From d2f17d31d86e8fc5dea19cab226461f1d817db05 Mon Sep 17 00:00:00 2001 From: Mikhail Volkhov Date: Mon, 30 Sep 2024 14:39:36 +0200 Subject: [PATCH 1/2] Update mina version; bindings are the same --- MINA_COMMIT | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MINA_COMMIT b/MINA_COMMIT index e3ab559d..0e0decc1 100644 --- a/MINA_COMMIT +++ b/MINA_COMMIT @@ -1 +1 @@ -The mina commit used to generate the backends for node and web is 9bdaae99904c13e3e10841ec6b778e45cdacabfb +The mina commit used to generate the backends for node and web is d68deacf78c2845e55e7fd8888e42571ac0fac97 From bfba51b9d8351b04af51bf6d59d5291cdb0490ce Mon Sep 17 00:00:00 2001 From: Florian Date: Tue, 1 Oct 2024 14:15:37 +0200 Subject: [PATCH 2/2] bindings --- compiled/node_bindings/o1js_node.bc.map | 2 +- compiled/node_bindings/plonk_wasm.cjs | 2300 ++++++----- compiled/node_bindings/plonk_wasm.d.cts | 868 ++--- compiled/node_bindings/plonk_wasm_bg.wasm | Bin 4839545 -> 4840970 bytes .../node_bindings/plonk_wasm_bg.wasm.d.ts | 880 ++--- compiled/web_bindings/plonk_wasm.d.ts | 2306 +++++------ compiled/web_bindings/plonk_wasm.js | 3430 ++++++++--------- compiled/web_bindings/plonk_wasm_bg.wasm | Bin 3839390 -> 3874592 bytes compiled/web_bindings/plonk_wasm_bg.wasm.d.ts | 952 ++--- 9 files changed, 5368 insertions(+), 5370 deletions(-) diff --git a/compiled/node_bindings/o1js_node.bc.map b/compiled/node_bindings/o1js_node.bc.map index 1e37266b..736f67bb 100755 --- a/compiled/node_bindings/o1js_node.bc.map +++ b/compiled/node_bindings/o1js_node.bc.map @@ -1 +1 @@ -{"version":3.0,"file":"o1js_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","tsBindings","caml_bigint_256_bytes_per_limb","caml_bigint_256_compare","caml_bigint_256_div","caml_bigint_256_num_limbs","caml_bigint_256_of_bytes","caml_bigint_256_of_decimal_string","caml_bigint_256_of_numeral","caml_bigint_256_print","caml_bigint_256_test_bit","caml_bigint_256_to_bytes","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_create_bytes","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","plonk_wasm","require","tsRustConversion","caml_fp_srs_b_poly_commitment","srs","chals","caml_fp_srs_batch_accumulator_check","comms","rust_comms","rust_chals","ok","caml_fp_srs_batch_accumulator_generate","n_comms","tsSrs","caml_fp_srs_create","caml_fp_srs_h","caml_fp_srs_lagrange_commitment","caml_jsstring_of_string","caml_fp_srs_read","path","caml_fp_srs_write","append","caml_fp_vector_create","caml_fp_vector_emplace_back","caml_fp_vector_get","caml_fp_vector_length","caml_fq_srs_add_lagrange_basis","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","caml_utf8_of_utf16","caml_bytes_of_utf16_jsstring","caml_string_of_jsstring","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","pos","clen","new_str","old_data","MlFakeDevice","Symbol","name_slash","mode","raise_unix","parent","RegExp","seen","file","bytes","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_to_array","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","value","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_compare","caml_pasta_fp_copy","caml_pasta_fp_div","caml_pasta_fp_domain_generator","caml_pasta_fp_equal","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_mut_square","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_pasta_fp_plonk_gate_vector_add","free_finalization_registry","instance_representative","free_on_finalize","caml_pasta_fp_plonk_gate_vector_create","caml_bytes_of_uint8array","uint8array","ocaml_bytes","caml_pasta_fp_plonk_gate_vector_digest","caml_pasta_fp_plonk_gate_vector_get","caml_pasta_fp_plonk_gate_vector_len","caml_pasta_fp_plonk_gate_vector_wrap","caml_pasta_fp_plonk_index_create","gates","public_inputs","caml_lookup_tables","caml_runtime_table_cfgs","prev_challenges","urs","wasm_lookup_tables","wasm_runtime_table_cfgs","caml_pasta_fp_plonk_index_create_bytecode","caml_pasta_fp_plonk_index_read","caml_pasta_fp_plonk_index_write","caml_pasta_fp_plonk_proof_batch_verify","indexes","proofs","caml_pasta_fp_plonk_proof_create","witness_cols","caml_runtime_tables","prev_sgs","wasm_runtime_tables","proof","caml_pasta_fp_plonk_proof_verify","caml_pasta_fp_plonk_verifier_index_create","vk","caml_pasta_fp_plonk_verifier_index_read","caml_pasta_fp_plonk_verifier_index_shifts","log2_size","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_square","caml_pasta_fp_sub","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_compare","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_mut_square","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_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_pasta_fq_plonk_index_create","caml_pasta_fq_plonk_index_create_bytecode","caml_pasta_fq_plonk_index_domain_d1_size","caml_pasta_fq_plonk_index_read","caml_pasta_fq_plonk_index_write","caml_pasta_fq_plonk_proof_batch_verify","caml_pasta_fq_plonk_proof_create","caml_pasta_fq_plonk_proof_verify","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_square","caml_pasta_fq_sub","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","decr_nat","borrow","deferred_of_promise","promise","deferred","deferred_bind","func","input","anotherDeferred","deferred_create","promise_creator","resolve","deferred_map","deferred_peek","deferred_return","deferred_run","Error","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","wrap","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","fp_oracles_create","lgr_comm","verifier_index","fp_oracles_create_no_public","fq_oracles_create","fq_oracles_create_no_public","getTsBindings","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","z1","ml_z_add","z2","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","tp_loc$5","tp_loc$6","name$28","tp_loc$7","tp_loc$8","name$29","tp_loc$9","tp_loc$10","name$30","tp_loc$11","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$14","all$2","name$82","tp_loc$15","name$83","module_name$25","name$84","name$85","suffix$6","suffix","tp_loc$16","module_name$26","module_name$27","suffix$13","module_name$28","name$86","name$87","module_name$29","tp_loc$17","tp_loc$18","atom","record$1","label","ocaml_lex_tables$1","ocaml_lex_tables$2","ocaml_lex_tables$3","op","fmt$0","fmt$1","pos$0","slots","slots$0","name$89","here","tp_loc$19","none$1","arg$0","tp_loc$20","level_bits$0","here$0","here$1","here$2","here$3","here$4","here$5","tp_loc$21","tp_loc$22","tp_loc$23","tp_loc$24","list$1","tp_loc$25","list$2","tp_loc$26","empty$15","v_print_debug_messages_for","environment_variable","job_queue","deferred0","deferred1","monitor","import0","error$0","pos$1","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$2","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","state$0","tp_loc$27","tp_loc$28","name$95","module_name$31","name$96","tp_loc$29","tp_loc$30","tp_loc$31","pos$3","label$1","pos$4","tp_loc$32","tp_loc$33","tp_loc$34","pos$5","tp_loc$35","tp_loc$36","tp_loc$37","tp_loc$38","state$13","state$12","state$11","state$10","state$9","state$8","state$7","state$6","state$5","state$4","state$3","state$2","state$1","feature_flags","maybe","tp_loc$39","none$5","actual_feature_flags","tp_loc$40","tp_loc$41","tp_loc$42","tp_loc$43","tp_loc$44","tp_loc$45","tp_loc$46","tp_loc$47","tp_loc$48","tp_loc$49","tp_loc$50","tp_loc$51","tp_loc$52","tp_loc$53","state$14","tp_loc$54","start$2","expected$0","tp_loc$55","pos$7","pos$6","pos$12","pos$11","pos$10","pos$9","pos$8","tp_loc$56","state$16","state$15","tp_loc$57","tp_loc$58","tp_loc$59","state$17","tp_loc$60","pos$13","tp_loc$61","tp_loc$62","pos$15","pos$14","tp_loc$68","tp_loc$63","tp_loc$64","tp_loc$65","tp_loc$66","tp_loc$67","pos$16","pos$19","pos$18","pos$17","name$97","id$5","name$98","id$6","pos$24","pos$23","pos$22","pos$21","pos$20","tp_loc$69","tp_loc$70","tp_loc$71","tp_loc$72","state$19","state$18","tp_loc$73","tp_loc$74","state$21","state$20","tp_loc$75","tp_loc$76","state$26","state$25","state$24","state$23","state$22","tp_loc$77","tp_loc$78","tp_loc$79","tp_loc$80","tp_loc$81","tp_loc$82","tp_loc$83","tp_loc$84","pos$31","pos$30","pos$29","pos$28","pos$27","pos$26","pos$25","state$29","initial_prefix","prefix$7","state$28","state$27","tp_loc$85","tp_loc$86","tp_loc$87","tp_loc$88","tp_loc$89","prefix$6","acc$0","state$31","state$30","tp_loc$90","tp_loc$91","tp_loc$92","pos$32","pos$34","pos$33","state$32","tp_loc$93","sponge_name","description$0","state$34","tp_loc$94","sponge_name$0","pos$42","pos$41","pos$40","pos$39","t2$2","t1$2","t2$3","t1$3","pos$38","pos$37","pos$36","pos$35","t2$0","t1$0","t2$1","t1$1","v0$0","t$7","pos$46","pos$45","pos$44","pos$43","t2$4","t1$4","t2$5","t1$5","t$8","state$46","state$45","state$41","state$42","state$43","state$44","state$36","state$37","state$38","state$39","state$40","tp_loc$95","tp_loc$96","pos$62","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","tp_loc$97","pos$63","tagname","branches","pos$65","pos$64","tp_loc$98","tp_loc$99","pos$66","pos$67","coinbase","proof_level","account_creation_fee_int","default_transaction_fee","default_snark_worker_fee","minimum_user_command_fee","genesis_state_timestamp","network","description$1","description$2","tp_loc$100","tp_loc$101","tp_loc$102","tp_loc$103","tp_loc$104","pos$69","message$1","state$48","tp_loc$109","state$47","tp_loc$105","tp_loc$106","tp_loc$107","tp_loc$108","hex_key_odd","hex_key_even","state$49","tp_loc$110","tp_loc$111","pos$70","coinbase$1","proof_level$0","account_creation_fee_int$0","default_transaction_fee$0","default_snark_worker_fee$0","minimum_user_command_fee$0","genesis_state_timestamp$0","network$0","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$6","t1$7","t1$8","pos$74","pos$73","pos$72","t2$7","t2$8","t2$9","key$1","pos$71","t2$6","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$50","v$105","x$0","state$51","tp_loc$112","tp_loc$113","pos$91","pos$90","t2$11","pos$89","pos$88","t2$10","pos$87","pos$86","description$3","state$53","state$52","tp_loc$114","tp_loc$115","env$1","tp_loc$117","err$3","tp_loc$116","description$4","tp_loc$118","state$54","tp_loc$119","tp_loc$120","description$5","pos$92","tp_loc$121","tp_loc$122","state$56","state$55","tp_loc$123","tp_loc$124","description$6","pos$95","pos$94","state$57","pos$93","tp_loc$125","tp_loc$126","pos$96","s$2","s$1","s$0","description$7","state$59","state$58","tp_loc$127","tp_loc$128","pos$97","tp_loc$129","tp_loc$130","empty$37","state$62","state$61","state$60","tp_loc$131","tp_loc$132","tp_loc$133","tp_loc$134","tp_loc$135","state$64","state$63","tp_loc$136","tp_loc$137","description$8","description$9","description$10","tp_loc$138","tp_loc$139","tp_loc$140","five","state$65","empty_stack_msg","salt_phrase","deriver_name","salt_phrase$0","deriver_name$0","salt_phrase$1","tp_loc$141","state$66","default$12","tp_loc$142","tp_loc$143","description$11","tp_loc$144","pos$102","pos$101","pos$100","pos$99","t2$13","pos$98","t2$12","tp_loc$145","tp_loc$146","tp_loc$147","epoch_data$0","dummy_value","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","tp_loc$172","tp_loc$173","tp_loc$174","state$71","state$70","state$69","tp_loc$175","description$12","tp_loc$176","tp_loc$177","state$73","state$72","tp_loc$178","description$13","tp_loc$179","state$75","state$74","tp_loc$180","description$14","tp_loc$181","state$80","state$79","state$78","state$77","state$76","tp_loc$182","description$15","description$16","tp_loc$183","tp_loc$184","description$17","tp_loc$185","tp_loc$186","tp_loc$187","tp_loc$188","tp_loc$189","tp_loc$190","tp_loc$191","tp_loc$192","tp_loc$193","tp_loc$194","state$84","state$83","state$82","state$81","description$18","description$19","tp_loc$195","names$1","tp_loc$196","names$2","tp_loc$197","tp_loc$198","state$86","state$85","tp_loc$199","tp_loc$200","pos$104","pos$103","tp_loc$201","tp_loc$202","transaction_id$1","expected_hash$1","transaction_id$0","expected_hash$0","transaction_id","expected_hash","v1_hashes","description$20","description$21","pos$105","update_failed","kind$3","tp_loc$203","tp_loc$204","tp_loc$205","tp_loc$206","tp_loc$207","tp_loc$208","tp_loc$209","tp_loc$210","tp_loc$211","nsf_tag","min_balance_tag","name$99","description$23","description$22","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","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","n$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","lr","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","expected","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","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","print_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","token","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_no_args","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","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$3","hash_fold_t$5","hash_fold_t$8","func$1","func$3","t$1","t$2","t$3","t$4","t$5","type_name","compare$11","compare_array","compare_elt","len_a","len_b","ret","compare_option","concat$1","ys","num_bits","word_size","formatter","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$5","bind$0","return$1","map$6","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$13","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$15","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","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$17","equal_array","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$15","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$6","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$7","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$8","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$21","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$23","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$24","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","tuple","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","label$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$26","map$27","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","small_positive_int","uniform_inclusive","log_uniform_inclusive","non_uniform","inclusive","log_inclusive","uniform_all","let_syntax_002","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","delta","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","b_002","hash_fold_t$22","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$23","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$24","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$25","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$26","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$27","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_read_t$27","t_of_sexp$25","sexp_of_t$36","equal$18","compare$45","bin_size_t$14","bin_write_t$14","bin_read_t$28","bin_read_t$29","typename_of_t$2","hash_fold_t$32","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","bin_read_array$2","compare_array$0","equal_array$0","group$45","bool$1","group$46","bin_shape_char$0","func$9","group$47","bin_shape_float$0","group$48","bin_shape_int","func$10","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","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$34","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$35","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","start$0","convert","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","shape_tbl","register","path_to_type","ty_decl","shape$0","canonical1","canonical2","create$49","substring","buffer_len","length$22","bytes_for_client_to_commit","offset_in_buffer","apply$5","unsafe_get_char","count_while","lift2","succ1","input1","more1","succ2","input2","more2","symbol$170","symbol$171","fail$0","more$0","marks","prompt","parser_uncommitted_bytes","parser_committed_bytes","continue$0","demand_input","ensure_suspended","go","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_yojson","poly_a","bin_writer_a","bin_reader_a","bin_a","versioned","to_latest","bin_shape_elt","of_yojson","to_yojson$0","max_string_len","symbol$172","bin_shape_t$71","bin_write_t$29","bin_read_t$58","to_string$37","of_string$38","create$50","length$23","sub$8","copy$4","init$9","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","xor","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$10","f3","md5_do_chunk","feed$2","to_fill","unsafe_feed_bytes$1","unsafe_feed_bigstring$1","unsafe_get$2","padlen","rol32","dup$2","init$11","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$12","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$13","sha256_do_chunk","feed$5","unsafe_feed_bytes$4","unsafe_feed_bigstring$4","unsafe_get$5","init$14","unsafe_get$6","dup$5","unsafe_feed_bytes$5","unsafe_feed_bigstring$5","rol64","dup$6","init$15","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","v$2","ror64$0","dup$7","init$16","sha512_do_chunk","feed$7","unsafe_feed_bytes$7","unsafe_feed_bigstring$7","unsafe_get$8","init$17","unsafe_get$9","dup$8","unsafe_feed_bytes$8","unsafe_feed_bigstring$8","init$18","init$19","init$20","init$21","dup$9","init$22","whirlpool_do_chunk","rc","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","digest_size_in_bits","digest_size_in_bytes","char_generator","gen$0","hash_fold_t$1","t_of_sexp$0","equal$0","bin_shape_typ","bin_writer_typ","bin_reader_typ","bin_typ","group$0","bin_shape_t_tagged","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","read_version","top_tag_versions","bin_read_top_tagged_to_latest","saved_pos","pos_ref$0","of_yojson$0","gen$1","of_hex$0","to_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","a_009","b_010","slots_per_tuple","arch_sixtyfour$0","max_slot","t0","t3","t4","t5","t13","masked_tuple_id_num_bits","max_array_length","tuple_id_mask","init$23","create$51","header_index","tuple_id","header_index_mask","invariant$9","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$54","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","dummy","tuple_num$0","create_with_dummy","capacity","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$10","set$9","t_of_sexp$46","sexp_of_t$55","validate$3","sexp_of_t$57","max_num_bits","invariant$10","of_int$6","symbol$173","symbol$174","pow2","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$59","v_level_bits","v_alarm_precision","bnd","create$52","level_bits","max_num_bits$0","num_keys","add_clamp_to_max","min_key_in_same_slot","min_key_in_same_slot_mask","value$3","next$5","pool","prev","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$60","v_how_to_dump","v_dump_if_delayed_by","t_of_sexp$49","sexp_of_t$61","equal$26","x_003","x_004","t_of_sexp$50","sexp_of_t$62","t_of_sexp$51","sexp_of_t$63","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","fields","name1","bnd$0","bnd$1","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","tail$1","field_sexp$19","sexp$2","alarm_precision_field","level_bits_field","capacity_field","duplicates$0","extra$0","field_sexp$18","sexp$0","num_key_bits","alarm_precision_value","sexp$3","sexp$4","fvalue$16","field_sexps$0","dump_if_delayed_by_field","how_to_dump_field","duplicates$1","extra$1","tail$0","field_sexp$20","sexp$1","how_to_dump_value","dump_if_delayed_by_value","fvalue$17","fvalue$18","fvalue$19","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","all$3","debug","debug$0","symbol$175","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$64","create_with_parent","dummy_e","dummy_f","dummy_a","create_array$0","create$53","sexpifier","none$2","is_none$1","is_some$1","create$55","enqueue$0","execution_context","priority","new_capacity","old_jobs","old_front","new_jobs","create$56","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$57","create2","run1","execution_context1","run2","execution_context2","enqueue$1","scheduler","schedule_jobs","add$18","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$5","of_binable$5","map$29","bind$14","map$30","symbol_map$2","bind$15","map$31","both$0","symbol_map$3","choices","unregisters","choices$0","choices$1","handler$0","handler$1","monitor$0","backtrace_history","column","monitor$1","name$1","backtrace$0","backtrace$1","traces","backtrace$2","list_if_not_empty","return$16","bind$16","map$32","return$17","apply$6","map$33","return$18","equal$27","combine$3","bs","sexp_of_t$66","v_pipe_id","v_values_read","values_sent_downstream","values_sent_downstream_and_flu","when_sent_downstream","fill_with_eof","sexp_of_t$67","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$24","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","pct","pot","mct","mot","loc$2","last$0","last$1","direct","map$38","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","constant$1","delim","mutable_flag","virtual_flag","rec_flag","nonrec_flag","direction_flag","private_flag","constant_string","tyvar","tyvar_loc","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","e0","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","p2","pattern1$0","pattern_list_helper","pat2","pat1","simple_pattern","pattern1","simple_pattern$0","po","closed","longident_x_pattern","with_paren","simple_name","lbl","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","typ","expr","attrs$0","md","class_constraint","class_type$3","class_declaration","cl$2","cl$1","constr","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","vl","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","co","type_with_label","print_indexop","path_prefix","print_index","indices","rem_args","print_path","other_args","print","i3","i2$0","i1$0","i1$1","left$0","txt$0","o$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","x1$1","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","x2$1","x1$8","x2$2","x1$9","x1$10","x1$11","x0$16","x3$0","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$1","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$3","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$0","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","all$4","lookup$1","drv","compare$80","equal$39","protectx$0","add$26","add_exn$3","find_opt$1","of_alist$5","alist$0","f$10","read_all_into","map$41","fold_right$6","symbol$183","concat$4","is_empty$12","filter_map$9","concat_map$2","assoc_opt","iter$32","is_some$2","map$42","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$4","raise_errorf$0","enter_module","enter_value$0","module_name$30","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_constr","pexp_ident","pexp_constant","pexp_let","pexp_fun","pexp_construct","pexp_variant","pexp_record","include_infos$0","ppat_any","ppat_variant","ppat_record","pstr_eval","pstr_value","value_binding$0","pat","short_name","name$92","flatten_exn","unflatten","parse$3","map$44","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","get$12","fold_dot_suffixes","collapse_after_at","parts","parts$1","parts$0","make$5","matches","matched","create_set","fully_qualified_names","attributes$0","list$5","is_whitelisted","reserve","is_in_reserved_namespaces","ignore_checks","create$65","current_file","string_of_context","get_all_for_context","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","all$0","other_contexts","current_context","a_or_an","rev_others","others","meths$0","nmeths","nvals","pstr","pstr_eval$0","restore_context","backup","parse$4","on_error","param$2","nil","symbol$184","symbol$185","map$45","many","rtag","get_pstr_eval","st","get_pstr_extension","get_psig_extension","get_attributes","get_attribute_if_is_floating_n","dummy_ext","name$93","registrar","declare","pattern","not_seen","mark_as_seen","do_mark_as_seen","get$13","longest_match","longest_match$1","longest_match$0","attr$0","name$94","declare$0","convert$0","check_attribute","item$0","item$1","closed_flag","fields$0","end_marker","end_marker_str","extract_prefix","remove_loc","remove_loc$0","prev$1","diff_asts","generated","round_trip","with_temp_file","fn1","fn2","dump","ast","cmd$0","parse_string","match_loop","mismatch_handler","source","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","split_normal_and_expect","split_normal_and_expect$0","filter$7","field$0","extension$0","attr_str_type_decl","attribute","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","sg","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","func$0","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$5","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","fp","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$66","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_all","derivers","derivers_and_args","named_generators","actual_deriver_name","dep","dep_name","add$28","extension$1","actual_deriver","deriver","invalid_with","generator_name_of_id","f$11","mk_deriving_attr","generator_name","disable_warnings_attribute","warning","inline_doc_attr","wrap_str","hide","warnings$0","warnings$2","warnings$1","include_infos","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$67","location$2","pattern$4","expression$3","create$68","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","Field","variant$2","variant_type","clauses","Clause","clauses$0","clause","lhs","rhs","empty$30","lookup$2","of_alist$6","variance_error","actual","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","arg_label","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","type","shrinker_intf","generator_intf","observer_intf","sig_type_decl$0","str_type_decl$0","rec_flag$0","generator_extension","observer_extension","shrinker_extension","fields$1","arg0","xs$2","xs$3","v3","v_transaction","v_network","v_patch","transaction_field","network_field","patch_field","patch_value","network_value","transaction_value","patch","transaction","of_string_exn","is_digit_string","of_string_opt","proposed_protocol_version_opt","set_proposed_opt","t_opt","get_proposed_opt","compatible_with_daemon","num_bits$5","compare$81","equal$40","symbol$186","symbol$187","of_int$7","symbol$188","symbol$189","symbol$190","symbol$191","to_int_exn$1","to_string$41","of_string$43","shift_left$6","shift_right$6","log_and","log_or","two_to_the_i","compare$82","is_integer_string","char_is_digit","of_string_base","of_string_no_underscores","group$74","bin_shape_t$72","bin_size_t$28","bin_write_t$30","bin_read_t$59","bin_read_t$60","arg_1$0","to_binable$6","of_binable$6","t_of_sexp$52","sexp_of_t$68","bin_size_t$29","bin_write_t$31","bin_read_t$61","bin_read_t$62","bin_shape_t$73","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$5","bits$3","extra_bytes","num_bytes","hash$46","to_string$43","char_is_hex_digit","of_hex_string_no_underscores","of_string$45","module_name$32","func$11","func$12","of_binable$7","write","simple$1","sync","set_sync_implementation","simple$2","read$0","ds","write$0","var_to_bits","equal$41","rhs1","rhs0","lhs1","lhs0","of_interval","canonicalize","a4","a3","disjoint_union_exn","of_intervals_exn","is","is$0","invariant$11","gen_from","min_size","gen_disjoint_pair","y0","y3","cvar_of_sexp","of_f","sexp_of_cvar","of_index","var$7","bind$1","return$2","unhandled","fail$2","run$2","req","hs","handle","req$1","create_single","request","bind$19","return$19","run$3","map2$4","read_var","read$1","value_of_fields","var_to_fields","field_vars","map$46","symbol_bind$6","symbol_map$4","bind$20","return$20","map$47","join$11","ignore_m$0","all$6","all_unit$0","run$4","rc$0","value$5","cases","add_case","case$3","sexp_of_basic","of_basic","unhandled$0","sexp_of_t$69","t_of_sexp$53","to_basic$0","map$48","get_value","override_label","label_opt","basic","equal$42","boolean$0","r1cs","annotation","unit$0","create$69","get$14","emplace_back","length$25","dummy_vector","get$15","T","make$6","num_inputs","next_auxiliary","system","eval_constraints","log_constraint","with_witness","is_running","eval_constraints$0","my_id","get_variable_value","store_field_elt","alloc_var","as_prover","set_as_prover","set_stack","set_handler","constraint_count","assert_equal","assert_all","assert_square","assert_r1cs","assert","with_label","handle_as_prover","exists_handle","request_witness","mk_lazy","create$70","stack_to_string","eval_constraints_ref","run$5","return$21","map$49","bind$21","symbol_bind$7","symbol_map$5","bind$22","return$22","map$50","join$12","ignore_m$1","all$7","all_unit$1","field_vec_id","pack_field_vec","field_vec","run_and_check_exn","get_one","final_id","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","next_input","primary_input","build","input_typ$0","return_typ$0","return_typ","input_typ","alloc_input","constraint_system_auxiliary","size_in_field_elements","var_of_fields","retvar","return_typ$1","input_typ$1","checked","run_computation","finish_computation","retvar$0","auxiliary_input_size","constraint_system","builder","generate_public_input","value_to_fields","store_field_elt$0","receive_public_input","input_var","output_var","first_auxiliary","auxiliary_input","handlers","finish_witness_generation","auxiliary_output_data","res_fields","output_fields","res_field","output_field","true_output","cont0","k0","generate_auxiliary_input","generate_witness_conv","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","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","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","to_field","of_field","typ$0","to_bits","ith_bit","if$0","then","else$0","t_of_sexp$54","non_empty_tree_of_sexp","tree_of_sexp","implied_root","entry_hash","addr0","path0","addr","let_syntax_001","fetch_and_update_req","prev_path","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$0","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","assert$0","exists$1","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","any$1","all$1","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","scale$1","scale$2","terms$1","to_constant_and_terms","neg_one","linear_combination","terms","var_indices","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","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","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","in_prover","in_checked_computation","as_stateful","make_checked","size_in_bits","of_int","sub$0","sqrt$0","is_square$0","size_in_bits$0","print$0","random$0","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","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","negate$1","symbol$19","symbol$20","unpack$2","project$1","parity$2","run_prover","mark_active","counters","mark_active_deferred","compute$0","inject_wrapper","finalize_is_running","cached_state","constraint_system_manual","cached_active_counters","run_circuit","circuit","return_var","generate_witness_manual","as_prover_manual","size_to_witness","old_as_prover","values_to_witness","values_to_witness$0","request_manual","unit_request","prover_block","this_functor_id","run_checked","to_int$6","of_int$9","add$29","eq$4","create$71","N","pi","t_plus_n","compare$83","lte_exn","eq$5","eq_exn","num_commitments_without_degree","to_nat","contr","singleton$2","func$13","length$26","func$14","hhead_off","xss$0","tls","hds","mapn","nth$6","idx$0","idx$1","zip","to_list$9","to_array$4","init$27","map$51","of_list$7","of_list_and_length_exn","of_array_and_length_exn","fold$18","for_all$9","foldi$4","reduce_exn$1","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","of_list_exn","there$0","back$0","append$5","adds","adds$0","rev$1","split$6","transpose","tails","heads","trim_front","extend_front_exn","extend_exn","extended","extend_front","bin_shape_t$74","bin_size_t$30","bin_write_t$32","bin_read_t$63","compare$84","hash_fold_t$38","equal$43","to_yojson$1","t_of_sexp$55","sexp_of_t$70","bin_shape_t$75","bin_size_t$31","bin_write_t$33","bin_read_t$64","bin_read_t$65","compare$85","hash_fold_t$39","equal$44","to_yojson$2","of_yojson$1","t_of_sexp$56","sexp_of_t$71","compare$86","hash_fold_t$40","equal$45","to_yojson$3","of_yojson$2","t_of_sexp$57","sexp_of_t$72","bin_shape_t$76","bin_size_t$32","bin_write_t$34","bin_read_t$66","compare$87","hash_fold_t$41","equal$46","to_yojson$4","of_yojson$3","t_of_sexp$58","sexp_of_t$73","compare$88","hash_fold_t$42","equal$47","to_yojson$5","of_yojson$4","t_of_sexp$59","sexp_of_t$74","to_list$10","bin_shape_t$77","bin_size_t$33","bin_write_t$35","bin_read_t$67","compare$89","hash_fold_t$43","equal$48","to_yojson$6","of_yojson$5","t_of_sexp$60","sexp_of_t$75","compare$90","hash_fold_t$44","equal$49","to_yojson$7","of_yojson$6","t_of_sexp$61","sexp_of_t$76","bin_shape_t$78","bin_size_t$34","bin_write_t$36","bin_read_t$68","compare$91","hash_fold_t$45","equal$50","to_yojson$8","of_yojson$7","t_of_sexp$62","sexp_of_t$77","to_yojson$9","of_yojson$8","bin_shape_t$79","bin_size_t$35","bin_write_t$37","bin_read_t$69","compare$92","hash_fold_t$46","equal$51","to_yojson$10","of_yojson$9","t_of_sexp$63","sexp_of_t$78","compare$93","equal$52","t_of_sexp$64","sexp_of_t$79","of_list_exn$0","bin_shape_t$80","bin_size_t$36","bin_write_t$38","bin_read_t$70","compare$94","hash_fold_t$47","equal$53","to_yojson$11","of_yojson$10","t_of_sexp$65","sexp_of_t$80","compare$95","hash_fold_t$48","equal$54","to_yojson$12","of_yojson$11","t_of_sexp$66","sexp_of_t$81","bin_shape_t$81","bin_size_t$37","bin_write_t$39","bin_read_t$71","compare$96","hash_fold_t$49","equal$55","to_yojson$13","of_yojson$12","t_of_sexp$67","sexp_of_t$82","compare$97","hash_fold_t$50","equal$56","to_yojson$14","of_yojson$13","t_of_sexp$68","sexp_of_t$83","F","to_yojson$15","poly_f","symbol$204","group$75","bin_shape_t$82","bin_size_t$38","size_of_f","bin_write_t$40","write_f","bin_writer_t$38","bin_writer_f","bin_read_t$72","bin_read_t$73","bin_reader_t$38","bin_reader_f","bin_t$38","bin_f","t_of_sexp$69","sexp_of_t$84","compare$98","cmp_f","equal$57","hash_fold_t$51","hash_fold_f","a0","to_yojson$16","symbol$205","t_of_sexp$70","sexp_of_t$85","compare$99","hash_fold_t$52","typ$2","map$52","map$53","create$72","equal$58","to_yojson$17","symbol$206","group$76","bin_shape_t$83","bin_size_t$39","bin_write_t$41","bin_writer_t$39","bin_read_t$74","bin_read_t$75","bin_reader_t$39","bin_t$39","versioned$0","t_of_sexp$71","sexp_of_t$86","compare$100","b_020","a_019","equal$59","a_021","b_022","b_024","a_023","hash_fold_t$53","to_yojson$18","symbol$207","t_of_sexp$72","sexp_of_t$87","compare$101","a_025","b_026","b_028","a_027","hash_fold_t$54","typ$3","func$15","map$54","create$73","of_field$0","to_field$0","equal$60","f$12","maxes","just","nothing$0","to_option_unsafe","value_exn$1","of_option","symbol$208","func$16","constant_layout_typ","bool_typ","a_typ","dummy_var","bool_typ$0","bool_typ$1","typ$4","group$77","bin_shape_t$84","t_of_sexp$73","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","foreign_field_mul","foreign_field_add","range_check1","range_check0","of_hlist","of_full","to_full","lookup_pattern_range_check","table_width_at_least_2","table_width_at_least_1","lookups_per_row_4","lookups_per_row_3","to_data","map$55","to_yojson$19","fields$2","fields$3","fields$4","fields$5","fields$6","fields$7","fields$8","fields$9","fields$10","x$10","fields$11","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","symbol$209","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","xs$18","x$16","xs$17","x$15","xs$16","x$14","xs$15","xs$14","xs$25","x$23","xs$24","x$22","xs$23","x$21","xs$22","x$20","xs$21","x$19","xs$20","x$18","group$78","bin_shape_t$85","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$42","bin_read_t$76","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$74","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","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","sexp_of_t$88","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","compare$102","a_013","b_014","a_015","b_016","a_033","b_034","a_035","b_036","n$19","n$20","a_045","b_046","n$21","a_047","b_048","n$22","hash_fold_t$55","hash_fold_a","hsv$1","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","equal$61","a_057","b_058","a_059","b_060","a_061","b_062","a_063","b_064","a_065","b_066","a_067","b_068","a_069","b_070","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","t_of_sexp$75","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","to_hlist$1","of_hlist$1","field$1","map$56","to_list$11","always_present","optional_gates","to_absorption_sequence","to_in_circuit","map$57","to_list$12","group$79","to_hlist$2","evals","public_input","of_hlist$2","to_hlist$3","of_hlist$3","p1","f$13","group$80","f_multi","to_hlist$4","ft_eval1","of_hlist$4","to_hlist$5","of_hlist$5","typ$5","Impl","num_chunks","single","uses_lookups","lookups_per_row_3$0","lookups_per_row_4$0","evals$0","to_yojson$20","poly_g","poly_fq","symbol$210","group$81","bin_shape_t$86","fq","bin_size_t$41","size_of_g","size_of_fq","bin_write_t$43","write_g","write_fq","bin_read_t$77","of_g","of_fq","v_lr","v_z_1","v_z_2","v_delta","v_challenge_polynomial_commitm","t_of_sexp$76","lr_field","z_1_field","z_2_field","delta_field","challenge_polynomial_commitmen","challenge_polynomial_commitmen$0","delta_value","z_2_value","z_1_value","lr_value","sexp_of_t$89","compare$103","cmp_g","cmp_fq","a_245","b_246","a_247","b_248","t_250","t_249","t_252","t_251","hash_fold_t$56","hash_fold_g","hash_fold_fq","equal$62","a_253","b_254","a_255","b_256","t_258","t_257","t_260","t_259","to_hlist$6","z_2","z_1","of_hlist$6","group$82","sexp_of_t$90","of_fqv","v_ft_eval1","v_evals","v_proof","arg$31","bnds$29","arg$24","bnds$30","arg$25","bnds$24","arg$26","bnds$25","arg$27","bnds$26","arg$28","bnds$27","arg$29","bnds$28","arg$30","bnds$31","compare$104","cmp_fqv","a_301","b_302","cmp_fq$0","a_305","b_306","cmp_g$0","a_303","b_304","n$27","a_263","b_264","t_266","t_265","t_268","t_267","n$23","n$24","n$25","n$26","a_307","b_308","t_310","t_309","t_312","t_311","n$28","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","a_111","b_112","a_113","b_114","a_115","b_116","a_117","b_118","a_119","b_120","a_121","b_122","a_123","b_124","a_125","b_126","a_127","b_128","a_129","b_130","a_131","b_132","to_yojson$21","symbol$211","group$83","bin_shape_t$87","bin_size_t$42","bin_write_t$44","bin_read_t$78","t_of_sexp$77","sexp_of_t$91","compare$105","a_341","b_342","a_343","b_344","hash_fold_t$57","equal$63","a_345","b_346","a_347","b_348","to_yojson$22","symbol$212","compare$106","a_349","b_350","a_351","b_352","equal$64","a_353","b_354","a_355","b_356","group$84","bin_shape_t$88","to_hlist$7","aggreg","sorted_5th_column","of_hlist$7","to_hlist$8","of_hlist$8","group$85","bin_shape_t$89","to_hlist$9","t_comm","z_comm","w_comm","of_hlist$9","to_hlist$10","of_hlist$10","typ$7","commitment_lengths","w_lens","wo","g$0","fqv","group$86","t_of_sexp$78","of_g$0","field_sexps$1","messages_field","openings_field","proof_field","evals_field","ft_eval1_field","ft_eval1_value","evals_value","proof_value","w_comm_field","z_comm_field","t_comm_field","aggreg_field","runtime_field","runtime_value","aggreg_value","t_comm_value","z_comm_value","w_comm_value","openings_value","messages_value","t_of_sexp$79","field_sexps$2","duplicates$2","extra$2","tail$2","sorted_5th_column_field","sorted_5th_column_value","equal$65","a_483","b_484","cmp_g$1","a_485","b_486","a_439","b_440","a_441","b_442","a_443","b_444","a_445","b_446","a_447","b_448","a_449","b_450","a_451","b_452","a_383","b_384","a_385","b_386","a_387","b_388","cmp_fqv$0","a_491","b_492","cmp_fq$1","a_489","b_490","a_317","b_318","a_487","b_488","a_271","b_272","t_274","t_273","t_276","t_275","a_319","b_320","t_322","t_321","t_324","t_323","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","a_149","b_150","a_151","b_152","a_153","b_154","a_155","b_156","a_157","b_158","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_171","b_172","group$87","bin_shape_t$90","comm","bin_size_t$43","size_of_comm","bin_write_t$45","write_comm","bin_read_t$79","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$80","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","endomul_scalar_comm","emul_comm","mul_comm","complete_add_comm","psm_comm","generic_comm","coefficients_comm","sigma_comm","of_hlist$11","map$58","typ$8","func$17","f_opt","lookup_selector_ffmul","lookup_selector_range_check","lookup_selector_xor","lookup_selector_lookup","runtime_tables_selector","lookup_table_ids","lookup_table_comm","rot_comm","foreign_field_mul_comm","foreign_field_add_comm","range_check1_comm","range_check0_comm","xor_comm","combine_split_commitments","scale_and_add","xi","reduce_without_degree_bound","reduce_with_degree_bound","without_degree_bound","with_degree_bound","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$8","bin_shape_t$91","bin_size_t$44","bin_write_t$46","bin_read_t$80","of_binable$9","of_char_exn","to_int$7","decode","encode","byte$0","charify","hexified","to_u4","map$59","round_constants","mds","pasta_p_legacy","pasta_p_kimchi","pasta_q_kimchi","id$4","make$7","sponge_state","sponge_state_of_sexp","sexp_of_sponge_state","copy","rate","absorb","squeeze","operation","sponge","fe","to_blocks","field_elems","num_blocks","create_block","global_pos","first_half_rounds_full","block_cipher","sbox","constant_offset","second_half_rounds_full","not_implemented","to_binable$7","of_binable$10","path$2","empty$31","log$1","internal","empty_quartiles","allocation_times","now$0","get_lifetime_ms","mean","lifetimes","q1","q2","q3_offset","q3","q4","compute_statistics","run_test","time_offsets","expected_quartiles","message$0","comparator$0","comparator$1","message$2","message$3","comparator$3","table$0","attach_finalizer","object_id","info_opt","data_opt","statistics","json","block_on_async_exn","to_deferred","map$60","bind$23","return$23","symbol_bind$8","symbol_map$6","bind$24","return$24","map$61","join$13","get$16","t_of_sexp$81","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$62","n_next","n_prev","ss","accs","to_yojson$23","symbol$213","group$88","bin_shape_t$92","bin_size_t$45","bin_write_t$47","bin_read_t$81","v_inner","t_of_sexp$82","inner_field","inner_value","sexp_of_t$92","compare$107","equal$66","hash_fold_t$58","to_yojson$24","of_yojson$14","t_of_sexp$83","sexp_of_t$93","compare$108","equal$67","hash_fold_t$59","typ$9","map$63","y_squared","t_004","t_003","t_005","t_010","t_012","t_011","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","shifted$0","unshifted","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$89","v_challenges","v_commitment","challenges_field","commitment_field","commitment_value","challenges_value","hash_fold_array","poly_fqv","poly_g$0","arg1$2","arg0$2","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_openings","a_455","b_456","a_391","b_392","a_393","b_394","a_395","b_396","a_397","b_398","a_399","b_400","a_401","b_402","a_403","b_404","a_363","b_364","a_365","b_366","a_281","b_282","a_457","b_458","a_283","b_284","t_286","t_285","t_288","t_287","t_of_sexp$2","hash_fold_fqv","a_465","b_466","a_407","b_408","a_409","b_410","a_411","b_412","a_413","b_414","a_415","b_416","a_417","b_418","a_419","b_420","a_369","b_370","a_371","b_372","a_293","b_294","a_467","b_468","a_295","b_296","t_298","t_297","t_300","t_299","map_creator","messages","openings","to_latest$0","path$0","fields$30","fields$43","fields$31","fields$25","fields$26","fields$27","fields$28","fields$29","fields$32","fields$44","fields$38","fields$33","fields$34","fields$35","fields$36","fields$37","fields$39","fields$40","fields$41","fields$42","fields$45","arg1$3","arg0$3","xs$26","xs$27","arg3$1","arg2$2","arg3$0","a_475","b_476","a_423","b_424","a_425","b_426","a_427","b_428","a_429","b_430","a_431","b_432","a_433","b_434","a_435","b_436","a_375","b_376","a_377","b_378","a_379","b_380","a_477","b_478","t_of_sexp$3","sexp_of_t$3","v_sorted_5th_column","hsv$33","hsv$29","hsv$30","hsv$31","hsv$32","hsv$24","hsv$25","hsv$26","hsv$27","hsv$28","map_creator$0","create$1","compare$3","id$1","map_creator$1","sexp_of_t$4","fq_array_to_vec","vec","opening_proof_of_backend_exn","gpair","g2","g1","eval_of_backend","evals_to_tuple","zeta_omega","zeta","gs","of_backend_with_public_evals","eval_to_backend","vec_to_array","V","evals_of_tuple","chal_polys","pcwo","lr$0","challenges","to_backend$0","to_backend_with_public_evals","public_evals","to_backend_with_public_evals$0","extract_challenges_and_commitm","commitments","pk","primary","auxiliary","prev_comms","prev_chals","create_async","batch_verify","logger","vks_and_v","batch_verify$0","prev_challenge","pi$0","create_with_public_evals","scalar_challenge","beta","joint_combiner_chal","joint_combiner","digest_before_evaluations","p_eval_1","p_eval_2","opening_prechallenges","columns","permutation_cols","map$64","s3","yr","xr","n_acc","yp","xp","yt","xt","map$65","x7","x6","x5","a8","b0","n8","n0","all_tag_versions","bin_read_all_tagged_to_latest","domain_generator","over","t_of_sexp$84","compare$109","compare$110","cmp_row","to_rust_wire","col","row","t_of_sexp$85","of_v","field_sexps$12","l_field","r_field","o_field","c_field","duplicates$12","extra$12","tail$7","field_sexp$60","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$59","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$58","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$57","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$56","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","field_sexps$14","id_field$0","data_field","duplicates$14","extra$14","tail$9","field_sexp$55","field_sexp$50","field_sexp$51","fvalue$43","field_sexp$52","fvalue$44","data_value","id_value$0","field_sexps$13","id_field","first_column_field","duplicates$13","extra$13","tail$8","field_sexp$54","field_sexp$47","field_sexp$48","fvalue$41","field_sexp$49","fvalue$42","first_column_value","id_value","kind_field","values_field","coeffs_field","field_sexp$53","coeffs_value","values_value","kind_value","sexp_of_t$94","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$32","bnds$33","bnds$34","arg$32","bnds$35","arg$33","bnds$36","arg$34","bnds$37","arg$35","bnds$38","arg$36","bnds$39","arg$37","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_data","bnds$149","arg$146","bnds$150","arg$147","bnds$151","v_first_column","v_id$0","arg$148","bnds$152","arg$149","bnds$153","v_coeffs","v_values","v_kind","arg$150","bnds$154","arg$151","bnds$155","arg$152","bnds$156","map$66","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","first_column","coeffs","eval_one","vo","vr","cr","vl$0","vr$0","vo$0","compare$111","hash_fold_t$60","a0$0","hash$47","t_of_sexp$86","sexp_of_t$95","get_concatenated_fixed_lookup_","flts","flt","get_concatenated_runtime_looku","rt_cfgs","rt_cfg","finalize_fixed_lookup_tables","fixed_lt_rev","finalize_runtime_lookup_tables","rt_cfgs_rev","t_018","t_017","t_020","t_019","compute_witness","external_values","internal_values","num_rows","custom_printf_029","i_after_input","cols","row_idx","col_idx","map_runtime_tables","cfgs","rt_idx","compute_value","vidx","vv","id_int32","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","get_concatenated_fixed_lookup_$0","get_concatenated_runtime_looku$0","wire","add_row","vars_for_perm","finalize_and_get_gates","runtime_tables_cfg$0","gates_rev","fixed_lookup_tables","runtime_tables_cfg","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","gate","gates$0","relative_row","add_gates","wired_to","wired_to$0","wires","md5_digest","num_constraints","to_json","add_generic_constraint","coeffs2","o2","coeffs$0","red","terms$0","terms_list","lx","go$0","lx$0","rs","s1x1_plus_s2x2","reduce_to_v","xo","xo$0","x3$1","x3$2","ratio","ratio$0","red_pr","l_s","r_s","coeff","add_round_state","s5","s4","reduce_curve_point","x3$3","curr_row","add_endoscale_round","vars$1","add_endoscale_scalar_round","red_w0","red_w1","red_w2","red_w3","red_w4","red_w5","red_w6","vars$2","lookup1","lookup2","lookup3","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","runtime_table_cfgs","prev_challenges$0","prev_challenges$1","array_to_vector","vk_commitments","full_vk_commitments","to_list$14","of_list$8","group3","pt","pt$0","tuples","string_bits","test_bit","to_bytes$0","bit","of_bytes$0","hash$48","hash_fold_t$61","to_yojson$25","of_yojson$15","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$90","bin_shape_t$93","group$91","bin_shape_t$94","bin_size_t$46","bin_write_t$48","bin_read_t$82","of_bytes$1","to_bytes$1","of_decimal_string","to_string$44","test_bit$0","div$1","compare$112","num_limbs","bytes_per_limb","to_hex","to_hex_string","of_hex_string","of_numeral","double$1","one$8","symbol$214","double$2","one$9","to_affine_exn$0","of_affine$0","symbol$215","make$8","unshifted$0","make$9","sponge_params","params$1","to_field$1","of_field$1","with_lagrange","domain_size","vks","create_aux$0","backend_create","computed_witness","create$74","to_binable$8","of_binable$11","create$75","of_data$0","to_field$2","of_field$2","with_lagrange$0","create_aux$1","create_async$0","create$76","to_binable$9","of_binable$12","create$77","create_with_public_evals$0","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$92","bin_shape_t$97","group$93","bin_shape_t$98","group$94","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$216","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","wrap$2","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$25","map$67","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","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$95","bin_shape_t$99","bin_write_t$51","bin_read_t$87","t_of_sexp$88","sexp_of_t$97","hash_fold_proofs_verified","path$3","to_int$8","of_int_exn$4","to_input$0","to_input$1","one_hot","typ$10","group$96","bin_shape_t$100","path$4","group$97","bin_shape_t$101","bin_read_t$88","group$98","bin_shape_t$102","bin_size_t$49","bin_write_t$52","bin_read_t$89","group$99","bin_shape_t$103","group$100","bin_shape_t$104","t_of_sexp$89","sexp_of_t$98","compare$115","hash_fold_t$62","hash$49","path$5","equal$68","group$101","bin_shape_t$105","path$6","h$1","to_bits$0","to_yojson$26","symbol$217","of_yojson$16","yojson","to_hex$3","of_hex","sexp_of_t$99","t_of_sexp$90","to_yojson$27","symbol$218","group$102","bin_shape_t$106","path$7","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","domain","group$103","bin_shape_t$107","challenge","bin_size_t$50","size_of_challenge","bin_write_t$53","write_challenge","bin_read_t$90","of_challenge","v_prechallenge","to_yojson$28","poly_challenge","of_yojson$17","t_of_sexp$91","prechallenge_field","prechallenge_value","sexp_of_t$100","compare$116","cmp_challenge","hash_fold_t$63","hash_fold_challenge","equal$69","prechallenge","typ$11","chal","to_yojson$29","symbol$219","group$104","digest$0","size_of_digest","write_digest","bin_writer_t$42","bin_read_t$91","of_digest","bin_reader_t$42","bin_t$42","version$11","versioned$1","compare$117","of_digest$0","of_digest$1","hash_fold_digest","hash$50","equal$70","path$8","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","pack$1","typ$13","etyp$0","bp_challenge","group$105","to_hlist$13","zeta_to_domain_size","zeta_to_srs_length","of_hlist$13","to_minimal","group$106","to_hlist$14","branch_data","bulletproof_challenges","combined_inner_product","plonk","of_hlist$14","group$107","map_challenges","scalar","group$108","bin_shape_t$108","bin_size_t$51","size_of_g1","size_of_bulletproof_challenges","bin_write_t$54","write_g1","write_bulletproof_challenges","bin_read_t$92","of_g1","of_bulletproof_challenges","v_old_bulletproof_challenges","to_field_elements","g1_to_field_elements","old_bulletproof_challenges","scalar_challenge$0","group$109","to_hlist$15","messages_for_next_wrap_proof","sponge_digest_before_evaluatio","deferred_values","of_hlist$15","bulletproof_challenges$0","bool$2","fp$0","scalar_challenge$1","challenge$0","group$110","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$111","f8","f7","f6","f5","maybe_constant","feature_flags_spec","use","to_data$0","option_map","messages_for_next_step_proof","of_data$1","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$14","to_hlist$16","unfinalized_proofs","of_hlist$16","to_data$2","of_data$3","per_proof","hash_fold_t$64","hash$51","compare$118","t_of_sexp$92","sexp_of_t$101","hash_fold_t$65","hash$52","compare$119","t_of_sexp$93","sexp_of_t$102","equal$71","rhs0$0","lhs0$0","rhs0$1","lhs0$1","rhs0$2","lhs0$2","rhs0$3","lhs0$3","hash_fold_t$66","a0$1","a0$2","a0$3","hash$53","compare$120","t_of_sexp$94","sexp_of_t$103","constant_term","if_feature","unnormalized_lagrange_basis","vanishes_on_zero_knowledge_and","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","index_terms","constant_term$0","index_terms$0","pow2pow","shifts","shifts$0","zetaw","rounds","features","all_feature_flags","endo","field_of_hex","zk_rows","srs_length_log2","get_eval","omega_to_minus_1","omega_to_minus_2","next_term","omega_to_intermediate_powers","term","omega_to_zk_plus_1","omega_to_zk","omega_to_zk_minus_1","zk_polynomial","zeta_to_n_minus_1","feature","lazy_flag","omega_to_zk_plus_1$0","w_to_i","omega_pow","perm_alpha0","ft_eval0","e0_s","zkp","zeta1m1","p_eval0","zeta1","p_eval0$0","w_n","ft_eval0$0","ft_eval0$1","nominator","ft_eval0$2","derive_plonk","w0$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","version_byte$18","checksum_len","version_string","compute_checksum","ctx0","ctx1","ctx2","first_hash","ctx3","second_hash","checksum","decode_exn","decoded","error_str","check_encoding","to_base58_check","of_base58_check","of_base58_check_exn","to_base64","of_base64","b64","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$121","to_yojson$30","of_yojson$18","sexp_of_t$104","t_of_sexp$95","compare$122","sexpifier$0","v_identifier","v_type","compare$123","to_int","compare$124","t_of_sexp$96","state_hash_field","blockchain_length_field","global_slot_since_genesis_fiel","global_slot_since_genesis_valu","blockchain_length_value","state_hash_value","sexp_of_t$105","v_global_slot_since_genesis","v_blockchain_length","v_state_hash","compare$125","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","header_version","to_yojson$31","compare$126","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$112","bin_shape_t$109","path$9","group$113","bin_shape_t$110","path$10","group$114","bin_shape_t$111","compare$127","a_265","b_266","t_016","t_015","t_078","t_077","t_080","t_079","t_084","t_083","t_086","t_085","t_088","t_087","t_090","t_089","t_094","t_093","t_096","t_095","t_098","t_097","t_100","t_099","t_102","t_101","t_104","t_103","t_106","t_105","t_108","t_107","t_110","t_109","t_116","t_115","t_118","t_117","t_120","t_119","a_273","b_274","a_267","b_268","t_270","t_269","t_272","t_271","sexp_of_t$106","v_bulletproof","v_evaluations","v_commitments","v1$11","v1$12","v1$13","v1$14","equal$72","a_275","b_276","t_024","t_023","t_026","t_025","t_028","t_027","t_029","t_034","t_126","t_125","t_128","t_127","t_132","t_131","t_134","t_133","t_136","t_135","t_138","t_137","t_142","t_141","t_144","t_143","t_146","t_145","t_148","t_147","t_150","t_149","t_152","t_151","t_154","t_153","t_156","t_155","t_158","t_157","t_160","t_159","t_162","t_161","t_164","t_163","t_166","t_165","t_168","t_167","a_277","b_278","t_280","t_279","t_282","t_281","path$11","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$6","to_field_checked","bits_msb","nybbles_per_row","rows","nybbles_by_row","mk","to_field_checked$0","to_field_constant","r_2i1","seal$0","rounds_rev","n_acc_prev","xq1","yq1","s1_squared","xq2","yq2","s3_squared","endo_inv","gy","gx","endo_to_field","base$0","scalar$0","endo_to_field$0","Impl$0","forbidden_shifted_values","two_to_n","neg_two_to_n","representatives","generate$0","keypair","forbidden_shifted_values$0","other_mod","high$0","check$5","x_eq","b_eq","typ$15","forbidden_shifted_values$1","typ$16","t0$0","check$7","typ_unchecked$1","typ$17","input$1","high_entropy_bits","to_the_alpha","add_assign","apply_affine_map","constants","matrix","dotv","copy$0","underlying","last_squeezed","squeeze_field","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","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","reduce_chunks","sigma_comm_last","sigma_comm_last$0","f_comm","chunked_t_comm","combined_evaluation","fx$0","fx$1","needs_final_permute_if_empty","of_sponge","add_in","i_equals_0","i_equals_j","cond_permute","permute","permuted","consume_pairs","pos_after","add_in_y_after_perm","add_in_y_before_perm","num_pairs","empty_imput","should_permute","consume_all_pending","pos_after$0","recombine","original_sponge","xs_curr","next_index_curr","curr_i","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","default$8","one$10","default$9","hash$54","ro","tock","tick","scalar_chal","evals_combined","f2$0","dummy_chals","challenges_computed","challenges_computed$0","group$115","bin_shape_t$112","bpcs","bin_size_t$52","size_of_s","size_of_challenge_polynomial_c","size_of_bpcs","bin_write_t$55","write_s","write_challenge_polynomial_com","write_bpcs","bin_read_t$93","of_s","of_challenge_polynomial_commit","of_bpcs","v_app_state","prepare","group$116","bin_shape_t$113","bin_read_t$94","path$12","t_of_sexp$97","sexp_of_t$107","hash_fold_t$67","f$14","read_step_circuit_field_elemen","prover_fe","sponge_params$0","one$11","group_size_in_bits","constant$4","typ$18","inv_exn","symbol$220","symbol$221","symbol$222","negate$2","inv_exn$0","symbol$223","symbol$224","symbol$225","equal$73","t_of_sexp$98","sexp_of_t$108","scale$3","zero$10","symbol$226","negate$3","to_affine_exn$1","of_affine$1","typ$19","typ_unchecked$2","constant$5","symbol$227","double$3","scale$4","to_field_elements$0","scale_inv","negate$4","one$12","if$3","h$2","max$25","hash_fold_vk","group$117","bin_shape_t$114","bin_size_t$53","bin_write_t$56","bin_read_t$95","bin_read_t$96","v_max_proofs_verified","v_actual_wrap_domain_size","v_wrap_index","path$13","versioned$2","func$18","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$13","bin_size_t$54","bin_write_t$57","bin_read_t$97","bin_read_t$98","bin_shape_t$115","bin_writer_t$43","bin_reader_t$43","bin_t$43","path$14","g$1","to_hlist$17","of_hlist$17","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$118","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$58","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$99","of_messages_for_next_wrap_proo","of_messages_for_next_step_proo","bin_read_t$100","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","of_f_multi$0","of_f_multi","v_public_input","v_evals$0","v_prev_evals","v_ft_eval1$0","sexp_of_t$110","of_bp_chals","of_challenge$0","most_recent_width","g0","tick_arr","lengths","poly_messages_for_next_step_pr","poly_messages_for_next_wrap_pr","arg1$4","arg0$4","arg1$5","arg0$5","arg1$6","arg0$6","arg1$7","arg0$7","poly_f_multi$0","poly_f_multi","fields$46","poly_bool","poly_scalar_challenge","fields$47","xs$51","xs$52","arg2$5","arg1$10","arg0$10","xs$53","x$32","xs$35","xs$36","xs$38","x$24","xs$37","xs$30","xs$31","xs$34","xs$29","state$35","xs$28","state$33","arg5$0","arg4$0","xs$33","xs$32","xs$54","x$33","xs$45","xs$46","arg2$4","arg1$9","arg0$9","xs$50","x$31","xs$49","x$30","xs$39","xs$40","arg2$3","xs$43","x$27","xs$42","x$26","xs$41","x$25","arg1$8","arg0$8","xs$48","x$29","xs$44","xs$47","x$28","xs$55","x$34","poly_f_multi$1","cmp_messages_for_next_step_pro","a_173","b_174","a_179","b_180","a_181","b_182","a_183","b_184","cmp_messages_for_next_wrap_pro","cmp_scalar_challenge","cmp_f_multi","t_194","t_193","t_196","t_195","a_197","b_198","t_200","t_199","t_202","t_201","app_state_field","old_bulletproof_challenges_fie","old_bulletproof_challenges_val","app_state_value","statement_field","prev_evals_field","sexp$5","of_challenge$1","of_scalar_challenge$0","proof_state_field","messages_for_next_step_proof_f","deferred_values_field","messages_for_next_wrap_proof_f","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","messages_for_next_step_proof_v","proof_state_value","sexp$6","commitments_field","evaluations_field","ft_eval1_field$0","bulletproof_field","bulletproof_value","ft_eval1_value$0","evaluations_value","commitments_value","sexp$7","evals_field$0","of_f_multi$1","public_input_field","public_input_value","evals_value$0","prev_evals_value","statement_value","hsv$43","hash_fold_messages_for_next_st","hash_fold_messages_for_next_wr","hash_fold_scalar_challenge","hsv$42","hash_fold_f_multi$0","hash_fold_f_multi","e0$0","e0$1","e0$2","e1$3","e0$3","e1$4","e0$4","hsv$34","e1$5","e0$5","hsv$35","hsv$36","e1$6","e0$6","hsv$37","hsv$38","e1$7","e0$7","hsv$39","hsv$40","hsv$41","a_195","b_196","a_201","b_202","a_207","b_208","a_209","b_210","a_211","b_212","a_187","b_188","t_208","t_207","t_210","t_209","t_214","t_213","t_216","t_215","prev_evals","statement","statement$0","prev_evals$0","to_yojson_full","group$119","bin_shape_t$117","bin_size_t$56","bin_write_t$59","bin_read_t$101","bin_read_t$102","path$15","of_yojson$19","to_yojson$32","sexp_of_t$111","t_of_sexp$100","hash$56","hash_fold_t$69","equal$75","compare$129","of_repr$0","to_repr$0","versioned$3","to_binable$11","of_binable$14","path$16","of_yojson$20","to_yojson$33","to_yojson_full$0","sexp_of_t$112","t_of_sexp$101","hash$57","hash_fold_t$70","equal$76","compare$130","group$120","bin_shape_t$118","bin_size_t$57","bin_write_t$60","bin_read_t$103","bin_read_t$104","path$17","of_yojson$21","to_yojson$34","sexp_of_t$113","t_of_sexp$102","hash$58","hash_fold_t$71","equal$77","compare$131","of_repr$1","to_repr$1","versioned$4","to_binable$12","of_binable$15","path$18","read_wrap_circuit_field_elemen","sponge_params$1","squeeze_field$0","one$13","group_size_in_bits$0","constant$6","typ$21","if$4","scale$5","inv_exn$1","symbol$228","symbol$229","symbol$230","negate$5","negate$6","square$3","inv_exn$2","symbol$231","symbol$232","symbol$233","assert_square$2","assert_r1cs$2","equal$79","t_of_sexp$104","sexp_of_t$115","scale$6","random$2","zero$11","symbol$234","negate$7","to_affine_exn$2","of_affine$2","multiscale_known$0","typ$22","typ_unchecked$3","constant$7","symbol$235","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","nones","maybes","none_sum","just_sum","just_is_yes","b_g","maybe_sum","maybe_is_yes","is_yes","no_2","maybe_2","yes_2","no_1","maybe_1","yes_1","b_x","lagrange","domains","which_branch","pts","scaled_lagrange","lagrange_with_correction","actual_shift","field2pow","two_to_actual_shift","base_and_correction","pr","h_precomp","finite","assert_finite","batch","without_bound","with_bound","reduce_point","point","keep","base_point","point$0","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","j1","zeta_1","gamma_1","beta_1","alpha_1","j0","zeta_0","gamma_0","beta_0","alpha_0","j1$0","j1$1","var_to_fields$0","assert_eq_plonk","index_to_field_elements","g_opt","simulate_optional_sponge_with_","sponge_state_before","state_before","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","correction","x_hat","x_hat$0","runtime$1","runtime$2","runtime$3","b_runtime","runtime_comm","runtime$0","compute_joint_combiner","absorb_sorted_1","absorb_sorted_2_to_4","absorb_sorted_5","z$2","sponge2$0","joint_combiner_if_true$0","sponge2","joint_combiner_if_true","joint_combiner$2","compute_lookup_table_comm","second_column","has_runtime","second_column_with_runtime","has_runtime$0","sum$1","second_with_runtime","rest_rev","comm$0","scaled_acc","comm$1","has_comm","scaled_acc$0","has_acc","comm$2","scaled_acc$1","comm$3","has_comm$0","scaled_acc$2","acc_with_comm","joint_combiner$0","joint_combiner$1","lookup_table_comm$0","lookup_table_comm$1","b_lookup_table_comm","lookup_sorted_minus_1","aggreg$0","sponge$0","sponge_before_evaluations","sigma_comm_init","ft_comm$0","len_1_add","len_1","len_2_add","len_2","len_3_add","len_4_add","len_5_add","len_5","len_6_add","len_6","append_chain","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","xi_actual","r_actual","xi_actual$0","xi$0","xi_correct","plonk_minimal","zeta_n","zetaw_n","combined_evals","evals2","evals1","ft","sg_evals$0","actual_combined_inner_product","combined_inner_product_correct","challenge_poly","b_actual","b_correct","plonk_checks_passed","to_hlist$18","of_hlist$18","to_hlist$19","of_hlist$19","shift$0","typ$23","create$82","find$17","lookup_compiled","other_id","lookup_side_loaded","set_ephemeral","eph","prover","ephemeral","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","corr","sponge_after_index","receive","domain$0","z_comm$0","t_comm$0","vanishing_polynomial","should_square","side_loaded_domain","max_n","vanishing_polynomial$0","pow2_pow","squeeze_challenge$0","domain_for_compiled","unique_domains","which_log2","lookups_per_row_2","actual_width_mask","opt_sponge","a_002","b_003","a_006","b_007","a_008","b_009","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","unfinalized","bulletproof_challenges_actual","bulletproof_success","hash_messages_for_next_step_pr$1","verify$0","to_hlist$20","prev_challenge_polynomial_comm","prev_proof_evals","wrap_proof","of_hlist$20","to_hlist$21","of_hlist$21","shift$1","dummy$1","one_chal","typ$24","dummy$2","create$83","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","lookup_table_comm3","lookup_table_comm2","lookup_table_comm1","lookup_table_comm0","lookup_pattern_xor","table_width_3","assert_consistent","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","ret_conv_inv","main$0","constraint_builder","range_check_table_used","combined_lookup_table_length","lookup_table_length_log2","group$121","bin_shape_t$119","path$19","group$122","bin_shape_t$120","bin_size_t$58","bin_write_t$61","bin_read_t$105","bin_read_t$106","v_constraints","path$20","poly_polyComm","poly_comm","poly_polyComm$0","arg8$0","arg7$0","arg6$0","versioned$5","of_repr$2","to_binable$13","of_binable$16","path$21","f_debug","num_choices","choices_length","num_choices$0","dummy_step_domains","dummy_step_widths","dummy_step_keys","compare$133","right_026","left_025","right_014","left_013","right_022","left_021","right_004","left_003","right_030","left_029","right_006","left_005","right_008","left_007","right_012","left_011","t_of_sexp$105","t_of_sexp$106","sexp_of_t$116","or_infinity_to_yojson","poly_comm_to_yojson","poly_caml_g","verifier_index_to_yojson","poly_fr","poly_srs","poly_poly_comm","step_verification_key_to_yojso","wrap_verification_key_to_yojso","get_proof","verification_key","for_vk","set_proof","is_env_var_set_requesting_erro","constant_term$1","index_terms$1","tick_rounds","AB","challenge_polys","which_eval","expand_deferred","tick_field","sc","plonk0","step_domain","w$0","tick_plonk_minimal","tick_combined_evals","tick_domain","tick_env","challenges_digest","lookup_final_terms","xi_chal","r_chal","actual_proofs_verified","combined_inner_product_actual","to_shifted","verify_heterogenous","chunking_data","expected_num_chunks","non_chunking","expected_domain_size","deferred_values$0","least_wrap_domain","match$2","actual_wrap_domain","accumulator_check","batch_verify_inputs","A_value","prepared_statement","dlog_check","comm_chals","verify_promise","a_value","create$84","wrap_domains$0","proofs_verifieds","auxiliary_typ","var_to_field_elements","value_to_field_elements","chain_to","rule","self_width","extract_lengths","len_ms","len_ns","branches$0","local_branches_length","local_signature_length","heights","widths","requests","output_typ","opt_wrap_key","compiled","wrap_key","known_wrap_keys","ld$0","ds$0","feature_flags_and_num_chunks","ns1","ns2","ln1","ln2","feature_flags_and_num_chunkss","feature_flags_and_num_chunkss$0","ln2$0","ln1$0","ns2$0","ns1$0","dummy_scalar_challenge","constant_typ","bool_typ_of_flag","prev_proof_typs","output_typ$0","auxiliary_var","ret_var","previous_proof_statements","ret_value","auxiliary_value","prevs","unfinalized_proofs_unextended","actual_wrap_domains","stmts","stmts$0","stmt","proofs$0","proof_witnesses","datas","messages_for_next_wrap_proofs","unfinalizeds","actual_wrap_domains$0","must_verify","unfinalizeds$0","messages_for_next_wrap_proofs$0","datas$0","proof_witnesses$0","pw","actual_wrap_domain$0","actual_wrap_domain$1","sponge_digest","prev_messages_for_next_step_pr","verified","self_data","optional_wrap_keys","optional_wrap_keys$0","optional_wrap_key","tags$0","zk_rows$0","num_chunks$0","wrap_key$0","previous_proof_statement","proof_must_verify","public_input$1","previous_proof_statements$0","own_domains","step$0","proof_cache","next_state","Maxes","prevs_length","self_dlog_plonk_index","self_dlog_vk","prev_vars_length","prev_values_length","expand_proof","dlog_vk","dlog_index","Local_max_proofs_verified","deferred_values_computed","x_hat_1","zeta$0","alpha$0","zetaw$0","prechals","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","prevs$0","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","sgs","prev_proofs$0","witnesses$0","x_hats$0","statements_with_hashes$0","wrap_vk$1","wrap_vk$0","domain_index","to_fold_in","next_proof","next_statement","conv_inv","next_statement_hashed","auxiliary_inputs","create_proof","proof_cache$0","proof_json","to_string$45","to_string$46","storable","header_read","vk_storable","read_or_generate","k_p","k_v","s_p","s_v","dirty","header_version_field","constraint_constants_field","length_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","identifying_hash_value","constraint_system_hash_value","length_value","constraint_constants_value","header_version_value","v_identifying_hash","v_constraint_system_hash","v_constraint_constants","v_header_version","t_022","to_string$47","to_string$48","storable$0","vk_storable$0","read_or_generate$0","vk$0","symbol$236","generate_or_load","pad_messages_for_next_wrap_pro","messages_len","maxes_len","maxes$0","maxes$1","default$10","promise_all","compile_with_wrap_main_overrid","disk_keys$0","override_wrap_domain","override_wrap_main","Branches","constraint_constants","storables","self$0","self$1","a_value_to_fields","a_var_to_fields","a_value_to_fields$0","a_var_to_fields$0","conv_irs","wrap_vk_storable","wrap_storable","step_vk_storable","step_storable","snark_keys_header","constraint_system_hash","constraint_constants$0","constraint_constants$1","prev_varss_length","prev_varss_n","padded","enabled","chain_to$0","step_data","all_step_domains","lock","cache_handle","accum_dirty","disk_keys","cs_hash","existing_lock","unlock","ks","step_keypairs","step_vks","step_keypairs$0","wrap_main$0","wrap_main$1","wrap_requests","self_id","disk_key_prover","wrap_disk_key","wrap_pk","computed_domain_size","ks$0","step_vk","step_pk","proof$0","tweak_statement","tweak_statement$0","which_index","prev_statement_with_hashes","x_hat_evals","shift_value","next_statement$0","next_accumulator","provers","cache_handle$0","typ$6","verify_promise$0","wrap_main_dummy_override","dummy_id","binable","of_compiled_promise","of_compiled","in_circuit","permanent","srs_precomputation","compile_promise","compile","identifier","proof_module","adjust_provers","compile_async","callback","dummy_constraints","example","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","lazy_step_vk","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$2","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$19","cons$5","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$108","sexp_of_t$118","hash_fold_t$73","compare$134","t_of_sexp$109","sexp_of_t$119","bin_size_t$59","bin_write_t$62","bin_read_t$107","bin_read_t$108","empty$32","equal$81","typ$25","t_of_sexp$110","sexp_of_t$120","add$31","typ$26","negate$9","constant$10","if$8","double$5","scale$8","sum$4","make_checked$1","params$3","block_cipher$1","add_assign$1","copy$10","to_bits$1","update$5","hash$60","pow2$1","to_bits$2","params$4","hash$61","pack_input","pack_input$0","prefix_to_field","params$5","rounds_full$0","initial_ark$0","rounds_partial$0","to_the_alpha$1","hash$62","salt$1","pack_input$1","to_the_alpha$2","seal$1","add_assign$2","apply_affine_map$0","copy$11","params$6","scan_state_transaction_capacit","t$9","length_in_bytes$1","padding_char","create$85","protocol_state","protocol_state_body","account","side_loaded_vk","zkapp_account","zkapp_payload","zkapp_body_mainnet","zkapp_body_testnet","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$0","checkpoint_list","zkapp_precondition","zkapp_precondition_account","zkapp_precondition_protocol_st","account_update_account_precond","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","raise$1","to_option$0","array_length","export$0","jsoo_exports","symbol$237","lookup$3","of_js","salt$2","salt$3","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$123","bin_shape_t$121","group$124","field$4","group$125","create$86","bin_read_t$109","v_x","v_is_odd","bin_size_t$60","bin_write_t$63","to_hlist$22","of_hlist$22","gen$2","group$126","bin_shape_t$122","path$22","version$12","group$127","group$128","bin_shape_t$123","create$87","bin_read_t$110","bin_read_t$111","bin_reader_t$44","bin_size_t$61","bin_write_t$64","bin_writer_t$44","bin_t$44","group$129","public_key","size_of_public_key","write_public_key","bin_writer_t$45","bin_read_t$112","of_public_key","bin_reader_t$45","bin_t$45","version$13","equal_key","compare_key$2","hash_fold_t$74","hash$63","to_yojson$37","of_yojson$24","of_public_key$0","of_public_key$1","hash_fold_t$75","uncompressed","path$23","group$130","bin_shape_typ$0","group$131","public_key$0","create$88","bin_read_t$113","key_to_string","compress$1","empty$33","to_input$3","to_input_legacy","typ$27","var_of_t","equal$82","odd_eq","to_input$4","decompress","y_parity","decompress_exn","compare$135","hash_fold_t$76","of_yojson$25","compressed","to_yojson$38","sexp_of_t$122","t_of_sexp$112","path$24","group$132","bin_shape_t_tagged$0","create$89","bin_read_t$114","bin_size_t$62","bin_write_t$65","group$133","bin_shape_t$124","bin_size_t$63","bin_write_t$66","bin_writer_t$46","bin_read_t$115","bin_read_t$116","bin_reader_t$46","bin_t$46","compare$136","version$14","t_of_sexp$113","upperbound","path$25","group$134","bin_shape_typ$1","bin_size_typ","bin_write_typ","bin_read_typ","group$135","bin_shape_t_tagged$1","create$90","bin_read_t$117","bin_read_t$118","bin_reader_t$47","bin_size_t$64","bin_write_t$67","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$136","bin_shape_t$125","path$26","t_of_sexp$114","public_key_field","private_key_field","private_key_value","public_key_value","sexp_of_t$123","v_private_key","v_public_key","compare$137","pk2","pk1","of_private_key_exn","gen$3","t_of_sexp$115","sexp_of_t$124","compare$138","group$137","bin_shape_t$126","path$27","t_of_sexp$116","sexp_of_t$125","gen$4","to_field$3","typ$28","one_half","is_pos","constant$11","pos$68","if$9","to_yojson$39","poly_hash","poly_account","group$138","bin_size_t$65","size_of_hash","size_of_account","bin_write_t$68","write_hash","write_account","bin_read_t$119","of_account","arg_1$1","arg_2","arg_3","t_of_sexp$117","sexp_of_t$126","to_yojson$40","of_yojson$26","equal$83","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$118","sexp_of_t$127","hash$66","group$139","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_impl","replace_self","tree0","build_tail_f","prev_r","prev_l","mself","traverse_through_nodes","bottom_to_hash_node_path","bottom_el","tail_r","tail_l","add_path","account_id","h_r","h_l","add_wide_path_unsafe","h_r$0","h_l$0","find_index_exn","aid","custom_printf_041","custom_printf_042","acct","go_right","expected_kind","custom_printf_043","path_exn","v_favorite_number","a_046","b_047","name_field","favorite_number_field","favorite_number_value","name_value","data_hash","favorite_number","prune_hash_branches","let_syntax_053","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","pk$0","group$140","bin_shape_t$128","group$141","bin_shape_typ$2","group$142","bin_shape_t$129","path$28","of_yojson$27","to_yojson$41","t_of_sexp$119","sexp_of_t$128","hash_fold_t$77","func$20","compare$139","equal$84","version$15","bin_size_t$66","bin_write_t$69","bin_read_t$120","bin_read_t$121","path$29","group$143","bin_shape_t_tagged$2","create$91","bin_read_typ$0","bin_read_typ$1","bin_size_typ$0","bin_write_typ$0","to_yojson$42","of_yojson$28","t_of_sexp$120","sexp_of_t$129","hash_fold_t$78","hash$67","hashable$3","add$32","sub$9","div$2","rem$8","max_value$3","logand$1","logor$1","logxor$1","shift_left$7","shift_right$7","of_int$10","to_int$9","of_ms$0","to_ms$0","of_string$46","to_string$49","zero$12","one$14","lognot$6","succ$9","pred$9","compare$140","equal$85","max$26","min$25","pp$28","symbol$238","symbol$239","symbol$240","symbol$241","symbol$242","to_uint64","of_uint64","group$144","bin_shape_t$130","group$145","bin_shape_typ$3","group$146","bin_shape_t$131","path$30","of_yojson$29","to_yojson$43","t_of_sexp$121","sexp_of_t$130","hash_fold_t$79","func$21","compare$141","equal$86","bin_size_t$67","bin_write_t$70","bin_read_t$122","bin_read_t$123","path$31","group$147","bin_shape_t_tagged$3","create$92","to_yojson$44","of_yojson$30","t_of_sexp$122","sexp_of_t$131","length_in_bits$0","hash_fold_t$80","hash$68","hashable$4","add$33","sub$10","div$3","rem$9","max_int$3","logand$2","logor$2","logxor$2","shift_left$8","shift_right$8","of_int$11","to_int$10","of_int64$3","to_int64$4","of_string$47","to_string$50","zero$13","one$15","lognot$7","succ$10","pred$10","compare$142","equal$87","max$27","min$26","pp$29","symbol$243","symbol$244","symbol$245","symbol$246","symbol$247","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","current$5","u32_1","u32_2","zero$14","symbol$248","diff_or_zero","u32_slot","u32_span","u32_sum","diff$0","to_uint32$0","of_uint32$0","zero$15","equal$88","zero$16","succ$11","group$148","bin_shape_t$132","sgn","t_fields_annots","t_toplevel_annots","t_of_sexp$123","of_magnitude","of_sgn","magnitude_field","sgn_field","sgn_value","magnitude_value","sexp_of_t$132","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","create_preserve_zero_sign","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_044","custom_printf_045","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","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","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","scan_state_transaction_capacit$0","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$69","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$133","v_doc","of_annots","t_fields_annots$0","sexpifier$2","v_deprecated","v_skip","compare$143","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$26","map$70","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$149","bin_shape_t$133","t_fields_annots$1","t_toplevel_annots$1","t_of_sexp$124","of_h","hash_field","hash_value","sexp_of_t$134","v_hash","hash$69","data$3","hash$70","data$4","sexp_of_t$135","compare$144","cmp_h","hash$71","map$71","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","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_fun","field_fun","compile_acc$3","field_gen","compile_acc$4","nothing_gen","obj$1","compile_acc$5","public_key_gen","group$150","bin_shape_t$134","bin_writer_t$48","bin_reader_t$48","bin_t$48","version$16","func$22","path$32","group$151","bin_shape_typ$4","group$152","bin_shape_t$135","create$93","bin_read_t$124","bin_read_t$125","bin_reader_t$49","bin_size_t$68","bin_write_t$71","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$153","bin_shape_t$136","bin_writer_t$50","bin_reader_t$50","bin_t$50","hash$72","path$33","group$154","bin_shape_t$137","bin_read_t$126","bin_read_t$127","bin_reader_t$51","bin_size_t$69","bin_write_t$72","bin_writer_t$51","bin_t$51","equal$89","to_string$51","of_string$48","group$155","bin_shape_t$138","bin_read_t$128","bin_size_t$70","bin_write_t$73","t_of_sexp$125","sexp_of_t$136","to_yojson$45","symbol$249","group$156","bin_shape_t$139","bin_read_t$129","bin_read_t$130","v_transaction_capacity_log_2","bin_reader_t$52","bin_size_t$71","bin_write_t$74","bin_writer_t$52","bin_t$52","t_of_sexp$126","transaction_capacity_log_2_fie","transaction_capacity_log_2_val","sexp_of_t$137","equal$90","compare$145","to_snark_keys_header","blockchain_length","state_hash","genesis_timestamp_of_string","of_time","to_time","validate_time","time_str","genesis_timestamp_to_string","compare$146","poly_length","poly_delta","poly_genesis_state_timestamp","group$157","bin_shape_t$140","sexp_of_t$138","of_length","of_delta","of_genesis_state_timestamp","v_genesis_state_timestamp","v_grace_period_slots","v_slots_per_sub_window","v_slots_per_epoch","v_k","to_hlist$23","grace_period_slots","slots_per_sub_window","slots_per_epoch","of_hlist$23","compare$147","group$158","bin_shape_t$141","path$34","compare$148","symbol$250","sexp_of_t$139","v_minimum_user_command_fee","v_zkapp_cmd_limit_hardcap","v_max_action_elements","v_max_event_elements","v_zkapp_transaction_cost_limit","v_zkapp_signed_pair_update_cos","v_zkapp_signed_single_update_c","v_zkapp_proof_update_cost","v_num_accounts","v_txpool_max_size","v_protocol","group$159","bin_shape_t$142","bin_read_t$131","bin_read_t$132","bin_reader_t$53","bin_size_t$72","bin_write_t$75","bin_writer_t$53","bin_t$53","hash$73","tps_goal_x10","max_user_commands_per_block","pending_coinbase_depth","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","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$160","bin_read_t$133","bin_read_t$134","t_of_sexp$127","to_list$15","to_numbered_list","def2","def1","map$72","fold$19","gen$5","inner_gen","of_array$4","map_gens","gen_division_generic","dirichlet","n_float","uniform","gen_division","symbol$251","zero$18","symbol$252","symbol$253","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","of_public_key$2","token_id","owner","public_key$1","token_id$0","derive_token_id$1","tid2","tid1","pk_equal","tid_equal","tid_else","pk_else","tid_then","pk_then","create$94","equal$91","group$161","t_of_sexp$128","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$162","bin_shape_t$143","path$35","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$0","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$29","deriver$1","group$163","group$164","field$5","version$17","group$165","bin_shape_t_tagged$4","create$95","bin_read_t$135","bin_size_t$73","bin_write_t$76","group$166","bin_shape_t$144","bin_size_t$74","bin_write_t$77","bin_read_t$136","t_of_sexp$129","sexp_of_t$140","compare$149","hash_fold_t$81","group$167","bin_shape_t$145","bin_read_t$137","bin_read_t$138","bin_reader_t$54","bin_size_t$75","bin_write_t$78","bin_writer_t$54","bin_t$54","path$36","group$168","bin_shape_typ$5","group$169","bin_shape_t_tagged$5","create$96","bin_read_t$139","bin_size_t$76","bin_write_t$79","authorization","group$170","bin_shape_t$146","path$37","sexp_of_t$141","gen$6","dummy_signature","let_syntax_297","signature_deriver","t_fields_annots$3","t_toplevel_annots$3","signature$3","signature$4","deriver$2","signature_fun","proof_fun","proof_gen","signature_gen","signature","to_record$0","of_record$0","deriver$3","control","typ$30","to_input$6","t_fields_annots$4","t_toplevel_annots$4","hash$74","data$5","hash$75","data$6","deriver$4","to_yojson$46","symbol$254","group$171","token$1","bin_size_t$77","bin_write_t$80","bin_read_t$140","t_of_sexp$130","sexp_of_t$142","equal$92","compare$150","hash_fold_t$82","path$38","to_yojson$47","symbol$255","group$172","bin_size_t$78","bin_write_t$81","bin_read_t$141","t_of_sexp$131","sexp_of_t$143","compare$151","hash_fold_t$83","path$39","group$173","bin_shape_typ$6","bin_size_typ$1","bin_write_typ$1","bin_read_typ$2","group$174","create$97","to_yojson$48","symbol$256","default_caller","of_string$49","equal$93","deriver$5","group$175","to_hlist$24","fee_excess_r","fee_token_r","fee_excess_l","fee_token_l","of_hlist$24","typ$31","token_typ","fee_typ","group$176","bin_shape_t$147","path$40","rebalance","fee_token_l$0","fee_token_r$0","fee_excess_l$0","zero$19","of_one_or_two","excesses","unreduced","gen_single","group$177","group$178","group$179","token_id$1","group$180","create$98","group$181","bin_shape_t$148","path$41","group$182","bin_shape_t$149","path$42","group$183","bin_shape_typ$7","group$184","bin_shape_t_tagged$6","create$99","dummy$4","to_yojson$49","of_yojson$31","t_of_sexp$132","sexp_of_t$144","equal$94","compare$152","group$185","ledger","bin_writer_t$55","bin_reader_t$55","bin_t$55","hash$76","path$43","group$186","controller","write_controller","of_controller","of_controller$0","of_controller$1","hash_fold_controller","path$44","sexp_of_t$145","gen_for_proof_authorization","gen_for_signature_authorizatio","gen_for_none_given_authorizati","to_string$52","of_string$50","to_hlist$25","signature_sufficient","signature_necessary","of_hlist$25","to_input$7","encode$0","decode$1","to_input$8","t$10","typ$32","to_input$9","check$10","group$187","to_hlist$26","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$26","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","txn_version","group$188","bin_shape_t$150","bin_size_t$79","bin_write_t$82","bin_read_t$142","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$133","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","sexp_of_t$146","compare$153","t_021","hash_fold_t$84","path$45","to_input$11","typ$33","to_input$12","t1$9","empty$35","auth_required","auth","txn_version$0","auth$0","t_fields_annots$6","t_toplevel_annots$6","deriver$6","transaction_version","txn_version_fun","auth_fun","auth_gen","txn_version_gen","to_record$1","of_record$1","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$189","bin_shape_t$151","path$46","group$190","bin_shape_typ$8","group$191","bin_shape_t$152","path$47","group$192","bin_shape_typ$9","group$193","bin_shape_t_tagged$7","create$100","generator_013","to_yojson$50","group$194","bin_shape_t$153","t_of_sexp$134","sexp_of_t$147","path$48","sexp_of_t$148","compare$154","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$195","bin_shape_t$154","path$49","to_yojson$51","group$196","bin_shape_t$155","path$50","to_display","display","empty$36","of_single_failure","is_empty$14","add$34","failure","describe","group$197","bin_shape_t$156","path$51","min$27","max$28","of_enum","equal$95","gen$7","equal$96","of_t","test_mask","payment","stake_delegation","fee_transfer","coinbase$2","typ$34","to_hlist$27","is_user_command","is_coinbase","is_fee_transfer","is_stake_delegation","is_payment","of_hlist$27","typ$35","equal$97","payment$0","stake_delegation$0","fee_transfer$0","coinbase$3","to_bits_t","to_bits_var","bool_var","bit3","bit2","bit1","acc3","add_if_true","base_typ","typ$36","unpacked_t_of_t","t_of_unpacked_t","unpacked","bits_t_of_t","t_of_bits_t","unpacked_typ","test_predicate","checked$0","one_of","one$16","default$11","group$198","group$199","group$200","global_slot","nonce","token_id$2","public_key$2","group$201","create$101","to_hlist$28","valid_until","fee_payer_pk","of_hlist$28","symbol$257","group$202","bin_shape_t$157","bin_size_t$80","bin_write_t$83","bin_writer_t$56","bin_read_t$143","bin_read_t$144","v_fee","v_fee_payer_pk","v_nonce","v_valid_until","v_memo","bin_reader_t$56","bin_t$56","t_of_sexp$135","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$149","hash_fold_t$85","path$52","group$203","bin_shape_t$158","bin_size_t$81","bin_write_t$84","bin_read_t$145","v_fee_token","t_of_sexp$136","fee_token_field","fee_token_value","sexp_of_t$150","hash_fold_t$86","path$53","group$204","bin_shape_typ$10","group$205","common","create$102","let_syntax_073","gen$8","group$206","bin_shape_t$159","bin_size_t$82","bin_write_t$85","bin_read_t$146","v_receiver_pk","v_amount","v_new_delegate","t_of_sexp$137","new_delegate_field","new_delegate_value","receiver_pk_field","amount_field","amount_value","receiver_pk_value","sexp_of_t$151","hash_fold_t$87","path$54","group$207","bin_shape_t$160","bin_size_t$83","bin_write_t$86","bin_read_t$147","v_source_pk","v_token_id","v_delegator","t_of_sexp$138","delegator_field","delegator_value","source_pk_field","token_id_field","token_id_value","source_pk_value","sexp_of_t$152","hash_fold_t$88","path$55","group$208","bin_shape_typ$11","group$209","bin_shape_t_tagged$8","create$103","to_yojson$52","poly_common","poly_body","symbol$258","group$210","bin_shape_t$161","bin_size_t$84","size_of_common","size_of_body","bin_write_t$87","write_common","write_body","bin_read_t$148","of_common","of_body","v_common","v_body","t_of_sexp$139","common_field","body_field","body_value","common_value","sexp_of_t$153","hash_fold_t$89","hash_fold_common","hash_fold_body","compare$155","cmp_common","cmp_body","group$211","common$0","group$212","create$104","to_hlist$29","of_hlist$29","group$213","bin_shape_t$162","bin_size_t$85","bin_write_t$88","bin_read_t$149","t_of_sexp$140","sexp_of_t$154","hash_fold_t$90","path$56","group$214","bin_shape_t$163","bin_size_t$86","bin_write_t$89","bin_read_t$150","t_of_sexp$141","sexp_of_t$155","hash_fold_t$91","path$57","group$215","bin_shape_typ$12","group$216","bin_shape_t_tagged$9","create$105","bin_read_t$151","read_version$6","read_version$5","read_version$3","read_version$2","read_version$4","read_version$1","bin_size_t$87","bin_write_t$90","create$106","fee$0","fee_payer","nonce$0","receiver","payload$0","new_delegate","max_amount","receiver_pk","generator_012","t_to_hlist","source_pk","t_of_hlist","typ$37","to_hlist$30","fee_token","of_hlist$30","typ$38","of_user_command_payload","max_amount_without_overflow","poly_payload","poly_pk","poly_signature","size_of_payload","size_of_pk","size_of_signature","write_payload","write_pk","write_signature","bin_writer_payload","bin_writer_pk","bin_writer_signature","of_payload","of_pk","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","b_094","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","fee_payer$0","fee_excess","receiver$0","valid_until$0","sign_payload","kp","fake_sign","gen_inner","fee_range","create_body","min_fee","min_fee$0","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","path$1","hash_fold_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$217","bin_shape_t$164","bin_writer_t$57","bin_reader_t$57","bin_t$57","hash$77","path$58","empty$38","group$218","bin_shape_t$165","bin_writer_t$58","bin_reader_t$58","bin_t$58","hash$78","path$59","group$219","bin_shape_t$166","path$60","group$220","bin_shape_t$167","to_hlist$31","of_hlist$31","to_input$13","of_option$0","to_option$1","map$73","typ$39","option_typ","lazy_option_typ","group$221","bin_shape_t$168","bin_size_t$88","bin_write_t$91","bin_read_t$152","t_of_sexp$142","sexp_of_t$156","compare$156","hash_fold_t$92","t_of_sexp$143","sexp_of_t$157","map$74","to_option$2","of_option$1","is_set","is_keep","deriver$8","gen$9","gen_a","typ$40","optional_typ","to_input$14","to_input$15","group$222","bin_shape_t$169","bin_size_t$89","bin_write_t$92","bin_read_t$153","t_of_sexp$144","sexp_of_t$158","compare$157","hash_fold_t$93","sexp_of_t$159","compare$158","gen$10","to_option$3","of_option$2","deriver_base","deriver$9","to_input$16","typ$41","ignore","group$223","bin_shape_t$170","path$61","to_hlist$32","of_hlist$32","encode$1","decode$2","invalid_public_key","digest_vk","dummy_vk_hash","t_of_sexp$145","sexp_of_t$160","equal$98","hash_fold_t$94","to_binable$14","of_binable$17","path$62","group$224","bin_shape_t$171","bin_size_t$90","bin_write_t$93","bin_read_t$154","typ$42","group$225","t_of_sexp$146","path$63","to_input$17","deriver$10","t_of_sexp$147","sexp_of_t$161","hash$79","empty_hash","push_hash","push_event","push_to_data_as_hash","events","pop_from_data_as_hash","events$0","typ$43","to_input$18","deriver$11","hash$80","typ$44","var_to_input$1","to_input$19","deriver$12","empty$39","max_length$1","check$11","t_of_sexp$148","to_binable$15","of_binable$18","path$64","group$226","t_of_sexp$149","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$33","proved_state","last_action_slot","action_state","zkapp_version","of_hlist$33","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$7","t_toplevel_annots$7","group$227","bin_shape_t$172","bin_size_t$91","bin_write_t$94","bin_read_t$155","v_verification_key","v_zkapp_version","v_action_state","v_last_action_slot","v_proved_state","v_zkapp_uri","t_of_sexp$150","sexp_of_t$162","path$65","zkapp_uri_non_preimage","hash_zkapp_uri_opt","zkapp_uri_opt","hash$81","typ$45","zkapp_uri_to_input","digest$4","default_digest","action_state_deriver","list_5","gen_uri","app_state$2","seq_state","group$228","bin_shape_t$173","bin_writer_t$59","bin_reader_t$59","bin_t$59","hash$82","path$66","max_length$2","check$12","t_of_sexp$151","to_binable$16","of_binable$19","path$67","num_bits$7","to_field$4","byte_index","to_input$20","of_field$4","chars","typ$46","typ$47","var_to_input$2","zkapp","permissions","timing","voting_for","delegate","receipt_chain_hash","nonce$1","balance$1","token_symbol","token_id$3","public_key$3","zkapp$0","permissions$0","timing$0","voting_for$0","delegate$0","receipt_chain_hash$0","nonce$2","balance$2","token_symbol$0","token_id$4","public_key$4","to_hlist$34","of_hlist$34","t_fields_annots$8","t_toplevel_annots$8","group$229","bin_shape_t$174","path$68","group$230","bin_shape_t$175","bin_size_t$92","bin_write_t$95","bin_read_t$156","bin_read_t$157","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","path$69","check$13","to_yojson$53","poly_field","poly_controller","poly_amount","of_yojson$32","arg10$0","arg9$0","arg6$1","arg5$1","arg4$2","arg3$2","arg4$1","x$37","x$36","x$35","value_of_sexp","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","equal$99","cmp_amount","path$70","to_hlist$35","of_hlist$35","zkapp$1","permissions$1","timing$1","voting_for$1","delegate$1","receipt_chain_hash$1","nonce$3","balance$3","token_symbol$1","token_id$5","public_key$5","zkapp$2","permissions$2","timing$2","voting_for$2","delegate$2","receipt_chain_hash$2","nonce$4","balance$4","token_symbol$2","token_id$6","public_key$6","hash_zkapp_account_opt","delegate_opt","digest$5","typ$48","account$0","zkapp$3","typ$49","hash$83","create$107","min_balance_at_slot","min_balance_past_cliff","global_slot_u32","cliff_time_u32","vesting_period_u32","num_periods","vesting_decrement","has_permission","has_permission_to_send","has_permission_to_receive","gen_with_constrained_balance","vesting_end","gen_any_vesting_range","let_syntax_082","vesting_slots","vesting_periods_count","max_cliff_amt","to_vest","vi","group$231","bin_shape_t$176","ledger_hash","t_of_sexp$152","of_ledger_hash","total_currency_field","total_currency_value","sexp_of_t$163","v_total_currency","compare$159","cmp_ledger_hash","t_fields_annots$9","t_toplevel_annots$9","to_hlist$36","total_currency","of_hlist$36","hash$84","total_currency$0","hash$85","total_currency_fun","total_currency_gen","group$232","bin_shape_t$177","t_of_sexp$153","sexp_of_t$164","path$71","group$233","bin_shape_t$178","bin_writer_t$60","bin_reader_t$60","bin_t$60","hash$86","path$72","group$234","bin_shape_t$179","epoch_ledger","start_checkpoint","lock_checkpoint","t_of_sexp$154","of_epoch_ledger","of_epoch_seed","of_start_checkpoint","of_lock_checkpoint","ledger_field","seed_field","start_checkpoint_field","lock_checkpoint_field","epoch_length_field","epoch_length_value","lock_checkpoint_value","start_checkpoint_value","seed_value","ledger_value","sexp_of_t$165","v_epoch_length","v_lock_checkpoint","v_start_checkpoint","v_seed","v_ledger","compare$160","cmp_epoch_ledger","cmp_epoch_seed","cmp_start_checkpoint","cmp_lock_checkpoint","cmp_length","t_fields_annots$10","t_toplevel_annots$10","to_hlist$37","epoch_length","of_hlist$37","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$235","bin_shape_t$180","t_of_sexp$155","sexp_of_t$166","compare$161","a_022","a_018","a_016","path$73","merge$10","if$10","merge$11","f$15","group$236","bin_shape_t$181","t_fields_annots$11","t_toplevel_annots$11","to_hlist$38","of_hlist$38","to_input$21","deriver$13","upper_fun","lower_fun","lower_gen","upper_gen","v_upper","v_lower","run$7","length$29","balance$5","global_slot$0","group$237","bin_shape_t$182","bin_size_t$93","bin_write_t$96","bin_read_t$158","t_of_sexp$156","lower_field","upper_field","upper_value","lower_value","sexp_of_t$167","hash_fold_t$95","compare$162","cmp_a$0","compare$163","deriver$14","range_max","range_uint32","range_uint64","nonce$5","balance$6","amount$1","length$30","deriver$15","v_foo","gen$11","compare_a","to_input$22","to_input$23","to_input_checked","typ$50","check$14","run$8","init$28","action_state$1","boolean$1","receipt_chain_hash$3","frozen_ledger_hash","token_id$7","epoch_seed$0","public_key$7","to_input$24","check$15","typ$51","receipt_chain_hash$4","balance$7","nonce$6","group$238","account$1","t_of_sexp$157","is_new_field","is_new_value","sexp_of_t$168","v_is_new","path$74","t_fields_annots$12","t_toplevel_annots$12","to_hlist$39","is_new","of_hlist$39","sexp_of_t$169","compare$164","a_133","b_134","proved_state$1","action_state$2","state$67","delegate$3","receipt_chain_hash$5","nonce$7","balance$8","is_new$0","proved_state$2","action_state$3","state$68","delegate$4","receipt_chain_hash$6","nonce$8","balance$9","gen$12","accept","nonce$9","deriver$16","is_new_fun","proved_state_fun","action_state_fun","state_fun","delegate_fun","receipt_chain_hash_fun","nonce_fun","balance_fun","balance_gen","nonce_gen","receipt_chain_hash_gen","delegate_gen","state_gen","action_state_gen","proved_state_gen","is_new_gen","to_input$25","to_hlist$40","of_hlist$40","group$239","bin_shape_t$183","size_of_epoch_data","write_epoch_data","of_epoch_data","t_of_sexp$158","of_epoch_data$0","hash_fold_epoch_data","compare$165","a_191","b_192","a_193","b_194","a_189","b_190","a_185","b_186","a_175","b_176","a_177","b_178","path$75","deriver$17","a_203","b_204","max_epoch_length","min_epoch_length","gen$13","to_input$26","to_input$27","group$240","bin_shape_t$184","snarked_ledger_hash","epoch_data","to_hlist$41","next_epoch_data","staking_epoch_data","min_window_density","of_hlist$41","t_of_sexp$159","of_snarked_ledger_hash","of_global_slot","snarked_ledger_hash_field","min_window_density_field","staking_epoch_data_field","next_epoch_data_field","next_epoch_data_value","staking_epoch_data_value","min_window_density_value","snarked_ledger_hash_value","t_fields_annots$13","t_toplevel_annots$13","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$241","protocol_state$1","t_of_sexp$160","sexp_of_t$170","v_next_epoch_data","v_staking_epoch_data","v_min_window_density","v_snarked_ledger_hash","compare$166","a_233","b_234","cmp_epoch_data","a_251","b_252","a_239","b_240","a_241","b_242","a_237","b_238","a_249","b_250","path$76","deriver$18","snarked_ledger_hash$1","max_min_window_density","gen$14","to_input$28","group$242","bin_shape_t$185","path$77","epoch_data_deriver","frozen_ledger_hash$0","state_hash$0","epoch_seed$1","length$31","amount$2","global_slot$1","typ$52","t1$10","a_313","b_314","group$243","bin_shape_t$186","path$78","gen$15","typ$53","group$244","bin_shape_t$187","path$79","to_hlist$42","user","of_hlist$42","group$245","account_transition","group$246","path$80","group$247","group$248","bin_shape_t$188","path$81","group$249","bin_shape_t$189","path$82","to_hlist$43","verification_key_hash","is_proved","is_signed","of_hlist$43","t_fields_annots$14","t_toplevel_annots$14","verification_key_hash$0","is_proved$0","is_signed$0","to_hlist$44","of_hlist$44","typ$54","deriver$19","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$20","typ$55","group$250","bin_shape_t$190","path$83","let_syntax_268","t_fields_annots$15","t_toplevel_annots$15","to_hlist$45","inherit_from_parent","parents_own_token","of_hlist$45","inherit_from_parent$0","parents_own_token$0","typ$56","sum_squared","typ$57","to_input$29","to_variant","of_variant","deriver$21","inherit_from_parent_fun","parents_own_token_fun","parents_own_token_gen","inherit_from_parent_gen","deriver$22","may_use_token","typ$58","group$251","bin_shape_t$191","bin_size_t$94","bin_write_t$97","bin_read_t$159","t_of_sexp$161","sexp_of_t$171","hash_fold_t$96","path$84","t_fields_annots$16","t_toplevel_annots$16","t_of_sexp$162","sexp_of_t$172","to_hlist$46","of_hlist$46","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$47","of_hlist$47","to_input$31","typ$59","deriver$23","group$252","bin_shape_t$192","path$85","t_fields_annots$17","t_toplevel_annots$17","voting_for$3","timing$3","token_symbol$3","zkapp_uri$3","permissions$3","verification_key$1","delegate$5","app_state$3","voting_for$4","timing$4","token_symbol$4","zkapp_uri$4","permissions$4","verification_key$2","delegate$6","app_state$4","to_hlist$48","of_hlist$48","gen$16","permissions_auth","token_account","token_gen","uri_gen","auth_tag","auth_required_gen","set_verification_key_auth","vk$1","to_hlist$49","of_hlist$49","noop","to_input$32","deriver$24","voting_for_fun","timing_fun","token_symbol_fun","zkapp_uri_fun","permissions_fun","verification_key_fun","app_state_fun","app_state_gen","verification_key_gen","permissions_gen","zkapp_uri_gen","token_symbol_gen","timing_gen","voting_for_gen","group$253","bin_shape_t$193","path$86","precondition","gen$17","deriver$25","group$254","bin_shape_t$194","path$87","t_fields_annots$18","t_toplevel_annots$18","to_hlist$50","valid_while","of_hlist$50","account$2","network$1","valid_while$0","account$3","network$2","deriver$26","valid_while_fun","account_fun","network_fun","network_gen","account_gen","valid_while_gen","let_syntax_265","to_hlist$51","of_hlist$51","group$255","bin_shape_t$195","bin_size_t$95","bin_write_t$98","bin_read_t$160","t_of_sexp$163","sexp_of_t$173","hash_fold_t$97","compare$167","a_142","b_143","a_144","b_145","a_146","b_147","path$88","group$256","bin_shape_t$196","path$89","t_fields_annots$19","t_toplevel_annots$19","authorization_kind","implicit_account_creation_fee","use_full_commitment","preconditions","call_depth","call_data","actions","increment_nonce$3","update$6","token_id$8","public_key$8","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$9","public_key$9","deriver$27","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","token_id_fun","public_key_fun","token_id_gen","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","compile_acc$12","authorization_kind_gen","group$257","bin_shape_t$197","path$90","group$258","bin_shape_t$198","sexp_of_t$174","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","compare$168","a_206","b_207","path$91","to_hlist$52","of_hlist$52","of_graphql_repr","group$259","bin_shape_t$199","path$92","t_fields_annots$20","t_toplevel_annots$20","nonce$10","fee$1","public_key$10","nonce$11","valid_until$1","fee$2","public_key$11","let_syntax_242","gen$18","deriver$28","valid_until_fun","fee_fun","fee_gen","valid_until_gen","of_fee_payer","to_hlist$53","of_hlist$53","chain","typ$60","non_preimage","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$260","bin_shape_t$200","path$93","t_fields_annots$21","t_toplevel_annots$21","authorization$0","authorization$1","deriver$29","authorization_fun","body_fun","body_gen","authorization_gen","group$261","bin_shape_t$201","path$94","group$262","bin_shape_t$202","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","v_delegate$0","v_authorization","t_of_sexp$164","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","account_field","valid_while_field","valid_while_value","account_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$175","hash_fold_account_update","hash_fold_length","hash$87","path$95","t_of_sexp$165","sexp_of_t$176","of_graphql_repr$0","quickcheck_generator$5","digest$6","create$108","group$263","bin_shape_t$203","hash_fold_t$98","hash$88","path$96","t_fields_annots$22","t_toplevel_annots$22","authorization$2","body$1","authorization$3","body$2","let_syntax_274","deriver$30","of_fee_payer$0","balance_change$1","public_key$12","token_id$10","increment_nonce$5","group$264","bin_shape_t$204","bin_size_t$96","size_of_field","bin_write_t$99","write_field","bin_read_t$161","v_elt","v_stack_hash","t_of_sexp$166","elt_field","stack_hash_field","stack_hash_value","elt_value","sexp_of_t$177","compare$169","cmp_field","hash_fold_t$99","hash_fold_field","group$265","bin_shape_t$205","t_of_sexp$167","status_field","status_value","sexp_of_t$178","v_status","map$75","group$266","bin_size_t$97","size_of_account_update_digest","bin_write_t$100","write_account_update_digest","bin_read_t$162","of_account_update_digest","v_account_update","v_account_update_digest","v_calls","t_of_sexp$168","account_update_field","account_update_digest_field","calls_field","calls_value","account_update_digest_value","account_update_value","sexp_of_t$179","compare$170","cmp_account_update","cmp_account_update_digest","cmp_digest","hash_fold_t$100","hash_fold_account_update_diges","t_of_sexp$169","fold$21","calls","account_update","mapi_forest_with_trees","map$76","to_yojson$54","symbol$259","group$267","bin_shape_t$206","bin_size_t$98","bin_write_t$101","bin_writer_t$61","bin_read_t$163","bin_read_t$164","bin_reader_t$61","bin_t$61","t_of_sexp$170","sexp_of_t$180","compare$171","equal$100","hash_fold_t$101","func$23","versioned$6","func$24","path$97","to_yojson$55","symbol$260","hash$89","to_yojson$56","symbol$261","group$268","bin_shape_t$207","bin_size_t$99","bin_write_t$102","bin_writer_t$62","bin_read_t$165","bin_read_t$166","bin_reader_t$62","bin_t$62","t_of_sexp$171","sexp_of_t$181","compare$172","equal$101","hash_fold_t$102","func$25","versioned$7","func$26","path$98","to_yojson$57","symbol$262","hash$90","to_yojson$58","symbol$263","group$269","bin_shape_t$208","bin_size_t$100","bin_write_t$103","bin_writer_t$63","bin_read_t$167","bin_read_t$168","bin_reader_t$63","bin_t$63","t_of_sexp$172","sexp_of_t$182","compare$173","equal$102","hash_fold_t$103","func$27","versioned$8","func$28","path$99","to_yojson$59","symbol$264","hash$91","h_tl","cons$0","account_update_digest","stack_hash","group$270","bin_shape_t$209","t_of_sexp$173","sexp_of_t$183","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$92","accumulate_hashes","hash_account_update","calls$0","node_hash","group$271","bin_shape_t$210","group$272","bin_shape_t$211","path$100","empty$40","group$273","bin_shape_t$212","path$101","group$274","bin_shape_t$213","path$102","version$18","t_of_sexp$174","fee_payer_field","account_updates_field","account_updates_value","fee_payer_value","sexp_of_t$184","v_account_updates","v_fee_payer","compare$174","a_224","b_225","a_230","b_231","a_093","a_228","b_229","a_226","b_227","hash_fold_t$104","group$275","bin_shape_t$214","bin_size_t$101","bin_write_t$104","bin_read_t$169","bin_read_t$170","path$103","let_syntax_275","let_syntax_273","calls_length","to_wire","forget_hashes","forget_hash","of_binable$20","path$104","group$276","bin_shape_typ$13","t_fields_annots$23","t_toplevel_annots$23","t_of_sexp$175","sexp_of_t$185","memo$2","account_updates$0","fee_payer$1","fee_payer$2","status_sym","if$11","group$277","bin_shape_t$215","path$105","create_complete","memo_hash","fee_payer_hash","group$278","bin_shape_t$216","path$106","group$279","bin_shape_t$217","t_of_sexp$176","zkapp_command_field","zkapp_command_value","sexp_of_t$186","v_zkapp_command","hash_fold_t$105","path$107","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","group$280","bin_shape_t$218","to_hlist$54","of_hlist$54","group$281","bin_shape_t$219","path$108","forest","group$282","bin_shape_t$220","t_of_sexp$177","of_u","sexp_of_t$187","compare$175","cmp_u","cmp_s","hash_fold_t$106","hash_fold_u","hash_fold_s","to_signed_command","gen_signed","group$283","bin_shape_t$221","t_of_sexp$178","sexp_of_t$188","hash_fold_t$107","path$109","group$284","bin_shape_t$222","path$110","group$285","bin_shape_t$223","t_of_sexp$179","sexp_of_t$189","hash_fold_t$108","path$111","with_random_receivers","size_args$0","a_012","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","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","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","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","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","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","a_044","t_of_sexp$12","sexp_of_t$12","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$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","hash_fold_t$7","versioned$11","hash$6","to_latest$7","equal$11","compare$9","sexp_of_t$17","func$2","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","hash_fold_t$9","sexp_of_t$20","compare$10","a_076","b_077","symbol$21","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","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$2","prev_state","symbol$22","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","symbol$23","symbol$24","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","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","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$286","bin_shape_t$224","path$112","v_prover","prover_field","prover_value","compare$176","group$287","bin_shape_t$225","sexpifier$3","path$113","compare$177","end_time","gen$19","value_of_t","typ$61","p_var","transaction_dummy","group$288","bin_shape_t$226","path$114","group$289","bin_shape_t$227","path$115","group$290","bin_shape_t$228","t_of_sexp$180","sexp_of_t$190","compare$178","path$116","equal_account_state","group$291","bin_shape_t$229","command","t_of_sexp$181","of_command","sexp_of_t$191","compare$179","cmp_command","hash_fold_t$109","hash_fold_command","group$292","bin_shape_t$230","t_of_sexp$182","sexp_of_t$192","compare$180","hash_fold_t$110","func$29","path$117","group$293","bin_shape_t$231","t_of_sexp$183","sexp_of_t$193","compare$181","hash_fold_t$111","func$30","path$118","compare_hash","group$294","bin_shape_t$232","bin_read_t$171","bin_read_t$172","bin_reader_t$64","bin_size_t$102","bin_write_t$105","bin_writer_t$64","bin_t$64","group$295","bin_shape_t$233","bin_read_t$173","bin_read_t$174","bin_reader_t$65","bin_size_t$103","bin_write_t$106","bin_writer_t$65","bin_t$65","mk_hasher","bin_size_t$104","bin_write_t$107","bin_read_t$175","bin_read_t$176","bin_shape_t$234","bin_writer_t$66","bin_reader_t$66","bin_t$66","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$296","bin_shape_t$235","t_of_sexp$184","sexp_of_t$194","compare$182","path$119","group$297","bin_shape_t$236","t_of_sexp$185","sexp_of_t$195","compare$183","path$120","recoded","group$298","signed_amount","group$299","failure_status_tbl","bin_shape_t$237","path$121","group$300","bin_shape_t$238","path$122","t_of_sexp$186","user_command_field","user_command_value","sexp_of_t$196","v_user_command","group$301","bin_shape_t$239","path$123","t_of_sexp$187","previous_delegate_field","previous_delegate_value","new_accounts_field","new_accounts_value","sexp_of_t$197","v_new_accounts","v_previous_delegate","group$302","bin_shape_t$240","path$124","t_of_sexp$188","sexp_of_t$198","group$303","bin_shape_t$241","path$125","t_of_sexp$189","accounts_field","command_field","command_value","accounts_value","sexp_of_t$199","v_command","v_accounts","group$304","bin_shape_t$242","path$126","t_of_sexp$190","sexp_of_t$200","group$305","bin_shape_t$243","path$127","t_of_sexp$191","burned_tokens_field","burned_tokens_value","sexp_of_t$201","v_burned_tokens","group$306","bin_shape_t$244","path$128","t_of_sexp$192","coinbase_field","coinbase_value","sexp_of_t$202","v_coinbase","group$307","bin_shape_t$245","path$129","t_of_sexp$193","sexp_of_t$203","group$308","bin_shape_t$246","path$130","t_of_sexp$194","previous_hash_field","varying_field","varying_value","previous_hash_value","sexp_of_t$204","v_varying","v_previous_hash","burned_tokens","varying","new_accounts","zc","supply_increase","burned_tokens$0","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","custom_printf_005","custom_printf_006","validate_timing","error_opt","get_with_location","set_with_location","sub_account_creation_fee","custom_printf_007","custom_printf_008","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","custom_printf_009","custom_printf_010","custom_printf_011","custom_printf_012","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","pop_exn","pop","onto","add_check","eff","global_state","local_state","new_account","local_state$0","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$2","to_pop$0","next_forest","current_is_empty","call_stack$0","current_forest","remainder_of_current_forest","account_update_forest","account_update$0","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","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","older_than_current_version","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","eta","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","symbol$265","env$2","raise_error","json_parse","typ$62","exists$12","size_in_fields","exists_one","in_prover$1","set_eval_constraints$0","enter_constraint_system","enter_generate_witness","enter_as_prover","alloc_var$0","set_as_prover$0","has_witness","get_variable_value$0","digest$7","read_var$0","assert_mul","assert_square$5","assert_boolean","compare$184","truncate_to_bits16","length_div_16","add_gate","zero$20","generic","sl","sr","sm","poseidon","ec_add","ec_scale","ec_endoscale","ec_endoscalar","lookup$4","rotate","add_fixed_lookup_table","add_runtime_table_config","of_js$0","prove","verify$1","public_input_vec","get_vk","get_cs_json","update$8","hash_to_group","sponge_params_checked","sponge_create","is_checked","sponge_absorb","sponge_squeeze","hashToGroup","getVerificationKey","getConstraintSystemJSON","ecAdd","ecScale","ecEndoscale","ecEndoscalar","rangeCheck0","rangeCheck1","foreignFieldAdd","foreignFieldMul","addFixedLookupTable","addRuntimeTableConfig","readVar","assertEqual","assertMul","assertSquare","assertBoolean","truncateToBits16","toJson","existsOne","inProver","asProver","inProverBlock","setEvalConstraints","enterConstraintSystem","enterGenerateWitness","enterAsProver","snarky","public_input_typ","statement_typ","input_size","output_size","inner_curve_typ","should_verifys_js","js_bool","should_verifys","public_output_size","statements","simple$3","read$2","should_write","cache_hit","write$1","errs","or_error","map_error$1","write$5","read$5","read$6","write$6","write$3","read$3","read$4","write$4","write$2","cache_dir","can_write","nat_modules_list","nat_add_modules_list","pickles_compile","max_proofs","storables$0","to_js_provers","js_prevs","js_result","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","verify$2","load_srs_fp","load_srs_fq","dummy_verification_key","encode_verification_key","decode_verification_key","vk_or_error","to_ml_string","from_ml_string","side_loaded_create","public_input_length","public_output_length","feature_flags_js","vk_to_circuit","vk_digest","checked_vk","in_prover$2","pickles","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$31","body_deriver","of_json$0","get_network_id_of_js_string","hash_to_group$0","sign_field_element","typ$63","account_update$1","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_zkapp_command$0","hash_payment_v1","b58","serialize_common","serialize_payment","serialize_payment_v1","example_payment","hashPayment","hashPaymentV1","serializeCommon","serializePayment","serializePaymentV1","hashZkAppCommand","examplePayment","accountUpdate","transactionCommitments","zkappPublicInput","signFieldElement","dummySignature","deriveChecked","toBase58","ofBase58","publicKeyToBase58","publicKeyOfBase58","privateKeyToBase58","privateKeyOfBase58","tokenIdToBase58","tokenIdOfBase58","memoToBase58","memoHashBase58","test$0","class$1","get$19","location_of_account","set$16","next_location","get_or_create","get_or_create_account","create_new_account","empty$41","with_ledger","create_masked","default_token_id","account_id$0","create$109","deriver$32","last_action_slot_fun","zkapp_version_fun","zkapp_version_gen","last_action_slot_gen","zkapp_fun","compile_acc$13","compile_acc$14","compile_acc$15","compile_acc$16","zkapp_gen","transform","get_account","add_account","balance$0","bal_u64","deriver$33","apply_json_transaction","network_json","network_state","who","application_result","static_method","method","prototype","export$1","export_global","snarky_obj"],"sources":["","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/strftime.js","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-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/bindings/ocaml/jsoo_exports/overrides.js","/builtin/+marshal.js","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/base_internalhash_types/runtime.js","/builtin/+nat.js","/builtin/+jslib.js","/nix/store/0j0bgafbbq9ld9w9jcis231jh4rzynj7-base_bigstring-v0.14.0/lib/ocaml/4.14.0/site-lib/base_bigstring/runtime.js","/builtin/+bigstring.js","/nix/store/xbsdcdn0jnvf0y1kph75cblwxmz1njba-bigstringaf-0.5.0/lib/ocaml/4.14.0/site-lib/bigstringaf/runtime.js","/nix/store/pywz3aqavgrd2bx57kg40fwhaywwbma2-bin_prot-v0.14.0/lib/ocaml/4.14.0/site-lib/bin_prot/runtime.js","/builtin/+array.js","/builtin/+backtrace.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/bindings.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/bindings-bigint256.js","/builtin/+compare.js","/builtin/+weak.js","/builtin/+gc.js","/builtin/+format.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/node_js/node_backend.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/bindings-vector.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","/nix/store/vgbwcp008szmwmgg74z0b1wjm6b9lzd3-ppx_expect-v0.14.2/lib/ocaml/4.14.0/site-lib/ppx_expect/collector/runtime.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/bindings-curve.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/bindings-field.js","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/runtime.js","/workspace_root/src/mina/src/lib/promise/js/promise.js","/workspace_root/src/mina/src/lib/integers_stubs_js/runtime.js","/nix/store/867v9v2xmbjdl25fj10mzdczkq4jpn9n-zarith_stubs_js-v0.14.1/lib/ocaml/4.14.0/site-lib/zarith_stubs_js/biginteger.js","/nix/store/867v9v2xmbjdl25fj10mzdczkq4jpn9n-zarith_stubs_js-v0.14.1/lib/ocaml/4.14.0/site-lib/zarith_stubs_js/runtime.js","/nix/store/qrl1yc5947axp1g3vb7i451ad8sqgqzq-time_now-v0.14.0/lib/ocaml/4.14.0/site-lib/time_now/runtime.js","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/obj.ml","/workspace_root/src/mina/src/lib/pickles/limb_vector/constant.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/int64.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/random.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/lexing.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/camlinternalFormat.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/printexc.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/filename.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/exn.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/sign0.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/hex_lexer.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/popcount.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/int63_emul.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/backtrace.ml","/nix/store/2p6va6pgr86b9jpd8sg2gikmr5jcbcgh-ppx_bench-v0.14.1/lib/ocaml/4.14.0/site-lib/ppx_bench/runtime-lib/benchmark_accumulator.ml","/nix/store/pywz3aqavgrd2bx57kg40fwhaywwbma2-bin_prot-v0.14.0/lib/ocaml/4.14.0/site-lib/bin_prot/shape/bin_shape.ml","/nix/store/5xwy2wc2yciacwz00gsi7jsiqaxhd9a8-stdio-v0.14.0/lib/ocaml/4.14.0/site-lib/stdio/in_channel.ml","/nix/store/5xwy2wc2yciacwz00gsi7jsiqaxhd9a8-stdio-v0.14.0/lib/ocaml/4.14.0/site-lib/stdio/out_channel.ml","/nix/store/db49bd33rlx4w9wzmw3m0y0kbvc0zglk-ppx_module_timer-v0.14.0/lib/ocaml/4.14.0/site-lib/ppx_module_timer/runtime/ppx_module_timer_runtime.ml","/nix/store/jgnkwlld3331rhqxj6p2fj6dwjpcxgjk-typerep-v0.14.0/lib/ocaml/4.14.0/site-lib/typerep/std_internal.ml","/nix/store/vgbwcp008szmwmgg74z0b1wjm6b9lzd3-ppx_expect-v0.14.2/lib/ocaml/4.14.0/site-lib/ppx_expect/collector/check_backtraces.ml","/nix/store/vm9lsm23bsi4n8ffnqsjxfcxdriicc6b-splittable_random-v0.14.0/lib/ocaml/4.14.0/site-lib/splittable_random/splittable_random.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/positions.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/perms.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/quickcheck.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/std_internal.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/span_float.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/tuple.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/digit_string_helpers.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/month.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/date0.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/percent.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/ofday_float.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/span_ns.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/ofday_ns.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/gc.ml","/nix/store/1pkh4niyyy3ns4qfq9albyp5c6s5961j-easy-format-1.3.2/lib/ocaml/4.14.0/site-lib/easy-format/easy_format.ml","/nix/store/0drrhgvdpri9gs6xrsf09jl9s3k1v8l3-yojson-1.7.0/lib/ocaml/4.14.0/site-lib/yojson/yojson.ml","/nix/store/xbsdcdn0jnvf0y1kph75cblwxmz1njba-bigstringaf-0.5.0/lib/ocaml/4.14.0/site-lib/bigstringaf/bigstringaf.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_blake2b.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_blake2s.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/digestif.ml","/workspace_root/src/mina/src/lib/blake2/blake2.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/tuple_pool/tuple_pool.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/validate.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/thread_pool_cpu_affinity/thread_pool_cpu_affinity.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/uopt/uopt.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/timing_wheel/timing_wheel.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/async_kernel_config.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/monitor.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/async_kernel.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_412.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/pprintast.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_413.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_414.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_411.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_410.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_409.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_408.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_407.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_406.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_405.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_404.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_403.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/ast_402.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_403_402.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ast/versions.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/stdppx/stdppx.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ast_builder.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/name.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/camlinternalOO.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/deriving.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/ppx_quickcheck/expander/environment.ml","/workspace_root/src/mina/src/lib/protocol_version/protocol_version.ml","/nix/store/1bbwaiffyvj49z18nwi2zlm1qdvj7zxa-bignum-v0.14.0/lib/ocaml/4.14.0/site-lib/bignum/bigint/bigint.ml","/workspace_root/src/mina/src/lib/snarky/src/base/cvar.ml","/workspace_root/src/mina/src/lib/snarky/src/base/constraint.ml","/workspace_root/src/mina/src/lib/snarky/src/base/backend_extended.ml","/workspace_root/src/mina/src/lib/snarky/src/base/checked_runner.ml","/workspace_root/src/mina/src/lib/snarky/src/base/utils.ml","/workspace_root/src/mina/src/lib/snarky/src/base/merkle_tree.ml","/workspace_root/src/mina/src/lib/snarky/src/base/snark0.ml","/workspace_root/src/mina/src/lib/pickles_types/shifted_value.ml","/workspace_root/src/mina/src/lib/pickles_types/plonk_types.ml","/workspace_root/src/mina/src/lib/pickles/pickles.ml","/workspace_root/src/mina/src/lib/pickles_types/plonk_verification_key_evals.ml","/workspace_root/src/mina/src/lib/hex/hex.ml","/workspace_root/src/mina/src/lib/snarky/sponge/sponge.ml","/workspace_root/src/mina/src/lib/allocation_functor/table.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/scale_round.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/scalar_challenge.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/curve.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/plonk_dlog_proof.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/bigint.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/endoscale_round.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/endoscale_scalar_round.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/field.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/plonk_constraint_system.ml","/workspace_root/src/mina/src/lib/snarky/fold_lib/fold.ml","/workspace_root/src/mina/src/lib/snarky/snarkette/fields.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/vesta_based_plonk.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/pallas_based_plonk.ml","/workspace_root/src/mina/src/lib/random_oracle_input/random_oracle_input.ml","/workspace_root/src/mina/src/lib/pickles_base/proofs_verified.ml","/workspace_root/src/mina/src/lib/pickles_base/side_loaded_verification_key.ml","/workspace_root/src/mina/src/lib/pickles_base/domain.ml","/workspace_root/src/mina/src/lib/pickles/composition_types/branch_data.ml","/workspace_root/src/mina/src/lib/pickles/composition_types/bulletproof_challenge.ml","/workspace_root/src/mina/src/lib/pickles/composition_types/composition_types.ml","/workspace_root/src/mina/src/lib/pickles/plonk_checks/scalars.ml","/workspace_root/src/mina/src/lib/snarky/snarky_curve/snarky_curve.ml","/workspace_root/src/mina/src/lib/snark_keys_header/snark_keys_header.ml","/workspace_root/src/mina/src/lib/error_json/error_json.ml","/workspace_root/src/mina/src/lib/pickles/wrap_wire_proof.ml","/workspace_root/src/mina/src/lib/pickles/scalar_challenge.ml","/workspace_root/src/mina/src/lib/pickles/plonk_curve_ops.ml","/workspace_root/src/mina/src/lib/pickles/reduced_messages_for_next_proof_over_same_field.ml","/workspace_root/src/mina/src/lib/pickles/step_main_inputs.ml","/workspace_root/src/mina/src/lib/pickles/side_loaded_verification_key.ml","/workspace_root/src/mina/src/lib/pickles/proof.ml","/workspace_root/src/mina/src/lib/pickles/wrap_main_inputs.ml","/workspace_root/src/mina/src/lib/pickles/wrap_verifier.ml","/workspace_root/src/mina/src/lib/pickles_types/opt.ml","/workspace_root/src/mina/src/lib/pickles/step_verifier.ml","/workspace_root/src/mina/src/lib/pickles/verification_key.ml","/workspace_root/src/mina/src/lib/pickles/proof_cache.ml","/workspace_root/src/mina/src/lib/pickles/cache.ml","/workspace_root/src/mina/src/lib/snark_params/snark_params.ml","/workspace_root/src/mina/src/lib/random_oracle/permutation/external/random_oracle_permutation.ml","/workspace_root/src/mina/src/lib/random_oracle/random_oracle.ml","/workspace_root/src/mina/src/lib/node_config/node_config.ml","/workspace_root/src/mina/src/lib/non_zero_curve_point/non_zero_curve_point.ml","/workspace_root/src/mina/src/lib/signature_lib/private_key.ml","/workspace_root/src/mina/src/lib/signature_lib/schnorr.ml","/workspace_root/src/mina/src/lib/signature_lib/keypair.ml","/workspace_root/src/mina/src/lib/sgn/sgn.ml","/workspace_root/src/mina/src/lib/sparse_ledger_lib/sparse_ledger.ml","/workspace_root/src/mina/src/lib/rosetta_coding/coding.ml","/workspace_root/src/mina/src/lib/currency/signed_poly.ml","/workspace_root/src/mina/src/lib/currency/currency.ml","/workspace_root/src/mina/src/lib/node_config/for_unit_tests/node_config_for_unit_tests.ml","/nix/store/adbsb38yzp5199nqrzr3g317kn03s4wh-re-1.9.0/lib/ocaml/4.14.0/site-lib/re/cset.ml","/nix/store/v4fdl8innpa4gcv3mwicy77kz67w2hfg-graphql_parser-0.12.2/lib/ocaml/4.14.0/site-lib/graphql_parser/parser.ml","/nix/store/v4fdl8innpa4gcv3mwicy77kz67w2hfg-graphql_parser-0.12.2/lib/ocaml/4.14.0/site-lib/graphql_parser/lexer.ml","/nix/store/xzrqi0hgad7ri5k4qfrwlsmrxzp04r8m-graphql-0.13.0/lib/ocaml/4.14.0/site-lib/graphql/graphql_schema.ml","/workspace_root/src/mina/src/lib/fields_derivers/fields_derivers.ml","/workspace_root/src/mina/src/lib/fields_derivers_graphql/fields_derivers_graphql.ml","/workspace_root/src/mina/src/lib/fields_derivers_json/fields_derivers_json.ml","/workspace_root/src/mina/src/lib/with_hash/with_hash.ml","/workspace_root/src/mina/src/lib/fields_derivers_zkapps/fields_derivers_zkapps.ml","/workspace_root/src/mina/src/lib/data_hash_lib/state_hash.ml","/workspace_root/src/mina/src/lib/genesis_constants/genesis_constants.ml","/workspace_root/src/mina/src/lib/block_time/block_time.ml","/workspace_root/src/mina/src/lib/one_or_two/one_or_two.ml","/workspace_root/src/mina/src/lib/mina_base/account_id.ml","/workspace_root/src/mina/src/lib/mina_base/account_timing.ml","/workspace_root/src/mina/src/lib/mina_base/signature.ml","/workspace_root/src/mina/src/lib/mina_base/control.ml","/workspace_root/src/mina/src/lib/mina_base/payment_payload.ml","/workspace_root/src/mina/src/lib/mina_base/ledger_hash0.ml","/workspace_root/src/mina/src/lib/mina_base/permissions.ml","/workspace_root/src/mina/src/lib/mina_base/signed_command_memo.ml","/workspace_root/src/mina/src/lib/mina_base/stake_delegation.ml","/workspace_root/src/mina/src/lib/mina_base/transaction_status.ml","/workspace_root/src/mina/src/lib/mina_base/transaction_union_tag.ml","/workspace_root/src/mina/src/lib/mina_base/signed_command_payload.ml","/workspace_root/src/mina/src/lib/mina_base/signed_command.ml","/workspace_root/src/mina/src/lib/mina_base/receipt.ml","/workspace_root/src/mina/src/lib/mina_base/state_body_hash.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_basic.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_account.ml","/workspace_root/src/mina/src/lib/mina_base/account.ml","/workspace_root/src/mina/src/lib/mina_base/epoch_ledger.ml","/workspace_root/src/mina/src/lib/mina_base/epoch_seed.ml","/workspace_root/src/mina/src/lib/mina_base/epoch_data.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_precondition.ml","/workspace_root/src/mina/src/lib/mina_base/data_as_hash.ml","/workspace_root/src/mina/src/lib/mina_base/account_update.ml","/workspace_root/src/mina/src/lib/mina_base/with_stack_hash.ml","/workspace_root/src/mina/src/lib/mina_base/with_status.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_command.ml","/workspace_root/src/mina/src/lib/mina_base/user_command.ml","/workspace_root/src/mina/src/lib/mina_base/fee_transfer.ml","/workspace_root/src/mina/src/lib/mina_base/coinbase_fee_transfer.ml","/workspace_root/src/mina/src/lib/mina_base/coinbase.ml","/workspace_root/src/mina/src/lib/mina_base/pending_coinbase.ml","/workspace_root/src/mina/src/lib/mina_base/staged_ledger_hash.ml","/workspace_root/src/mina/src/lib/mina_base/sok_message.ml","/workspace_root/src/mina/src/lib/mina_base/protocol_constants_checked.ml","/workspace_root/src/mina/src/lib/mina_base/fee_with_prover.ml","/workspace_root/src/mina/src/lib/transaction/transaction.ml","/workspace_root/src/mina/src/lib/transaction/transaction_hash.ml","/workspace_root/src/mina/src/lib/transaction_logic/mina_transaction_logic.ml","/workspace_root/src/bindings/ocaml/lib/pickles_bindings.ml","/workspace_root/src/bindings/ocaml/lib/consistency_test.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/camlinternalFormatBasics.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/camlinternalAtomic.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/stdlib.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/base.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/stdlib.mli","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/int_intf.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/float0.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/pipe.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/int_conversions.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/list.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/ppx_quickcheck/expander/import.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/sys0.ml","/nix/store/pywz3aqavgrd2bx57kg40fwhaywwbma2-bin_prot-v0.14.0/lib/ocaml/4.14.0/site-lib/bin_prot/write.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/camlinternalLazy.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/lazy.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/seq.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/option.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/result.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/char.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/int.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/bytes.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/string.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/marshal.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/array.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/int32.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/nativeint.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/parsing.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/set.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/map.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/stack.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/queue.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/buffer.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/printf.ml","/nix/store/0j0bgafbbq9ld9w9jcis231jh4rzynj7-base_bigstring-v0.14.0/lib/ocaml/4.14.0/site-lib/base_bigstring/base_bigstring.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/arg.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/printexc.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/fun.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/digest.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/random.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/hashtbl.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/attribute.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/format.ml","/nix/store/adbsb38yzp5199nqrzr3g317kn03s4wh-re-1.9.0/lib/ocaml/4.14.0/site-lib/re/fmt.ml","/nix/store/adbsb38yzp5199nqrzr3g317kn03s4wh-re-1.9.0/lib/ocaml/4.14.0/site-lib/re/pmark.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/scanf.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/callback.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/camlinternalMod.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/bigarray.ml","/nix/store/2av3dg967z8aq3i6iah4ipzm3s7d16d2-sexplib0-v0.14.0/lib/ocaml/4.14.0/site-lib/sexplib0/lazy_group_id.ml","/nix/store/2av3dg967z8aq3i6iah4ipzm3s7d16d2-sexplib0-v0.14.0/lib/ocaml/4.14.0/site-lib/sexplib0/sexp.ml","/nix/store/2av3dg967z8aq3i6iah4ipzm3s7d16d2-sexplib0-v0.14.0/lib/ocaml/4.14.0/site-lib/sexplib0/sexp_conv.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/ephemeron.ml","/nix/store/2av3dg967z8aq3i6iah4ipzm3s7d16d2-sexplib0-v0.14.0/lib/ocaml/4.14.0/site-lib/sexplib0/sexp_conv_error.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/span_helpers.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/import0.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/printf.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/array0.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/char0.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/list0.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/hash.ml","/workspace_root/src/mina/src/lib/bounded_types/bounded_types.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/ppx_compare_lib.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/string0.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/sexp.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/sexpable.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/word_size.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/pretty_printer.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/core_kernel.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/with_return.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/monad.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/comparator.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/field.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/source_code_position0.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/list1.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/result.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/container_intf.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/container.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/lazy.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/monad_intf.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/fn.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/list.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/ordering.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/applicative.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/info.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/error.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/invariant.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/maybe_bound.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/or_error.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/comparable.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/identifiable.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/comparable_intf.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/unit.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/ordered_collection_common.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/binary_search.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/binary_searchable.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/bytes0.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/blit.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/option.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/either.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/indexed_container.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/sequence.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/array.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/obj_array.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/uniform_array.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/char.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/string.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/bytes.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/pow_overflow_bounds.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/int_math.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/int.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/type_equal.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/univ_map.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/option_array.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/stack.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/set.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/set_intf.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/queue.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/nothing.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/never_returns.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/nativeint.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/map.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/map_intf.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/int64.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/bool.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/int32.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/int63.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/hashtbl.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/hashtbl_intf.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/hashable_intf.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/avltree.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/hash_set_intf.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/hash_set.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/float.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/buffer.ml","/nix/store/wvp9z6pjvgy3a520br5r5z85s089qrcp-ppx_assert-v0.14.0/lib/ocaml/4.14.0/site-lib/ppx_assert/runtime-lib/runtime.ml","/nix/store/wbxz75rbcss8c34aimp81fglzvwd2g9p-base-v0.14.3/lib/ocaml/4.14.0/site-lib/base/md5/md5_lib.ml","/nix/store/pywz3aqavgrd2bx57kg40fwhaywwbma2-bin_prot-v0.14.0/lib/ocaml/4.14.0/site-lib/bin_prot/common.ml","/workspace_root/src/mina/src/lib/pickles_types/vector.ml","/nix/store/pywz3aqavgrd2bx57kg40fwhaywwbma2-bin_prot-v0.14.0/lib/ocaml/4.14.0/site-lib/bin_prot/read.ml","/nix/store/pywz3aqavgrd2bx57kg40fwhaywwbma2-bin_prot-v0.14.0/lib/ocaml/4.14.0/site-lib/bin_prot/shape.ml","/nix/store/pywz3aqavgrd2bx57kg40fwhaywwbma2-bin_prot-v0.14.0/lib/ocaml/4.14.0/site-lib/bin_prot/size.ml","/nix/store/pywz3aqavgrd2bx57kg40fwhaywwbma2-bin_prot-v0.14.0/lib/ocaml/4.14.0/site-lib/bin_prot/type_class.ml","/nix/store/pywz3aqavgrd2bx57kg40fwhaywwbma2-bin_prot-v0.14.0/lib/ocaml/4.14.0/site-lib/bin_prot/utils.ml","/nix/store/pywz3aqavgrd2bx57kg40fwhaywwbma2-bin_prot-v0.14.0/lib/ocaml/4.14.0/site-lib/bin_prot/std.ml","/nix/store/32j9id74ljgmmys10y7ccjj00rz1g6f9-ppx_inline_test-v0.14.1/lib/ocaml/4.14.0/site-lib/ppx_inline_test/config/inline_test_config.ml","/nix/store/qrl1yc5947axp1g3vb7i451ad8sqgqzq-time_now-v0.14.0/lib/ocaml/4.14.0/site-lib/time_now/time_now.ml","/nix/store/32j9id74ljgmmys10y7ccjj00rz1g6f9-ppx_inline_test-v0.14.1/lib/ocaml/4.14.0/site-lib/ppx_inline_test/runtime-lib/runtime.ml","/nix/store/jgnkwlld3331rhqxj6p2fj6dwjpcxgjk-typerep-v0.14.0/lib/ocaml/4.14.0/site-lib/typerep/typename.ml","/nix/store/jgnkwlld3331rhqxj6p2fj6dwjpcxgjk-typerep-v0.14.0/lib/ocaml/4.14.0/site-lib/typerep/make_typename.ml","/nix/store/jgnkwlld3331rhqxj6p2fj6dwjpcxgjk-typerep-v0.14.0/lib/ocaml/4.14.0/site-lib/typerep/variant_and_record_intf.ml","/nix/store/jgnkwlld3331rhqxj6p2fj6dwjpcxgjk-typerep-v0.14.0/lib/ocaml/4.14.0/site-lib/typerep/typerep_obj.ml","/nix/store/jgnkwlld3331rhqxj6p2fj6dwjpcxgjk-typerep-v0.14.0/lib/ocaml/4.14.0/site-lib/typerep/type_abstract.ml","/nix/store/vgbwcp008szmwmgg74z0b1wjm6b9lzd3-ppx_expect-v0.14.2/lib/ocaml/4.14.0/site-lib/ppx_expect/common/file.ml","/nix/store/vgbwcp008szmwmgg74z0b1wjm6b9lzd3-ppx_expect-v0.14.2/lib/ocaml/4.14.0/site-lib/ppx_expect/collector/expect_test_collector.ml","/nix/store/vgbwcp008szmwmgg74z0b1wjm6b9lzd3-ppx_expect-v0.14.2/lib/ocaml/4.14.0/site-lib/ppx_expect/config_types/expect_test_config_types_intf.ml","/nix/store/vgbwcp008szmwmgg74z0b1wjm6b9lzd3-ppx_expect-v0.14.2/lib/ocaml/4.14.0/site-lib/ppx_expect/config_types/expect_test_config_types.ml","/nix/store/vgbwcp008szmwmgg74z0b1wjm6b9lzd3-ppx_expect-v0.14.2/lib/ocaml/4.14.0/site-lib/ppx_expect/config/expect_test_config.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/generator.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/bigarray_helpers.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/observer0.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/shrinker.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/test.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/observer.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/base_for_tests/test_blit.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/base_for_tests/test_binary_searchable.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/parsexp.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/automaton_stack.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/of_sexp_error.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/parse_error.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/parser_automaton_internal.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/parser_automaton.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/kind.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/automaton_helpers.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/parser.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/conv.ml","/nix/store/pnq2m3qvizxv1mg1hdcjnyyacv5abg1l-sexplib-v0.14.0/lib/ocaml/4.14.0/site-lib/sexplib/pre_sexp.ml","/nix/store/8ipy7zzf6y6q6bzn8vjl08lxi46f0a84-parsexp-v0.14.2/lib/ocaml/4.14.0/site-lib/parsexp/old_parser_cont_state.ml","/nix/store/pnq2m3qvizxv1mg1hdcjnyyacv5abg1l-sexplib-v0.14.0/lib/ocaml/4.14.0/site-lib/sexplib/conv.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/import.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/sexpable.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/binable_intf.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/binable0.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/printf.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/comparator.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/result.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/container.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/deprecate_pipe_bang.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/fn.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/ordered_collection_common.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/sequence.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/array.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/source_code_position0.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/info.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/error.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/t.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/list0.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/hashtbl.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/hash_set.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/or_error.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/map.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/set.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/comparable.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/doubly_linked_intf.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/list.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/option.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/union_find.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/doubly_linked.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/bag.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/sexp.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/hash_queue.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/hashable.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/identifiable.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/bool.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/hexdump_intf.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/hexdump.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/string.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/bytes.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/char.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/core_pervasives.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/sign.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/float.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/int.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/int32.ml","/workspace_root/src/mina/src/lib/unsigned_extended/unsigned_extended.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/int64.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/int63.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/unit.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/interfaces.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/lazy.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/nativeint.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/nothing.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/ordering.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/ref.ml","/workspace_root/src/mina/src/lib/transaction_logic/zkapp_command_logic.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/byte_units0.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/bigstring.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/core_bin_prot.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/md5.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/zone_intf.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/binable.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/zone.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/source_code_position.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/validated.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/type_equal.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/univ_map_intf.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/unit_of_time.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/unique_id.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/uniform_array.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/day_of_week.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/ofday_helpers.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/stable_internal.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/float_with_finite_only_serialization.ml","/workspace_root/src/mina/src/lib/timeout_lib/timeout_lib.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/time_intf.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/time.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/time_float0.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/time_float.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/time_ns.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/time_ns_alternate_sexp.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/set_once.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/heap_block.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/queue.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/option_array.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/memo.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/deque.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/debug.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/bag_intf.ml","/nix/store/vw36235nykag7qqqyifnwcf1w1hqzs1z-integers-0.4.0/lib/ocaml/4.14.0/site-lib/integers/unsigned.ml","/nix/store/276h7f2dbjlcqc4j37w42dckgn7adwki-biniou-1.2.1/lib/ocaml/4.14.0/site-lib/biniou/bi_util.ml","/nix/store/276h7f2dbjlcqc4j37w42dckgn7adwki-biniou-1.2.1/lib/ocaml/4.14.0/site-lib/biniou/bi_outbuf.ml","/nix/store/276h7f2dbjlcqc4j37w42dckgn7adwki-biniou-1.2.1/lib/ocaml/4.14.0/site-lib/biniou/bi_share.ml","/nix/store/740dqrj2kkwx403xiy5fdjv17k2fyhyn-ppx_deriving_yojson-3.6.1/lib/ocaml/4.14.0/site-lib/ppx_deriving_yojson/runtime/ppx_deriving_yojson_runtime.ml","/workspace_root/src/mina/src/lib/ppx_version/runtime/shapes.ml","/nix/store/klawzf016id66pnhl1vci4q5rj9ngn0h-angstrom-0.15.0/lib/ocaml/4.14.0/site-lib/angstrom/input.ml","/nix/store/klawzf016id66pnhl1vci4q5rj9ngn0h-angstrom-0.15.0/lib/ocaml/4.14.0/site-lib/angstrom/parser.ml","/nix/store/klawzf016id66pnhl1vci4q5rj9ngn0h-angstrom-0.15.0/lib/ocaml/4.14.0/site-lib/angstrom/angstrom.ml","/workspace_root/src/mina/src/lib/logproc_lib/interpolator.ml","/workspace_root/src/mina/src/lib/structured_log_events/structured_log_events.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/stubs/pasta_bindings.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/stubs/kimchi_bindings.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/digestif_bi.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/digestif_by.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/xor.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/digestif_conv.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_md5.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_rmd160.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_sha1.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_sha256.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_sha224.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_sha3.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_sha3_512.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_sha512.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_sha384.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_sha3_224.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_sha3_256.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_sha3_384.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/baijiu_whirlpool.ml","/nix/store/396bmy1k31lqjhl2x0h6hn0cmild3dhx-digestif-0.9.0/lib/ocaml/4.14.0/site-lib/digestif/ocaml/digestif_eq.ml","/nix/store/1mn9f5y20wg48xvhsv49w1x3z9s4ggri-eqaf-0.9/lib/ocaml/4.14.0/site-lib/eqaf/eqaf.ml","/workspace_root/src/mina/src/lib/mina_wire_types/block_time.ml","/workspace_root/src/mina/src/lib/mina_wire_types/currency.ml","/workspace_root/src/mina/src/lib/mina_wire_types/pickles/pickles_composition_types.ml","/workspace_root/src/mina/src/lib/mina_wire_types/pickles/pickles.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_account_id.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_numbers.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_call_stack_digest.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_coinbase_fee_transfer.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_coinbase.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_fee_transfer.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_pending_coinbase.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_signed_command_memo.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_signed_command.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_sok_message.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_stack_frame.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_staged_ledger_hash.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_zkapp_command.ml","/workspace_root/src/mina/src/lib/mina_wire_types/protocol_version.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/tuple_pool/tuple_type_intf.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/tuple_pool/tuple_type.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/pairing_heap/pairing_heap.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/sexp_hidden_in_test/sexp_hidden_in_test.ml","/nix/store/igaklwi3s15667y44rj682c92vws67if-core_kernel-v0.14.1/lib/ocaml/4.14.0/site-lib/core_kernel/thread_safe_queue/thread_safe_queue.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/time_ns.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/monitor0.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/debug.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/import.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/priority.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/types.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/execution_context.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/job_queue.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/tracing.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/external_job.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/job_pool.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/job_or_event.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/scheduler0.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/synchronous_time_source0.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/scheduler1.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/scheduler.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/ivar0.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/deferred0.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/ivar.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/monad_sequence.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/deferred1.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/deferred_std.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/ivar_filler.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/tail.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/async_stream.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/synchronous_time_source.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/bvar.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/time_source.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/stack_or_counter.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/throttle.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/async_kernel_scheduler.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/clock_ns.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/deferred_list.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/deferred_result.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/deferred_or_error.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/deferred_queue.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/deferred.ml","/nix/store/20g31cgvy1y7bx55af0vr948ygh00jz0-async_kernel-v0.14.0/lib/ocaml/4.14.0/site-lib/async_kernel/async_gc.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ast/ast_helper_lite.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/uchar.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/stdlib0.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/location.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/code_matcher.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_414_413.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_413_414.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_413_412.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_412_413.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_412_411.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_411_412.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_411_410.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_410_411.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_410_409.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_409_410.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_409_408.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_408_409.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_408_407.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_407_408.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_407_406.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_406_407.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_406_405.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_405_406.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_405_404.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_404_405.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_404_403.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_403_404.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/astlib/migrate_402_403.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ast/import.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ast/ast.ml","/nix/store/vqnd9wv44zrf52qszlhghmn077wid4m4-ppx_derivers-1.2.1/lib/ocaml/4.14.0/site-lib/ppx_derivers/ppx_derivers.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/traverse_builtins/ppxlib_traverse_builtins.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/longident.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/code_path.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/location.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ast/location_error.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/expansion_context.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ast_traverse.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/spellcheck.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ast_pattern0.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ast_builder_generated.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/caller_id.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/common.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ast_pattern_generated.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ast_pattern.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/extension.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/context_free.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/driver.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/merlin_helpers.ml","/nix/store/x4lilyn7619p1aplp6z7rvbn33yklgil-ppxlib-0.25.0/lib/ocaml/4.14.0/site-lib/ppxlib/ignore_unused_warning.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/ppx_quickcheck/expander/clause_syntax.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/ppx_quickcheck/expander/field_syntax.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/ppx_quickcheck/expander/ppx_shrinker_expander.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/ppx_quickcheck/expander/ppx_generator_expander.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/ppx_quickcheck/expander/ppx_observer_expander.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/ppx_quickcheck/expander/ppx_quickcheck_expander.ml","/nix/store/ib5fq18ky3jyczhyzy8hiak5arx9z6w8-base_quickcheck-v0.14.1/lib/ocaml/4.14.0/site-lib/base_quickcheck/ppx_quickcheck/ppx_quickcheck.ml","/workspace_root/src/mina/src/lib/snarky/snarkette/nat.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/double.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/intf.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/four.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/quadruple.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/triple.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/tuple_lib.ml","/workspace_root/src/mina/src/lib/key_cache/key_cache.ml","/workspace_root/src/mina/src/lib/snarky/bitstring_lib/bitstring.ml","/workspace_root/src/mina/src/lib/snark_bits/bits.ml","/workspace_root/src/mina/src/lib/snarky/interval_union/interval_union.ml","/workspace_root/src/mina/src/lib/snarky/src/base/handle.ml","/workspace_root/src/mina/src/lib/snarky/src/base/monad_let.ml","/workspace_root/src/mina/src/lib/snarky/src/base/request.ml","/workspace_root/src/mina/src/lib/snarky/src/base/checked.ml","/workspace_root/src/mina/src/lib/snarky/src/base/types.ml","/workspace_root/src/mina/src/lib/snarky/src/base/as_prover0.ml","/workspace_root/src/mina/src/lib/snarky/src/base/run_state.ml","/workspace_root/src/mina/src/lib/snarky/src/base/checked_intf.ml","/workspace_root/src/mina/src/lib/snarky/src/base/as_prover_ref.ml","/workspace_root/src/mina/src/lib/snarky/src/base/boolean.ml","/workspace_root/src/mina/src/lib/snarky/src/base/runners.ml","/workspace_root/src/mina/src/lib/snarky/src/base/typ.ml","/workspace_root/src/mina/src/lib/snarky/src/base/monad_sequence.ml","/workspace_root/src/mina/src/lib/snarky/src/base/enumerable.ml","/workspace_root/src/mina/src/lib/snarky/src/base/number.ml","/workspace_root/src/mina/src/lib/snarky/src/base/snark.ml","/workspace_root/src/mina/src/lib/pickles_types/nat.ml","/workspace_root/src/mina/src/lib/pickles_types/hlist0.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_state.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/basic/kimchi_pasta_basic.ml","/workspace_root/src/mina/src/lib/pickles_types/hlist.ml","/workspace_root/src/mina/src/lib/pickles_types/or_infinity.ml","/workspace_root/src/mina/src/lib/pickles/plonk_checks/plonk_checks.ml","/workspace_root/src/mina/src/lib/pickles_types/pcs_batch.ml","/workspace_root/src/mina/src/lib/pickles_types/at_most.ml","/workspace_root/src/mina/src/lib/snarky/sponge/params.ml","/workspace_root/src/mina/src/lib/snarky/sponge/constants.ml","/workspace_root/src/mina/src/lib/logger/fake/logger.ml","/workspace_root/src/mina/src/lib/allocation_functor/make.ml","/workspace_root/src/mina/src/lib/promise/js/promise.ml","/workspace_root/src/mina/src/lib/logger/context_logger/context_logger.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/poly_comm.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/plonk_dlog_oracles.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/constants.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/dlog_plonk_based_keypair.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/kimchi_backend_common.ml","/workspace_root/src/bindings/ocaml/lib/snarky_bindings.ml","/workspace_root/src/mina/src/lib/pickles/make_sponge.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/constraint_system/caml/vesta_constraint_system.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/constraint_system/caml/pallas_constraint_system.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/kimchi_pasta.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/kimchi_backend.ml","/workspace_root/src/mina/src/lib/pickles/backend/backend.ml","/workspace_root/src/mina/src/lib/snarky/group_map/bw19.ml","/workspace_root/src/mina/src/lib/cache_dir/fake/cache_dir.ml","/workspace_root/src/mina/src/lib/snarky/group_map/group_map.ml","/nix/store/rjwhg8i7ilr3mp6igyiqdc1ya444iij6-base64-3.4.0/lib/ocaml/4.14.0/site-lib/base64/base64.ml","/workspace_root/src/mina/src/lib/snarky_group_map/checked_map.ml","/workspace_root/src/mina/src/lib/snarky_group_map/snarky_group_map.ml","/workspace_root/src/mina/src/lib/pickles_base/one_hot_vector/one_hot_vector.ml","/workspace_root/src/mina/src/lib/pickles_base/domains.ml","/workspace_root/src/mina/src/lib/pickles/limb_vector/make.ml","/workspace_root/src/mina/src/lib/pickles/limb_vector/challenge.ml","/workspace_root/src/mina/src/lib/pickles/composition_types/digest.ml","/workspace_root/src/mina/src/lib/pickles/composition_types/spec.ml","/workspace_root/src/mina/src/lib/pickles/pseudo/pseudo.ml","/workspace_root/src/mina/src/lib/base58_check/version_bytes.ml","/workspace_root/src/mina/src/lib/base58_check/base58_check.ml","/workspace_root/src/mina/src/lib/codable/codable.ml","/workspace_root/src/mina/src/lib/pickles/import.ml","/workspace_root/src/mina/src/lib/pickles/util.ml","/workspace_root/src/mina/src/lib/pickles/endo.ml","/workspace_root/src/mina/src/lib/pickles/common.ml","/workspace_root/src/mina/src/lib/pickles/impls.ml","/workspace_root/src/mina/src/lib/pickles/tick_field_sponge.ml","/workspace_root/src/mina/src/lib/pickles/dummy.ml","/workspace_root/src/mina/src/lib/pickles/wrap_main.ml","/workspace_root/src/mina/src/lib/pickles/opt_sponge.ml","/workspace_root/src/mina/src/lib/pickles/commitment_lengths.ml","/workspace_root/src/mina/src/lib/pickles/evaluation_lengths.ml","/workspace_root/src/mina/src/lib/pickles/ro.ml","/workspace_root/src/mina/src/lib/pickles/compile.ml","/workspace_root/src/mina/src/lib/pickles/sponge_inputs.ml","/workspace_root/src/mina/src/lib/pickles/tock_field_sponge.ml","/workspace_root/src/mina/src/lib/pickles/wrap_hack.ml","/workspace_root/src/mina/src/lib/pickles/wrap_proof.ml","/workspace_root/src/mina/src/lib/pickles/tag.ml","/workspace_root/src/mina/src/lib/pickles/inductive_rule.ml","/workspace_root/src/mina/src/lib/pickles/types_map.ml","/workspace_root/src/mina/src/lib/pickles/per_proof_witness.ml","/workspace_root/src/mina/src/lib/pickles/unfinalized.ml","/workspace_root/src/mina/src/lib/pickles/requests.ml","/workspace_root/src/mina/src/lib/pickles/timer.ml","/workspace_root/src/mina/src/lib/pickles/fix_domains.ml","/workspace_root/src/mina/src/lib/pickles/wrap_domains.ml","/workspace_root/src/mina/src/lib/pickles/wrap.ml","/workspace_root/src/mina/src/lib/pickles/wrap_deferred_values.ml","/workspace_root/src/mina/src/lib/pickles/verify.ml","/workspace_root/src/mina/src/lib/pickles/step_main.ml","/workspace_root/src/mina/src/lib/pickles/step_branch_data.ml","/workspace_root/src/mina/src/lib/pickles/step.ml","/workspace_root/src/mina/src/lib/pickles/dirty.ml","/workspace_root/src/mina/src/lib/pickles/cache_handle.ml","/workspace_root/src/mina/src/lib/crypto_params/group_map_params.ml","/workspace_root/src/mina/src/lib/crypto_params/crypto_params.ml","/workspace_root/src/mina/src/lib/bignum_bigint/bignum_bigint.ml","/workspace_root/src/mina/src/lib/snarky_field_extensions/field_extensions.ml","/workspace_root/src/mina/src/lib/snarky_curves/snarky_curves.ml","/workspace_root/src/mina/src/lib/mina_stdlib/list.ml","/workspace_root/src/mina/src/lib/mina_stdlib/result.ml","/workspace_root/src/mina/src/lib/mina_stdlib/nonempty_list.ml","/workspace_root/src/mina/src/lib/snark_bits/bits_intf.ml","/workspace_root/src/mina/src/lib/snark_params/snark_util.ml","/workspace_root/src/mina/src/lib/snark_params/snark_intf.ml","/workspace_root/src/mina/src/lib/data_hash_lib/data_hash.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/pasta_fp_poseidon/kimchi_pasta_fp_poseidon.ml","/workspace_root/src/mina/src/lib/signature_kind/compile_config/mina_signature_kind.ml","/workspace_root/src/mina/src/lib/hash_prefixes/hash_prefixes.ml","/nix/store/vjri16x9f3vpyz2h1ima45qsi37blhgm-js_of_ocaml-compiler-4.0.0/lib/ocaml/4.14.0/site-lib/js_of_ocaml-compiler/runtime/jsoo_runtime.ml","/nix/store/rlngxmg9m2yii9yd922nbry0d7c6pfk2-js_of_ocaml-4.0.0/lib/ocaml/4.14.0/site-lib/js_of_ocaml/js.ml","/workspace_root/src/mina/src/lib/hash_prefix_states/hash_prefix_create/js/hash_prefix_create.ml","/workspace_root/src/mina/src/lib/hash_prefix_states/hash_prefix_states.ml","/workspace_root/src/mina/src/lib/test_util/test_util.ml","/workspace_root/src/mina/src/lib/non_zero_curve_point/compressed_poly.ml","/workspace_root/src/bindings/ocaml/lib/local_ledger.ml","/workspace_root/src/mina/src/lib/signature_lib/public_key.ml","/workspace_root/src/mina/src/lib/sparse_ledger_lib/inputs.ml","/workspace_root/src/mina/src/lib/dummy_values/dummy_values.ml","/workspace_root/src/mina/src/lib/unsigned_extended/intf.ml","/workspace_root/src/mina/src/lib/mina_numbers/nat.ml","/workspace_root/src/mina/src/lib/mina_numbers/intf.ml","/workspace_root/src/mina/src/lib/mina_numbers/zkapp_version.ml","/workspace_root/src/mina/src/lib/mina_numbers/txn_version.ml","/workspace_root/src/mina/src/lib/mina_numbers/account_nonce.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot_intf.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot_legacy.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot_span.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot_since_genesis.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot_since_hard_fork.ml","/workspace_root/src/mina/src/lib/mina_numbers/hd_index.ml","/workspace_root/src/mina/src/lib/mina_numbers/index.ml","/workspace_root/src/mina/src/lib/mina_numbers/length.ml","/workspace_root/src/mina/src/lib/mina_numbers/mina_numbers.ml","/workspace_root/src/mina/src/lib/currency/intf.ml","/nix/store/adbsb38yzp5199nqrzr3g317kn03s4wh-re-1.9.0/lib/ocaml/4.14.0/site-lib/re/core.ml","/nix/store/v4fdl8innpa4gcv3mwicy77kz67w2hfg-graphql_parser-0.12.2/lib/ocaml/4.14.0/site-lib/graphql_parser/graphql_parser.ml","/workspace_root/src/mina/src/lib/fields_derivers_zkapps/fields_derivers_js.ml","/workspace_root/src/mina/src/lib/data_hash_lib/data_hash_intf.ml","/workspace_root/src/mina/src/lib/block_time/intf.ml","/workspace_root/src/mina/src/lib/quickcheck_lib/quickcheck_lib.ml","/workspace_root/src/mina/src/lib/mina_base/util/mina_base_util.ml","/workspace_root/src/mina/src/lib/mina_base/account_id_intf.ml","/workspace_root/src/mina/src/lib/mina_base/hash_prefix.ml","/workspace_root/src/mina/src/lib/mina_base/data_hash.ml","/workspace_root/src/mina/src/lib/mina_base/token_id.ml","/workspace_root/src/mina/src/lib/mina_base/fee_excess.ml","/workspace_root/src/mina/src/lib/mina_base/ledger_hash_intf0.ml","/workspace_root/src/mina/src/lib/mina_base/frozen_ledger_hash0.ml","/workspace_root/src/mina/src/lib/mina_base/signed_command_memo_intf.ml","/workspace_root/src/mina/src/lib/mina_base/transaction_union_payload.ml","/workspace_root/src/mina/src/lib/mina_base/signed_command_intf.ml","/workspace_root/src/mina/src/lib/mina_base/side_loaded_verification_key.ml","/workspace_root/src/mina/src/lib/mina_base/state_hash.ml","/workspace_root/src/mina/src/lib/mina_base/verification_key_wire.ml","/workspace_root/src/mina/src/lib/mina_base/ledger_hash.ml","/workspace_root/src/mina/src/lib/mina_base/ledger_hash_intf.ml","/workspace_root/src/mina/src/lib/mina_base/frozen_ledger_hash.ml","/workspace_root/src/mina/src/lib/mina_base/digest_intf.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_statement.ml","/workspace_root/src/mina/src/lib/mina_base/prover_value.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_call_forest.ml","/workspace_root/src/mina/src/lib/mina_base/fee_transfer_intf.ml","/workspace_root/src/mina/src/lib/mina_base/coinbase_fee_transfer_intf.ml","/workspace_root/src/mina/src/lib/mina_base/coinbase_intf.ml","/workspace_root/src/mina/src/lib/mina_base/pending_coinbase_intf.ml","/workspace_root/src/mina/src/lib/run_in_thread/fake/run_in_thread.ml","/workspace_root/src/mina/src/lib/mina_base/staged_ledger_hash_intf.ml","/workspace_root/src/mina/src/lib/mina_base/stack_frame.ml","/workspace_root/src/mina/src/lib/mina_base/sparse_ledger_base.ml","/workspace_root/src/mina/src/lib/mina_base/sok_message_intf.ml","/workspace_root/src/mina/src/lib/mina_base/proof.ml","/workspace_root/src/mina/src/lib/mina_base/pending_coinbase_witness.ml","/workspace_root/src/mina/src/lib/mina_base/call_stack_digest_intf.ml","/workspace_root/src/mina/src/lib/mina_base/call_stack_digest.ml","/workspace_root/src/mina/src/lib/mina_base/ledger_intf.ml","/workspace_root/src/mina/src/lib/mina_base/mina_base.ml","/workspace_root/src/bindings/ocaml/lib/util.ml","/workspace_root/src/bindings/ocaml/lib/o1js_bindings_lib.ml","/workspace_root/src/bindings/ocaml/jsoo_exports/o1js_node.ml","/nix/store/12025gwcvnhg66dh6v6974viyq1b28ki-ocaml-base-compiler-4.14.0/lib/ocaml/std_exit.ml"],"mappings":"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;;;;;;;;;KC/NEC;KAhJAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCzHYr6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KDgSDs6C;KE1KXC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KC2I8BC;KAAN98B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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AFAF;uBACAC;uBnB8GF8+D;uBAMAtC;uBAEAD;uBACAD;uBmBnHEl8D;uBhNlBA8nD;uB6LgJFmU;uBAGAD;uBAIAyC;uBACAD;;;uBG7CE5Z;uBAbAJ;uBA4CAM;uBAlBAD;uBH+CF2X;uBAmDAV;uBGlNM/7D;uBADAD;uBHgONi8D;;uBAIA6C;uBAIAC;uBAGAG;uBAGAD;uBAGAD;uBAMAe;uBAMAD;;uBnL1GEmoB;;;;;;;;;uBYLIjoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBZiBJ7H;;;;uBpB1KiB5G;;;uB0MiDjBxN;uBAaAM;uB1MrCE9O;uBAzBe+b;uBqMyafhkB;uBEjYIgnB;uBvMxCW9C;uB0MHjBhxD;uB1MGiBywC;;;;;;uBqM6ZfI;uBADAD;uBrM5ZeG;;;;;;;;uBuMwCXihB;;;;uBACAG;;;;;;;;;uBvMzCWS;;uBuM8CnBiB;uBvM9CmB9wF;uBCoDHC;uBDpDGC;;;;;;;uBuMqFnBgxF;uBACAD;uBvMtFmBhB;;uBuM2FnBkB;uBvM3FmB5C;;;;;;uBuMiHX6C;;;;;uBvMjHWr0D;;;;;;;;uBUtBjBynD;uBVsBiB4J;;;;uB0MkGjBjN;uBAaAI;uB1M/GiBgP;;uB0MyJjB7O;uB1MzJiBG;;;uBE6LJzsH;uBAAHF;uBF7LOg5H;;;;;;;;;;uBoB0HjBm2B;;;;uBmLxFFx6B;uBAIQ0B;;uBGkCNxK;uBAgBAG;;uBlLeF0I;uB6K0ZI5f;;uBEzdI8f;uBG1CNzsD;uBH0CMixC;;;;;;uBF6cJI;uBADAD;uBE5cIG;;;;;;;;uBqF+KEmb;;;;uBACAG;;;;;;;;;uBrF9KFS;;;;uBoBAQztD;;uBpBWhBivD;uBACAD;uBACAD;uBAGAM;uBAKAnB;;uBAsBAqB;uBACAD;uBACAR;uBACAb;uBAGAuB;uBA2CAxB;uBAEAD;uBACAD;;uBAWAD;uBAGAD;uBAtCQ6B;;;;;;;;uBAeRL;uBAMApB;uBAEAD;uBACAD;;uBAIAtG;uBAOAqG;uBAGAD;uBAIAuB;uBACAD;uBGhCE5K;uBAkBAC;uB1M9IiBI;uB0MyJjBH;;;uBHkBF4J;uBAmDAV;uBGpOExtD;uBADAD;uBHkPF0tD;;uBAIAW;uBAIAC;uBAGAG;uBAGAD;uBAGAD;uBAMAuB;uBAMAD;;uBnLpGE23B;mB2UyKII;mBAcAG;mBAcAC;mBAcAC;mBAcAC;kBlVxZF5iB;kByUTO;mBUGP,uCAEsB;;6BCDfnrI,EAASvD,EAAGgF,KAAMwkF;sBAC1B,OADoBxkF;;;;;+DzKqGjB4sH,ayKrGiB5sH;+BAGlB,WAHMzB,EAASvD,EAAGgF,KAAMwkF,KAGT;;6BFGNjmF,EAAUyB,KAAM8zF;sBACzB,OADmB9zF;;;;;+DvK+FlB4sH,auK/FkB5sH;0CAAVzB,EAAUyB,KAAM8zF,OAGO;mCAMf9zF,YAAkB,OAAlBA,IAAsB;;6BAYhCzB,EAAGyB;sBAAO,sBAAqB8zF;wBAAU,gBAAzCv1F,EAAGyB,KAA4B8zF,OAAkC,CAAC;;6BAQjEv1F,EAAGP;sBAChB,SAAQkxF,KAAMlvF,KAAM8zF;wB,IAANiE;wBACZ;0BAAQ,eAFGx5F,EACCw5F,OAAMjE,QAEZ,iBAHQ91F,EAEVhD;0BACE,UACM,IAALzB,WAAK,OAALA;0BAFC,IAGa,6BAJTw+F;mCAI2B;sBAJzC,OAAQ7I,IAMG;;6BAGF3wF,EAAGP;sBAAI;+BAAPO,WAA4BvD,GAAQ,kBAAjCgD,EAAyBhD,UAAiC,EAAC;mBxUmJnEuxJ;6BwUlJKvxJ,GAAI,6BAAiC,OAArCA,CAAsC,CAAC;;6BAC1CuD,EAAGP;sBAAI,gBAAagC,KAAM8zF;wBAAY,kBAAnC91F,EAAmC,SAAtCO,EAAoByB,KAAM8zF,QAAsC,CAAC;;6BAE/D04D,GAAGC;sBACX,gBAAazsJ,KAAM8zF;wBACT,eAFF04D,GACKxsJ,KAAM8zF,QAET,WAHC24D,GACEzsJ,KAAM8zF;wBAET,kBADJ91F,EACAhD,EACD,CAAC;;6BAGCuD,EAAGP;sBACV,gBAAagC,KAAM8zF;wBACT,IAAJ94F,EAAI,SAFHuD,EACMyB,KAAM8zF;wBAER,2BAHD91F,EAEJhD,GADOgF,KAAM8zF,OAEW,CAAC;mBAczB44D;6CxUuHFH,kBwUvHEG;;;mBAeAC;+CxUwGFJ,UwUxGEI;;;;6BAWIh1C;sBACP,YADOA,MAEL;sBACO;qCAHFA;uBAKD,cxJ2LEyxB,WwJ7LP5/H;uBAAQ;sBAEH,sBACYsqF;wBACP,IAARrqF,MAAQ,MADOqqF,OAFjB33F,GACAE;wBAGF,wBALEmN,MAIEC,iBACS,CAAC;;6BAGRkuG,MAAY,mCAAZA,MAA0B;;6BAEfkI;sBAChB,YADgBA,OAEd;sBACiB;mCAHHA;uBAGG;;uBACJ,oBADL+sC;uBAGC;+BAFVE,uCAE6D,SAAE;uBAE/D;;0BALAD;;mCAKoCpjJ,MAAMm6B,IAAImpH;4BACrC,iBADqCA;6BAG1C;;6D1JgNJxkB,c0JnN8CwkB;4BAOzC,GAPyCA;6BAS1C;;6D1J0MJxkB,c0JnN8CwkB;4BAa3B,IAAbC,WAboCppH,MAAImpH;4BAc5C,eAjBYvjJ,MAGsBC,MAa9BujJ;4BACJ,OADIA,UAEM;sBAEX,GApBDtxH,UAsBA;;;8CAIiBo4D;iCACN;iDADMA,UA1BjBp4D;kCA6BA;;uDA7BclyB,M1JwMdysG,wB0J7KEg3C;iCAEF;mCAMc,IAATxjJ;mCAAS,wBApCdqjJ,YAoCKrjJ;iCACG,6BAAY,EAG8B;;6BAC5CyjJ;sBAAS,gBAAaltJ,KAAM8zF;wBAAU;4CAAtCo5D;yBAAsC;;4BAAtCA;0ChJzIR1vF,iBgJyIQ0vF;wBAA+C,sBAAzBltJ,KAAM8zF,OAA+C,CAAC;;6BAExEq5D;sBACd,IAAQD;sBACR;wBADQA;;;2BAA4B,kBADtBC,aACsB,UAA5BD,QAA4C;sBAApD,UACA,aADQA;sBACR;+BADQA;6ChJ5IN1vF,iBgJ4IM0vF,cACI;;6BA4BF3lH;sBACV,GADUA,IAAa,QAAbA,kBAAai9B,aAAb4oF;sBACV;uBADyC,mBAAbC,WAAat+D;;2BAAbs+D,WtJ2XxBrzF;sBsJ1XJ,gBAAah6D,KAAM8zF;wBACV,GAFCs5D,cAAkBC;0BAGR;6DAHVD,WACGptJ;2BAIN;4BALGotJ,cAGJvvC;8BAGG,MANmBwvC,WAGtBxvC;8BAHsBwvC;2BAUhB,eA8JNrB,YAvKal4D,OADTs5D,WAIJE;0BASD,GAHC9xJ,UAIC;0BAXa;2BAaJ,aANVA,oBAMsC,QAAC;2BACzB;;8BxJqFT4tI,WwJrGEppI,KAgBc,WxJqFhBopI,WwJ5FL5tI,IAVI4xJ;2BAkBU,qBxJoFThkB,WwJ5FL5tI;2BAQc;gCADZ+xJ;;4BAIF;8BAAY;gDAmJZvB,YAvKal4D,SAiBX05D;+BAIe;;8DANfzqJ,MAKE0G;8BACJ,iBANE1G,MAKE0G;8BAAQ;iCAJV8jJ;;0BAdY,IAsBH,iBxJ6ENnkB,WwJpFHokB,aAOJ;0BAAa;gCAAbz0J;4BACE;8BAAQ,IAAJ4F,EAAI,MAzBKm1F,OAwBf/6F,EAPIy0J;8BASF,KAXEzqJ,MASJhK,EACM4F;8BAAI,UADV5F;;;0BAtBgB,UA0BgC,WxJyEzCqwI,WwJ5FL5tI,IAVI4xJ;0BA6BC;4BAAC;;;mCvK/GVvgC,Oe9BFU,WwJgIQxqH,sBAAoC,YAAC;;;4BAfhC/C;2BA6BT,eAdI+C;;qDAcgB,CAAC;mBAGhB;iDACqB+wF,QAAU,cAAVA,OAAuC;;6BAC5D45D;sBAA+B,oBAA/BA,Q/E0HiB/pC;sB+E1HC,wDAA2C;mBASpEgqC;6BAAcP,WAAYC,WAAWO;qCAC9B7qJ;wBACT;yBA7KM40G;0BA6KN,OADS50G,eACc/C,MAAQ,iBAFQ4tJ,QAEhB5tJ,KAA+B;wBA7KzC,gBAAaA,KAAM8zF;0BAAU;mCAApC6jB,qB,sBAAoB33G,KAAM8zF,SAAmD,CA6KrB;sBAD7C,gBADDs5D,WAAYC;sBACX;;6BAIVO,SAAU,wBAAVA,QAA8B;mBAGnCC;6BAAiBD,QAAS/0J;sBAC5B,uBAD4BA,mBAAT+0J,QACuC;;6BA8BjCzxJ,GAAGE;sBAC5B,sBAAqBy3F,QACnB,aADmBA,OADI33F,GAAGE,GAGL,CAAC;mBAGL;mBACA;mBACJ;mBACQ;mBACN;mBACF;mBAGf;;;kBAOoB,UAAQ;kBTzSjB;mBS0SI;;uDAbbyxJ;mBAoBM;mBAJR;;;;;+BAfEC;iCAkBM;mBAHR;6BAUaE;sBACb,gBAAajuJ,KAAM8zF;wBACjB;qCAFWm6D;yBAGO,kCAFPjuJ;yBAIT;;4BA6CEgsJ;4BAjDal4D;;4BAIoC,WxJrB5Cs1C,WwJmBLvrB,YADAD;yBAKgB;qCxJvBXwrB,WwJmBLvrB,YACAqwC;wBAGgB,OAAhBC,aACS,CAAC;mBAGe;mBACC;;;+BAU5BG,kBAAkBnyJ,GAAGE;wBACvB,sBAAqBy3F;0BAAU,+BAAVA,OADD33F,GAAGE,GACsC,CAAC;+BAG5DkyJ,sBAAsBpyJ,GAAGE;wBAC3B,sBAAqBy3F;0BAAU,+BAAVA,OADG33F,GAAGE,GACsC,CAAC;+BAGhEmyJ,YAAYxwJ,EAAE7B,GAAGE;wBACqC;oDAD1C2B,EAAE7B,GAAGE;yBACqB,6CADrBA;wBACI;wEADPF,YACiD;sBAGnD,SAAZsyJ;wB,OAJAD,YARAF;sBAagB,SAAhBI;wB,OALAF,YAJAD;sBAUc;;uBAKE;;4BAAZlmB,mBADAvyG;wCAEa,uBADbuyG;;;;8C/KwvCFolB,e+KxvCEmB;uBAHJ9yC;;8BAhBAwyC;8BAIAC;8BAIAC;8BAIAC;8BACAC;8BACAC;8BAEA7yC;mBA1B4B;;;uBxJrQhC+P;;;uBfiDEuB;;uBdjGIpU;;uB2BuWFlI;uBb5QE8b;;uBkBlFJvyD;uB8CsIE25C;uBAJAJ;uBAEAE;uBACAC;uBAJAJ;uBAEAE;uBAOAM;;uBAEAE;uBADAD;uBAHAH;uBACAC;;;;uBjD5FI6X;;;;;uBACAI;;;;;;;;;uBACAa;;uBAIRL;uBfqCEE;uBehCF3nH;uBACA4nH;uBACAS;uBACAC;uBACAC;uBAGAY;uBAKAV;;uBAsBAiB;uBACAD;uBACAjB;uBACAp6F;uBAGAu7F;uBAGAjqH;uBAGA0xG;uBAGAG;uBAGA58C;uBAGA08C;uBAGAF;uBAIQmV;;;;;uBAIR8B;uBAIAJ;uBACAD;uBAMAtrF;uBAMAwsF;uBAEAD;uBACAE;uBACAH;uBAGArC;uBAOAoC;uBAGAF;uBAIAD;uBACAD;uBGrHEpG;uBANAD;uBA6BAQ;uBAbAN;uBAuCAU;uBAhBAH;uBHmGF8D;uBG3LE/uD;uBDgjBE/C;uBC5gBEC;uBHmNNu8C;uBAIAuX;uBAIAO;uBAIAC;uBAGAG;uBAGAD;uBAGAD;uBAMAQ;uBAMAD;;uBnLhHE28B;uB2UqLIM;mBAtC0B;;;;;;qBxJrQhCzsB;qBAIQc;;qBGLN9Y;qBAMAC;;qBlLoDF8X;qB6KsSIvuB;qBEzVI+xB;;qBG5CNj/D;qBH4CMq9D;;;;;;qBF6UJS;qBADAnC;qBE5UIiC;;qBF4UJjC;qBE5UIgC;;;;;;;;;qBACAf;;;;;;;;;qBACAsB;;qBAIRc;qBmBhCEx/D;qBAuCc9pE;qBArCd+pE;qBnBqCF6+D;qBACAD;qBACAD;qBAGAM;qBAKArC;;qBAsBA+C;qBACAD;qBACAhB;qBACA/B;qBAGAiD;qBA2CAlD;qBAEAD;qBACAD;qBmBnHEl8D;qBnB8HFi8D;qBAGAD;qBAtCQuD;;;;;qBmB9FN1/D;qBAFAF;qBACAC;qBnB8GF8+D;qBAMAtC;qBAEAD;qBACAD;qBmBnHEl8D;qBhNlBA8nD;qB6LgJFmU;qBAGAD;qBAIAyC;qBACAD;;;qBG7CE5Z;qBAbAJ;qBA4CAM;qBAlBAD;qBH+CF2X;qBAmDAV;qBGlNM/7D;qBADAD;qBHgONi8D;;qBAIA6C;qBAIAC;qBAGAG;qBAGAD;qBAGAD;qBAMAe;qBAMAD;;qBnL1GEmoB;qB2U6LIQ;kBTvXK;mBSmUqB;;;;;;;;uB/T9I1BzoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBZiBJ7H;uB2U+LIuwB;mBAlE0B;;;;uB/VvSbn3B;;;uB0MiDjBxN;uBAaAM;uB1MrCE9O;uBAzBe+b;uBqMyafhkB;uBEjYIgnB;uBvMxCW9C;uB0MHjBhxD;uB1MGiBywC;;;;;;uBqM6ZfI;uBADAD;uBrM5ZeG;;;;;;;;uBuMwCXihB;;;;uBACAG;;;;;;;;;uBvMzCWS;;uBuM8CnBiB;uBvM9CmB9wF;uBCoDHC;uBDpDGC;;;;;;;uBuMqFnBgxF;uBACAD;uBvMtFmBhB;;uBuM2FnBkB;uBvM3FmB5C;;;;;;uBuMiHX6C;;;;;uBvMjHWr0D;;;;;;;;uBUtBjBynD;uBVsBiB4J;;;;uB0MkGjBjN;uBAaAI;uB1M/GiBgP;;uB0MyJjB7O;uB1MzJiBG;;;uBE6LJzsH;uBAAHF;uBF7LOg5H;;;;;;;;;;uBoB0Hj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DAGkC;;;sBAHlC;;;;oCtD8ZA+Q;;sBsD9ZA,wCAGkC;;;;;;;sB;wBAFhC;0CxMaEzhC;sBwMZF;;kBACgC;;;sB,QrI8JhCL;;gEqI9JgC;kB5ClBzB;mB4CkByB,yBAsBP,qBAAkB;mBAtBX;;;;;;;;8C;mBAAA;;;;;;sBAsC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAUF;;;;;;;;;;;;;2CX1DyDkzD;;;;;;;;;;;;;;;wBW0DzD;;;;;;;;;;4DX1DyDH;;2BW0DzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEpDwCJpwB;;;;2BoDxCI;;;;sFAU4B;;;wBAV5B;;;;;;;;;;8CX1DyDqwB;;4BW0DzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDpLgEJvzB;;;4BoLhEI;;;;;qEAU4B;;;wBAV5B,gDAU4B;;wBAV5B;;;;;;;;kDX1DyDwzB;2BW0DzD;;;;;;;;6BtDkUJvxB;;;2BsDlUI;;;;;;;;;;;;oCtDkUJA,gBAjGAP;oCA0IAW;;;2BsD3WI;;;sDAU4B;;;;;wBAV5B;iCACE;;2BACA;;;2BACA;;iCACA;;2BACA;;;;;iC7LugBJhrC;;;2B6LtgBI;;;;;;;2BACA;;;;;;;;;;;kC7LqgBJA,ebreEod;iCauYFld;;;2B6LraI;;;;;oEAC0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAa5B,yBAAgD;;;;;;;;;;;;;;;;;uBXjFS42D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wB;0BFIrD,oCACK;;;0DAA0B;4CAGA,gCAAiB;sBauH1D;;;;;;;;;;;;;;;;uBX/H+DkB;;;;;;;;;;;;;;;;;;;;;;;;uBW+H/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBArHoC;;;;;;kBAwHZ;;kBrXjIpB99B;kBI4HFyV;kBqUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBrUoITD;kBJ5HEzV;kBsXVN;;kB7CEa;mB6CFb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAIQ;wFAA0C;kBAIA;;kBtXG5CC;kBI4HFyV;kBADAD;kBJ5HEzV;kBuXRN;;kBAKG;;kBvXIGC;kBI4HFyV;kBADAD;kBJ5HEzV;kBwXVN;;kB/CEa;mB+CGb;;;;8C,gCAAgD;mBAAhD;0C;mBAAA;;sB,wCAAgD;mBAAhD;;sBpD6KE;mBoD7KF;;sB,OzD0aI+Q,+ByD1a4C;kBAAhD;kB/CHa;kB+CQX;;;;;;;;kBA+BqD;;kBxX9BjD9Q;kBI4HFyV;kBADAD;kBJ5HEzV;kByXVN;;kBhDEa;mBgDFb;;sBAwBiC,sDAA+B;mBAxBhE;;sBA4BmC,yDAAiC;mBA5BpE;;sBAgCmD;sEAAiC;mBAhCpF;;sBAoC4C;sEAAiC;mBApC7E;;sBAwCuC;sEAAiC;mBAxCxE;;sBA4CyC;sEAAiC;mBA5C1E;;sBAmDM;uFAGC;mBAtDP;;sBA0D0C;8EAA0C;mBA1DpF;;sBAiEM;8EAEC;mBAnEP;;sBAuE8C;8EAA0C;mBAvExF;;;sBA8EM;;;;;;;iCAIC;;mBAgBD;;;;;;;kC,sCAA8C;mBAA9C;;;;;;iFAA8C;mBAA9C;;;;;;6DAA8C;mBAA9C;;;;;;;;sBAQgB;oDAA8B,iCAAa,EAAC;;;sBAGlD;;uBACM,iB/L2LTL;uB+L5LG;sBACM;;wBACZ;0BAAgB;;;;2BACV;qCAEM,oBADF;0BAFM;;;sBAKlB,QAAC;;;;;;uBlESCvB;;;;;;;;;;;;;;;;;;;;uBHioBNmjC;uBAGE/lG;;;;;;;;;;;;wBqEzmB4B;iD,0BAAgC;;wBACpC,uCAAwC;;;0BAQnC,kBrE6lB/B+lG,gCqE7lBqE;;;wBAenE;yBrEzKFlsD;;;;;yBqEyKE;;;;;;;;;iD,6BAA2C;wBAA3C;;;;;qFAA2C;wBAA3C;;;;;iEAA2C;wBAA3C;;;;;;0BAQgB;wDAA8B,iCAAa,EAAC;;0BAGlD;wCrEskBV75C;2BqErkBgB,iB/L6GTmkE;2B+L9GG;0BACM;;4BACZ;8BAAgB;;;;+BACV;;+BAGJ,0BrE1LRtqB;;+BqEwLgB;8BAFM;;;0BAUlB,QAAC;;;;;kClE1EC+oB;;;;;;;;;8BHioBNmjC;8BAGE/lG;;;;;;;;;;;;8BGpoBIyiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBHooBJziE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBqEriBiC;;kBzXjNjCykE;kBI4HFyV;kBqUrIS;;;;;;uBrB+vBPl6E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBvF5dAuf;;;;;;;;;;;;;;;qB0FxKIkjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBH+eR/D;;;;;;;;;;;;;;sBG/eQ+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBnTSNwX;kBJ5HEzV;kB0XVN;;kBjDEa;mBiDFb;;sBAmBqB;+BnEqLfxkE;wBCtD2B,sDAA8B;+BDsDzD+E;wBClD4B;wBA9ChC,UAEc,qCACF;wBA2CoB,MAzCxB;wBACR,qBAAyB,kBAAO;wBAAhC,QAwCgE;+BD+C9DghG;wBC5CuC;wBAtCzC,iBACiB;wBAqCwB,IAnCvC,aAAQ,iBAAe;wBACvB;;;4BACU;;6BAxFP,iBACE,oBAEH;oDAwFa,wBAA+D;wBAJ9E,QAkCoF;;wBkEnIpE,iBlEwCQ;+BhIobtBt7D,uCkM5d4C;;mDAQzB,2B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C,oDACsD;kDAG7B,2BAAuB;;kCrC5B1D,qCqCsC+C;;;sBvCkFrD,gBAAY2nB;wBACO,IAAb3tD,WADM2tD;wBAKH,sB,OvCuzEL76C,UuC3zEE9S;wBAEF;yBADEtjH;0BACF;4BACE,4BAHAsjH;;;0CACAtjH,EAFMixK,MAQI,CuCzFqC;yCACE,sBAA+B;2CAGnC,sBAAiC;;;0B1CwhBhF3tD;6C0C5ce,iB1C4cfA,gB0C5cwD;8C/Es9DP,UqC1gDjDA,qB0C3c0D;;wBAG5D,mC1CwcEA,iB0Cxc0D;;wB/E89D5D,qBAEkB,gBqCxhDhBA,gBrCwhDyC;wBADzC;+DqCvhDAA,qB0Crc0E;;wBAG5E,wC1CkcEA,iB0ClcmE;;wB/E0gEhE,sB,gBqCxkDHA;wBrCykDA;kEqCzkDAA,qB0C9bqD;;wB/E2gEjD,iCqC7kDJA;wBrC6kDI;;6CqC7kDJA;wBrC+kDyB,Q+E1gEqC;;wB/E8gEhE,qBACE,gBqCplDAA,gBrColDyB;wBADhB;;qEqCnlDTA;uC0C1bgF;;wB/EkhE7D;iCqCxlDnBA,WrCwlDmB,+BqCxlDnBA,Y0CzbsE;;wB/EuhEtE;iCqC9lDAA,WrC8lDA,sBqC9lDAA,e0Cxb0E;;wB/E4hE1E;iCqCpmDAA;iCrComDA,uCqCpmDAA,e0CrbwD;;wB/E+hExD;iCqC1mDAA;iCrC0mDA,oCqC1mDAA,e0ClbkF;;wBACjE,kB1CibjBA,iB0Cjb4D;;wB/Em9D9D,qBACE,gBqCniDAA,gBrCmiDyB;wBADhB;0EqCliDTA,kB0Chb8E;;wB/Eu9D3D;iCqCviDnBA,WrCuiDmB,8BqCviDnBA,Y0C/aoE;;wBAC3C,sB1C8azBA,mB0C9a4E;;wB/E29D5E;iCqC7iDAA,WrC6iDA,qBqC7iDAA,e0C7awE;;wB/Eg+DxE;iCqCnjDAA;iCrCmjDA,sCqCnjDAA,e0C1auD;;wB/Em+DvD;iCqCzjDAA;iCrCyjDA,mCqCzjDAA,e0CvagF;;wBAC9D,kB1CsalBA,iB0Cta8D;;wB/EohE3C;iCqC9mDnBA;iCrC8mDmB,4CqC9mDnBA,Y0CnaoE;qDAG5C,wBAAsC;oD1C+ZtDovC,QAAQC;wBAEpB;;oDADIrvC,WADQovC,QAAQC;;uD,OpCk3DhBv8B,UoCj3DA9S,mB0C7Z2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8J3D;;;;;kBnDzZO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBmDqec,mCAAyB;;wB/Eq1CV,0C+El1C4B;;;0BASnC,oDAAsC;;;;0B/E21CrE,e+Et1CE;0B/E0rBF;4BAG6C;qFAA8B;0BADnE;;8ChJpqCJ7I,oBgJoqCyB;yC+E5rB8C;;;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;;;;;;;;;;;;;;wB/EwrDrE,8C+Er4DkD;6CAErC,WAAI;;wBACL,uB,mBAAuB;;wB/EqlDrC,sD+EplDqE;;wB;uC/EwlDvE,2C+EvlDmD;;wB/E0nDnD,8C+EvnDoD;;wB/E6nDlD;yF+E1nDmE;;wB/E8nD/D;;;wBACqB,Q+E9nDgB;;wB;;iC/EmoD3C;yC+EloD6D;;wB/EqoDrB,kD+EpoDW;;wB/EuoD/C,4C+EtoDmD;;wB/E0oDnD;mC+EzoDmE;;wB/E6oDnE,0D+E5oD2D;;wB/EglDzD;;;wBACqB,Q+EhlDU;;wB;uC/EqlDrC,mD+EplDuD;;wBACpC,mCAA0B;;wBAxLrC,sCAyL+D;;wB/EwlDnE,yC+EvlD6C;;wB/E2lD7C,0D+E1lD6D;;wB/E8lD7D,uD+E7lDqD;;wB/EimDnD;;;wBAEqB,Q+ElmDoB;0CAEjC,QAAC;6C/EwoDf,oC+EvoDyC;2C/E0oD1B,oB+EzoDU;yC/E0oDZ,mB+EzoDQ;;wBACA,mCAA4B;;wBAC5B,mCAA4B;;wBACxB,uCAAgC;;wB/E6pDzD,+C+E5pD6D;;wB/EiqD7D,2C+EhqDiD;;wB/EoqDjD,oC+EnqD6C;6CAC3B,iCAAyB;;wB/E0qD3C;;;;gDAA8C,6BAAQ,E+EzqDX;;wB/E6qD3C,kD+E5qDyC;yC/EorDzC,gC+EnrDiC;2CAClB,+BAAsB;wC/EyrDX,+B+ExrDK;4C/E+rD/B,mC+E1rDyC;;wB/EmsDzC,wC+E9rDqD;;wB/EksDjD,wC+EjsD6C;2C/EqsD7C,qC+EpsDmC;;wB/EwsDnC,oC+EvsDqC;;wB/E2sDrC,yC+E1sD2C;;wB/E8sD3C,wC+E7sD6C;;wB/EktD/C;;;;;sC+EjtDqD;;wB/EwtDrD;;;;;sC+EvtDmD;;wB/E8tDnD;;;;;sC+E7tDmD;;wB/EouDnD;;;;;sC+EnuDiD;;wB/E2uDjD;;;yC+E1uD+C;;wB/EivDjD,sC+EhvDyD;4C/EovDzD,oC+EnvDuC;;wB/E6vDvC,qD+EvvD6E;;wB/E2vD7E;qE+ExvDwD;;wB/EkwDpD,sC+E/vDqC;0C/E4wDf,iC+EjwDS;;wB/EowDnC,oD+EnwD6E;;wB/EwwD3E;;;kC+ErwD8C;;wB/E+wDhD,2D+E3wDqD;;wB/EqxDrD,8C+ElxDqE;;wB/EsxDrE,uC+ErxDmD;;wBACzC,uB,O9EopEN0b,0B8EppEuB;;wBACb;0B/EuxD+B,8C+EvxDV;2C/E0xDnC,8B+EzxDiC;;;wB/EmyDjC;;;;;mC+EhyDiF;;wB/EwyDhC,uC+EryD4B;;wB/EwyD7E,kD+EryDqD;;wBA1QC,kDA6QM;;wBAxT5D,gDAyToE;wDAlT3C,oBAmT8B;;wBAhTvD,kDAiTmE;;wB/E6wD7B,uC+E7nDuC;;;0BAQ5C,qCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BxF7bnEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBwF0lBH;;kB5XrqBGuV;kBI4HFyV;kBqUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uB3B0BX6rB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kB1S0GE9rB;kBJ5HEzV;kB6XVN;;kBpDEa;mBoDFb;sCtC0F0B,uCsC5DgD;mBA9B1E;;sBxC2NE,gBAAYgmC;wBACO,IAAb5tD,WADM4tD;wBAKH,sB,UAJH5tD;wBAEF;yBADEtjH;0BACF;4BACE,4BAHAsjH;;;0CACAtjH,EAFMkxK,MAQI,CwCnMwD;mBAhC1E,0BAkDmD,wBAAe;mBAlDlE;;sBAqD6B;sBrEFL;;;mDqEEwC,4BrEFmB,EqEEC;mBArDpF;;sBAyDI,0BACE,4BAAmB;sBADM;qEACL;mBA1D1B;;sB,I3CgqBM5tD;6C2Clfe,U3CkffA,gB2ClfuC;;wBACL,mC3CiflCA,iB2Cjf6E;;wBAG/E,wC3C8eEA,iB2C9ekD;;wBtF0rCpD,qBAEkB,U2C9sBhBA,gB3C8sBoC;wBADpC,gC2C7sBAA;wB3C6sBA,+CsFxrCyD;;4CtFqqCV,U2C1rB/CA,iB2CteqC;;wBtFmqCnB,U2C7rBlBA,W3C6rBkB,W2C7rBlBA,sB2CreuC;0CAC3B,iB3CoeZA,a2CpeiC;;wBAzDf,U3C6hBlBA,W2C7hBkB,Y3C6hBlBA,c2CneyC;;wBAtDvB,U3CyhBlBA,W2CzhBkB,gB3CyhBlBA,c2CleiD;;wBtFwrC9B,U2CttBnBA,W3CstBmB,a2CttBnBA,e2CjemC;;wBtF2rCrC,4B2C1tBEA,c2CheuD;;wBtF8rCpC,U2C9tBnBA,W3C8tBmB,c2C9tBnBA,e2C/d+B;;wBtFksCxB,U2CnuBPA,W3CmuBO,oB2CnuBPA,e2C9d6C;;wBAGvC,gC3C2dNA,2B2C3dwD;oD3C0dhD+rC;wBAEZ,oCADI/rC,WADQ+rC;;uD,UACR/rC,mB2Cvd+D;;;;;;;;;;;;;;;;;;;mBAzMrE;kBAmUM;kBpDjUO;;;;;;;;;;;;;;;;;;;;;;;8CoDyYS,4BAAoB;4CtFwxBV,gCsFvxB2B;;;0BAQlC,wCAA4B;;;;0BtFsyBjD,esFlyB0B;0BtFsab;;8C1I9yBT7I,oB0I8yB8B;yCsFtaiD;;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;+CtFggCiB,kCsF//Bf;yCtF8/BjC,kBsF7/Ba;2CtF+/BX,oBsF9/Be;6CtF+/Bf,kBsF9/Be;0CtF+/BhB,mBsF9/Bc;gDtF+/BV,qBsF9/BkB;0CtF+/BtB,mBsF9/Bc;gDtF+/BV,qBsF9/BkB;2CtF+/BvB,gBsF9/Ba;+CtF+/BT,oBsF9/BiB;0CACpB,mBAAc;2CtF+/Bb,oBsF9/Be;yCtF+/BhB,kBsF9/Bc;;wBtFihCiC,+CsFhhCf;2CtF8/B9B,oBsF7/BgB;4CtF8/Bf,qBsF7/BiB;0CtF8/BnB,mBsF7/Be;0CtF8/Bf,mBsF7/Be;yCtF8/BhB,kBsF7/Bc;6CtF8/BV,sBsF7/BkB;6CtF8/BlB,sBsF7/BkB;8CtF8/BhB,uBsF7/BoB;;wBtF8/Bd,uB,oCsF7/B0B;oDtF8/B1B,6BsF7/B0B;;wBACzB,iCAAsC;wCtF6/BZ,gCsF5/Bf;2CtF6/BqB,kCsF5/Bf;;wBtF6/BuB,sCsF5/Bf;;wBtF+/Bf,sCsF9/BmB;wCAC5C,4BAAwB;wCACxB,4BAAwB;2CACrB,+BAA2B;8CtFkgCiB,iCsFjgCf;8CtFkgCe,iCsFjgCf;6CtFkgCa,gCsFjgCf;;wBtFogCF,0CsFngCsB;;wBtFsgCX,sCsFrgCW;4CtFsgCH,mCsFrgCf;;wBtFsgCyB,oCsFrgCf;;wBtFwgChB,wCsFvgCoB;0CAC5C,8BAA0B;gDACtB,gCAA8B;;wBAC1B,oCAAkC;2CtFwgCC,kCsFvgCf;;wBtF0gCK,iDsFzgC6B;;wBtF6gC5E,4CsF1gCyD;;wBtF8gCpB,uCsF3gCmB;;wBtF8gC3B;4D,gBsF7gCiB;;wBtFghCN,0CsF/gCsB;;wBtFmhCzB,sCsFlhCmB;0CtFqhCD,iCsFphCf;wCtFqhC5B,iBsFphCY;;wBtFqhC6C,sCsFphCf;4CACxC,QAAC;0CACD,QAAC;;;wBtFwhCf;yFsFrhC4E;;wBtFwhC3B,uCsFrhCiC;;wBtFwhClF,kDsFrhC0D;;;wBtFyhC1D;;;;;;mCsFrhCqF;6C,iCAIzC;;wBtF6hC3B,oDsF1hC6C;;wBtFkiC7C;;;yBA5QX;wBADA;0EsFpxB8C;;;wBApQpD,gDAuQoE;wDAnQ/C,oBAoQkC;;wBAhQvD,kDAiQmE;gDA4I/C,8BAAoB;8CtF62BZ,6BsF52BkC;;;0BAS1D,2CAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+IzE;;kB7X9jBG0wB;kBI4HFyV;kBqUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBrUoITD;kBJ5HEzV;kB+QVN;;kBAkEG;;kB/QvDGC;kBI4HFyV;kBADAD;kBJ5HEzV;kB8XVN;;kBrDEa;mBqDFb;oC;mBAAA;;;;;;;;uB/G2MWvvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mB+G3MX;;;;;;;;;uB/G2MWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mB+G3MX;;;;;;;;;;;;;;uB/G2MWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mB+G3MX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4MG;;kB9XjMGwvE;kBI4HFyV;kBqUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uB1DmCXlrC;uBAEAC;uBAGAwN;uBAMAC;uBAEAC;uBAEQC;uBACAC;;;;;;;uDADAD;;;;;;;;;;;;;8BAfR5N;8BAEAC;8BAGAwN;8BAMAC;8BAEAC;8BAEQC;8BACAC;;;;;;;;sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kB3QiFNo9B;kBJ5HEzV;kB+XgBN;;kBAsKG;;kB/XrLGC;kBI4HFyV;kBADAD;kBJ5HEzV;kBgYVN;;kBvDEa,8BuDFb;kBzJ+HMr5B;;;;sB;wByJxFqB;;;;;;;kBvDrCd;mBuDqDT;;;;8C,gCAA0D;mBAA1D;0C;mBAAA;;sB,uCAA0D;mBAA1D;;sB;mBAAA;;sB,sCAA0D;kBAE3D;;kBhY9CGs5B;kBI4HFyV;kBADAD;kBJ5HEzV;kBiYVN;;kBxDEa;mBwDCb;;;;8C,gCAAkD;mBAAlD;0C;mBAAA;;sB,0CAAkD;mBAAlD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;8BAEQt0B;8BAONm/C;;;;mBAnFN;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgIG;;kBvYvHG+F;kBI4HFyV;kBADAD;kBJ5HEzV;kBwYVN;;kBAiHG;;kBxYtGGC;kBI4HFyV;kBqUrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uB8D6EJy2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBnYuDL12B;kBJ5HEzV;kByYVN;;kBhEEa;mBgEAb;;mBAA0C;oC;kBAAA;kBhEA7B;mBgEKP;;mBAAqC;oC;mBAAA,kBxE8EvC0R,chIPArD;mBwMvEuC,kB1EwGvCsB;mB0ExGuC;;;qBxE8EvC+B;qBhIPArD;qB8HiCAsB;;;;;;mB0ExGuC;;;;qB3SqqBjCxoC;qB8DxfJxB;;;;;;;;;qB4B0DA2G;qBADAD;;;;;;;;;qBuFjBKqpB;;;;mB0HrNgC,qB;mBAAA;;;;kBAkBvC;kBAED;;kBzYhBGuK;kBI4HFyV;kBADAD;kBJ5HEzV;kB0YKN;;kBAsHG;;kB1Y1HGC;kBI4HFyV;kBADAD;kBJ5HEzV;kB2YVN;;kBAW4B,sBAAC,WjN8RhBH;kBiNzIV;;kB3YrJGI;kBI4HFyV;kBADAD;kBJ5HEzV;kB4YVN;;kBnEEa;mBmEWP;;mBAAmC;oC;mBAAA,kB3EkHrCgS,gBhIqCApD;mB2MvJqC,kB7E4QrCsB;mB6E5QqC;;;qB3EkHrC8B;qBhIqCApD;qB8HqHAsB;;;;;;qBvI+XExjC;qBAaAtF;qBACAxB;;kBoNzpBmC;;qB3EkHrCosC;qBhIqCApD;qB8HqHAsB;;;;;;qBvI4YE9oC;qBAbAsF;qBAcA9G;;kBiJpqBO;mBmE4BT;;mBAAmC;oC;mBAAA,kB3EiGnCosC,gBhIqCApD;mB2MtImC,kB7E2PnCsB;mB6E3PmC;;;qB3EiGnC8B;qBhIqCApD;qB8HqHAsB;;;;;;qBvI4YE9oC;qBACAxB;qBuFreK2X;kB6HnK4B;;;qB3EiGnCy0B;qBhIqCApD;qB8HqHAsB;;;;;;qBvI4YE9oC;qBuFpeKkW;qBvFqeL1X;;kBoNxoBiC;kBnE5B1B;mBmEyCP;;mBAAmC;oC;mBAAA,kB3EoFrCosC,gBhIqCApD;mB2MzHqC,kB7E8OrCsB;mB6E9OqC;;;qB3EoFrC8B;qBhIqCApD;qB8HqHAsB;;;;;;mB6E9OqC;;qB/NZjC5gC;;qBWsoBFlI;qBACAxB;;;;;;;;;qBAbA+G;qBADAD;;;;;;;;;;;;qBuCroBF/2F;mB6KwBqC,2B;mBAAA;;;;;;;;;;;;;;;;sBAkBvC,0CAA6D;mBAlBtB;;sBAqCvC,sDAA4E;kBAK3D;;kB5Y1EbsqH;kBI4HFyV;kBADAD;kBJ5HEzV;kB6YVN;;kBpEEa;mBoEIT;;mBAA2C;oC;kBAAA;kBA4B+B;;kB7YvBxEC;kBI4HFyV;kBADAD;kBJ5HEzV;kB8YVN;;;kBrEEa;mBqEKP;;mBAAiC;oC;mBAAA,mB7EoGnC2R,chIkBAlD;mB6MtHmC,mB/EuRnC0B;mB+EvRmC;;;qB7EoGnCwB;qBhIkBAlD;qB8HiKA0B;;;;;;mB+EvRmC;;qBlTa/BnzB;;;;;;;;;;;;;;;;;;;;;;;;;;mBkTb+B,qB;mBAAA;;;;;mBAgBnC;;mBAAiC;oC;mBAAA,mB7EoFjC20B,chIkBAlD;mB6MtGiC,mB/EuQjC0B;mB+EvQiC;;;qB7EoFjCwB;qBhIkBAlD;qB8HiKA0B;;;;;;;;qBhD7FO9yB;kB+H1K0B;;;qB7EoFjCs0B;qBhIkBAlD;qB8HiKA0B;;;;;;;qBhD7FO/yB;;;kB+HtJiE;;kB9YhCtE6iB;kBI4HFyV;kBADAD;kBJ5HEzV;kB+YVN;;kBAauC;;kB/YFjCC;kBI4HFyV;kBADAD;kBJ5HEzV;kBgZVN;;kBvEEa;mBuEGT;;mBAI4D;oC;mBAAA,8BAJ5D,QAI4D;;;sBAJ5D;;;qEAI4D;;;;sBAJ5D,gDAI4D;;;sBAJ5D;;;+BACE,gBACA,iBACA,SAC0D;;;;kBvEPnD;mBuEOmD;;;;;;;;;;;;;;;;;;qBrZ2D1DhpB;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAO;qBADAD;qBAGAG;qBADAD;qBAJAJ;qBACAC;;;;;;;;;mBqZ7D0D,2B;mBAAA;;;kBAMlB;;kBhZJxC+oB;kBI4HFyV;kBADAD;kBJ5HEzV;kBiZVN;;kBxEEa;mBwEuBX;;mBAA2C;oC;mBAAA,mBhF0GzCiS,ehIuDAnD;mBgNjKyC,mBlFkSzCuB;mBkFlSyC;;;;;;;;;uBhF0GzC4B;uBhIuDAnD;uB8HiIAuB;;;;;;;uBvIQE7jC;uBAcAsyB;;mByNxTuC;;;;;uBhF0GzCmT;uBhIuDAnD;uB8HiIAuB;;;;;;uBvIQE7jC;;uBAcAsyB;;mByNxTuC;;;;;;;;;qBzN2SvCryB;qBADAD;;;mByN1SuC;;sB;;wBA4BlB,+CAAyC;6CAC9C,kBAAO;;wBACR,oDAAkB;;wBACd,8CAAyC;6CAC7C,oBAAM;6CACD,wBAAQ;;wBAGpB;wBACR;;oEAIM;;;;;;;;;;kBAiBV;kBAmCkE;;kBjZ3G9DyzB;kBI4HFyV;kBADAD;kBJ5HEzV;kBkZVN;;kBzEEa;mByEKP;;mBAA4C;oC;mBAAA,mBjFqG9C4R,ahIwBAlD;mBiN7H8C,mBnF8R9C0B;mBmF9R8C;;;qBjFqG9CwB;qBhIwBAlD;qB8HiKA0B;;;;;;;qBvIkFE/oC;qBb5QE8b;qBerCEb;kB+IpEG;mByEgBP;;mBAAgC;oC;mBAAA,mBjF0FlCsvB,ahIwBAlD;mBiNlHkC,mBnFmRlC0B;mBmFnRkC;;;qBjF0FlCwB;qBhIwBAlD;qB8HiKA0B;;;;;;mBmFnRkC;;qBrPF9B7gC;;qB2BuWFlI;qBb5QE8b;;qBkBlFJvyD;qB8CsIE25C;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAM;;qBAEAE;qBADAD;qBAHAH;qBACAC;;;;qBjD5FI6X;;;;;mBwNpD4B,qB;mBAAA;;;;;;;;;;;;;;;;;;;kBAWpC;kBAS4E;;kBlZ3BxE2d;kBI4HFyV;kBqUrIS;;;qB9F6JPnrC;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAM;;qBAEAE;qBADAD;kBvO9BF8qC;kBJ5HEzV;kBmZVN;;kB1EEa;mB0EGP;;mBAAkC;oC;mBAAA,mBlFwIpCkS;mBkFxIoC,mBpFgUpC5B;mBoFhUoC;;;qBlFwIpC4B;;qBFwLA5B;;;;;;mBoFhUoC;;;qBxYoHtCza;qB6KsSIvuB;qBEzVI+xB;;qBG5CNj/D;qBH4CMq9D;;;;;;qBF6UJS;qBADAnC;qBE5UIiC;;qBF4UJjC;qBE5UIgC;;;;;;;;;mByNjE8B,qB;mBAAA;;;;;;;kBAUtC;kBAS8E;;kBnZb1EkI;kBI4HFyV;kBADAD;kBJ5HEzV;kBqZVN;;kB5EEa;mB4EGP;;mBAAkC;oC;mBAAA,mBpFgJpCmS;mBoFhJoC,mBtFiVpC5B;mBsFjVoC;;;qBpFgJpC4B;;qBFiMA5B;;;;;;mBsFjVoC;;qBlakDlC/gC;qBAzBe+b;qBqMyafhkB;qBEjYIgnB;qBvMxCW9C;qB0MHjBhxD;qB1MGiBywC;;;;;;qBqM6ZfI;qBADAD;qBrM5ZeG;;;;;;;;qBuMwCXihB;;;;mB2NjE8B,qB;mBAAA;;;;;;kB5EH3B,I/IuEHqhD;kB2NpE8B;kBAUtC;kBAS8E;;kBrZb1E7tC;kBI4HFyV;kBADAD;kBJ5HEzV;kBsZVN;;kB7EEa;mB6EFb;;;;qBFuFU0tC;;;;mBEvFV,2B;mBAAA;;;;;;;;;;qB5CUiEK;;;;;;;;mB4CVjE;;sBAkBM;;;gC3OyFEb;;;;;;;yC2OtFsD;mBAGvB;;;;;;;;;;;;;;;;;;;;;;kB7EtB1B;mB6EsB0B;;;;;;;;;;;;qBnY+J/BjzC;;;;;;;;;;;;;;;;;;;;;;;;;;mBmY/J+B,qB;mBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmDrC;kBAS8E;;kBtZzE1EgG;kBI4HFyV;kBADAD;kBJ5HEzV;kBuZVN;;kB9EEa;mB8EIP;;mBAAgD;oC;mBAAA;;;sBAOhD;;kFACgD;wB1EqRhDoe;;;;;;;;;;;;;;;;;;kBJjSO;mB8EsBP;;mBAAiC;oC;mBAAA,mBtF4DnC3M,chIbArD;mBsN/CmC,mBxF+EnCqB;mBwF/EmC;;;qBtF4DnCgC;qBhIbArD;qB8HgCAqB;;;;;;mBwF/EmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;mBAAA;;;;;;kBAapB;;kBvZ1BbxP;kBI4HFyV;kBADAD;kBJ5HEzV;kBwZRN;;kBAwByB;;kBxZfnBC;kBI4HFyV;kBADAD;kBJ5HEzV;kByZVN;;kBhFEa;mBgFIT;;8C,gCAAwD;kBAAxD;kBAW2B;;kBzZNzBC;kBI4HFyV;kBADAD;kBJ5HEzV;kB0ZVN;;kBjFEa;mBiFGP;;mBAAsC;oC;mBAAA;sC3FoWxCwQ;mB2FpWwC;;;;;qB3FoWxCA;;;;;;mB2FpWwC;;;qB/YgI1CppB;qB6K0ZI5f;;qBEzdI8f;qBG1CNzsD;qBH0CMixC;;;;;;qBF6cJI;qBADAD;qBE5cIG;;;;;;;;qBqF+KEmb;;;;mB2IhPgC;oC;kBAAA;;kBAU1C;kBASkF;;kB1Zb9E0Y;kBI4HFyV;kBADAD;kBJ5HEzV;kB2ZVN;;kBlFEa;mBkFKP;;mBAA6B;oC;mBAKlB;;0CAMmB,uBAAkB;mBANrC,mBhHFb7Y;mBgHEa;;sBAUX,qDAAwD;mBAV7C;;sBAcX,iDAA6D;mBAdlD;;;;qBhHFbA;;;;;;;;mBgHEa;;;;;;;;;;;;;;;;;;;;;;;;;;;;mC;kBAmCqC;;kB3ZpChD8Y;kBI4HFyV;kBADAD;kBJ5HEzV;kB2SJN;;kBAI4C;;kB3SCtCC;kBI4HFyV;kBADAD;kBJ5HEzV;kB4ZVN;;kBAEA;kBAQmC;;kB5ZC7BC;kBI4HFyV;kBADAD;kBJ5HEzV;kB6ZVN;;kBpFEa;mBoFKT;;;;8C,gCAA+C;kBAA/C;kBAaF;;;;;;;;kBAOC;;kB7ZhBGC;kBI4HFyV;kBADAD;kBJ5HEzV;kBWPN;;kB8TDa;mB9TCb;;;;;;;;;kB4N4HMr5B;;;;sB;;;kBkG7HO;kB9T8BJ;kB8T9BI;mB9T8BJ,qB;mBA0EP;;;;;6BAAQl1G,G,UAAR+8K,iBAAQ/8K,KACwD;mBADhE;6BAAK+vK,UAAL1tK,G,oBAAK0tK,UAAL1tK;;6BAAK2tK,QAALl1J;sB,qBAAKk1J,QAALl1J,UACgE;mBADhE;6BAAKo1H,KAAcp1H;sB,qBAAdo1H,KAAcp1H;mBAAnB;6BAAKo1H,KAALp1H;sB,qBAAKo1H,KAALp1H,YACgE;mBADhE;;sBAAmB;wCAAH8vJ,+BAAhBn2B,MAAgBm2B,YAAE;+BAAlBhB;qCAA0B;mBAA1B;;sBAAmB;wCAAHoD,+BAAhBv4B,MAAgBu4B,YAAE;+BAAlBpB;qCAA0B;kBAA1B;kB8TxGW;mB9T2GX;;mBACsE,uB,UADtE2R;;kB8T3GW;mB9T8GX;;mBACsE;oC,UADtEE;mBACsE,gBADtE39K,4BACsE;kBADtE;kB8T9GW;mB9TiHX;;mBACsE;oC,UADtE89K;;kB8TjHW;mB9ToHX;;mBACsE;oC,UADtEE;mBACsE,iBADtEh+K,mBACsE;kBADtE;kBAGA;;kBAGA;;kBAGA;;;;kB8T7HW;mB9TgIX;;;;;6BAAQE,G,UAARi+K,iBAAQj+K,KAC8D;mBADtE;6BAAK+vK,UAAL1tK,G,oBAAK0tK,UAAL1tK;;6BAAK2tK,QAALl1J;sB,qBAAKk1J,QAALl1J,UACsE;mBADtE;6BAAKo1H,KAALp1H;sB,qBAAKo1H,KAALp1H,YACsE;mBADtE;;sBAAkB;wCAAH2jK,+BAAfhqC,MAAegqC,YAAE;+BAAjBF;qCAAwB;mBAAxB;;sBAAkB;wCAAHO,+BAAfrqC,MAAeqqC,YAAE;+BAAjBF;qCAAwB;kBAAxB;kBAGA;;kB8TnIW;mB9TsIX;;;;;6BAAQ5+K,G,UAARg/K,iBAAQh/K,KAC8D;mBADtE;6BAAK+vK,UAAL1tK,G,qBAAK0tK,UAAL1tK;;6BAAK2tK,QAALl1J;sB,sBAAKk1J,QAALl1J,UACsE;mBADtE;6BAAKo1H,KAALp1H;sB,qBAAKo1H,KAALp1H,YACsE;mBADtE;;sBAAoB;wCAAH0kK,+BAAjB/qC,MAAiB+qC,YAAE;+BAAnBF;qCAA4B;mBAA5B;;sBAAoB;wCAAHO,+BAAjBprC,MAAiBorC,YAAE;+BAAnBF;qCAA4B;kBAA5B;kB8TtIW;mB9TyIX;;mBACsE;oC,UADtEI;;kBAGA;;kBAEA;;;;kB8T9IW;mB9TiJX;;mBACsE;oC,UADtEE;;kBAIA;kBAIE;kBA2DF;;;wCAnDFjD;;kBAmDE;kBAIA,0BmZfSQ;kBnZiBgD,QAFzDjrI;kB8TxNW;mB9T4NX;;;4CA3DF2rI;mBA2DE;6BAAQl+K,G,UAARmgL,iBAAQngL,KAEiD;kBAFzD;kB8T5NW;mB9TgOX;;;;0CA/DFi/K;;mBA+DE;6BAAQj/K,G,UAARqgL,iBAAQrgL,KAEmD;kBAF3D;kBAIA;;kBAwFE;;kBXnTEwuI;kBI4HFyV;kBADAD;kBJ5HEzV;kB+ZVN;;kBAoCiD;;kB/ZzB3CC;kBI4HFyV;kBADAD;kBJ5HEzV;kBgaVN;;kBvFEa;mBuFUP;;mBAAsC;oC,UAAtCgyC;kBAKF,0BAPEC;kBA+KuD;;kBha9KvDhyC;kBI4HFyV;kBADAD;kBJ5HEzV;kBiaVN;;kBAqDG;;kBja1CGC;kBI4HFyV;kBADAD;kBJ5HEzV;kBkaVN;;kBzFEa;mByFFb;gCAGoB,kBrP4BZusC,aqP5BY,UAA+B;mBAHnD;gCAIoB,6BrP2BZD,gBqP3B+C;mBAJvD;sC,yCAOkE;mBAPlE,oB,4BAQwC;mBARxC,yB,kBrP+BQC,eqPdgD;mBAjBxD;;sBAkBwC,gCrPahCD,gBqPboD;mBAlB5D;;;;;wB/QkBMF;;;;;;mB+QlBN;;;;;;;;;kBzFEa;mByFFb,qBAqDwB,kBAAgB;mBArDxC,0BxSiUM+F;mBwSjUN;;;;uBxSiUMA;;;;mBwSjUN;kBAwImE;;kBla7H7DlyC;kBI4HFyV;kBADAD;kBJ5HEzV;kBmaRN;;kBAmIG;;kBna1HGC;kBI4HFyV;kBADAD;kBJ5HEzV;kBoaVN;;kB3FEa;mB2FFb;;sBAKwC,iC9MmKpC8rB,yB8MnKgE;mBALpE;;sBAMwC,kB9MoKpCD,iB8MpKoC,oBAAkB;kBAOW;;kBpaF/D5rB;kBI4HFyV;kBADAD;kBJ5HEzV;kBqaAN;;kB5FRa,kC4FQb;kB9LqHMr5B;;;;sB;wD1DhGE4lE;;;kB4J7BK;mB4FuBD8F;mBAIAC;6BAAYx9K;sBAAI,sDAAJA,EAAW;mBAUvBy9K,4BAAsB,SAAE;2BAVxBD,YAUAC;;;;qB1PoEJrF;;;;8C;mB8LsBuDsF;2B4DpGnDF,YAUAC;2B7OgVNlrE,Yb5QE8b;mC;kB8JzGK;mB4F2DL;;;;;;;;;;qCP8IG8rD,mBnZxCXwC;;mB0ZtGQ;mBAKyB;oC,UALzBgB;mBAYA;;;;;;;8D1Z0FRjD;;mB0Z1FQ;mBAIyB;oC,UAJzBmD;mBAQA;;;;;;;8DApBKD;;mBAo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EACAqD,EACApH,EACAkW,EAjBF+9M,KAIA5pN,GA2DoB;4BACtB,MA/CI6L,EAJApS,EACAC,EACAqD,EACApH,EAhBFi0N,KAIA5pN,GA4DoB;4BACtB,MAjDIrK,EACAkW,EAJApS,EACAC,EACAqD,EAfF6sN,KAIA5pN,GA6DoB;4BACtB,MAnDIjD,EACApH,EACAkW,EAJApS,EACAC,EAdFkwN,KAIA5pN,GA8DoB;4BACtB,MArDItG,EACAqD,EACApH,EACAkW,EAJApS,EAbFmwN,KAIA5pN,GA+DoB;4BACtB,MAvDIvG,EACAC,EACAqD,EACApH,EACAkW,EAjBF+9M,KAIA5pN,GAgEoB;4BACtB,MApDI6L,EAJApS,EACAC,EACAqD,EACApH,EAhBFi0N,KAIA5pN,GAiEoB;4BACtB,MAtDIrK,EACAkW,EAJApS,EACAC,EACAqD,EAfF6sN,KAIA5pN,GAkEoB;4BACtB,MAxDIjD,EACApH,EACAkW,EAJApS,EACAC,EAdFkwN,KAIA5pN,GAmEoB;4BACtB,MA1DItG,EACAqD,EACApH,EACAkW,EAJApS,EAbFmwN,KAIA5pN,GAoEoB;4BACtB,MA5DIvG,EACAC,EACAqD,EACApH,EACAkW,EAjBF+9M,KAIA5pN,GAqEoB;4BACtB,MAzDI6L,EAJApS,EACAC,EACAqD,EACApH,EAhBFi0N,KAIA5pN,GAsEoB;4BACtB,MA3DIrK,EACAkW,EAJApS,EACAC,EACAqD,EAfF6sN,KAIA5pN,GAuEoB;4BACtB,MA7DIjD,EACApH,EACAkW,EAJApS,EACAC,EAdFkwN,KAIA5pN,GAwEoB;4BACtB,MA/DItG,EACAqD,EACApH,EACAkW,EAJApS,EAbFmwN,KAIA5pN,GAyEoB;4BACtB,MAjEIvG,EACAC,EACAqD,EACApH,EACAkW,EAnBFg+M,KAQA50H,GAwEoB;4BACtB,MA9DIppF,EAJApS,EACAC,EACAqD,EACApH,EAlBFk0N,KAQA50H,GAyEoB;4BACtB,MAhEIt/F,EACAkW,EAJApS,EACAC,EACAqD,EAjBF8sN,KAQA50H,GA0EoB;4BACtB,MAlEIl4F,EACApH,EACAkW,EAJApS,EACAC,EAhBFmwN,KAQA50H,GA2EoB;4BACtB,MApEIv7F,EACAqD,EACApH,EACAkW,EAJApS,EAfFowN,KAQA50H,GA4EoB;4BACtB,MAtEIx7F,EACAC,EACAqD,EACApH,EACAkW,EAnBFg+M,KAQA50H,GA6EoB;4BACtB,MAnEIppF,EAJApS,EACAC,EACAqD,EACApH,EAlBFk0N,KAQA50H,GA8EoB;4BACtB,MArEIt/F,EACAkW,EAJApS,EACAC,EACAqD,EAjBF8sN,KAQA50H,GA+EoB;4BACtB,MAvEIl4F,EACApH,EACAkW,EAJApS,EACAC,EAhBFmwN,KAQA50H,GAgFoB;4BACtB,MAzEIv7F,EACAqD,EACApH,EACAkW,EAJApS,EAfFowN,KAQA50H,GAiFoB;4BACtB,MA3EIx7F,EACAC,EACAqD,EACApH,EACAkW,EAnBFg+M,KAQA50H,GAkFoB;4BACtB,MAxEIppF,EAJApS,EACAC,EACAqD,EACApH,EAlBFk0N,KAQA50H,GAmFoB;4BACtB,MA1EIt/F,EACAkW,EAJApS,EACAC,EACAqD,EAjBF8sN,KAQA50H,GAoFoB;4BACtB,MA5EIl4F,EACApH,EACAkW,EAJApS,EACAC,EAhBFmwN,KAQA50H,GAqFoB;4BACtB,MA9EIv7F,EACAqD,EACApH,EACAkW,EAJApS,EAfFowN,KAQA50H,GAsFoB;4BACtB,MAhFIx7F,EACAC,EACAqD,EACApH,EACAkW,EAnBFg+M,KAQA50H,GAuFoB;4BACtB,MA7EIppF,EAJApS,EACAC,EACAqD,EACApH,EAlBFk0N,KAQA50H,GAwFoB;4BACtB,MA/EIt/F,EACAkW,EAJApS,EACAC,EACAqD,EAjBF8sN,KAQA50H,GAyFoB;4BACtB,MAjFIl4F,EACApH,EACAkW,EAJApS,EACAC,EAhBFmwN,KAQA50H,GA0FoB;4BACtB,MAnFIv7F,EACAqD,EACApH,EACAkW,EAJApS,EAfFowN,KAQA50H,GA2FoB;4BACtB,MArFIx7F,EACAC,EACAqD,EACApH,EACAkW,EAjBF+9M,KAQAE,GA0FoB;4BACtB,MAlFIj+M,EAJApS,EACAC,EACA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,eAAen6N;4BACjB;+DADiBA;8CAGPxC;uCACc,sBAJPwC,EAGPxC,WAEF4F,EAFE5F;uCAGD,SAFDyF,MACAG,qBACsB,EAAE;;kCAvH9Bw0N;kCAEAC;;;;kCAwDAvhH;;kCA0BJ0yG;;kCAEA8Q;;;;;;;kC2WxCOC;;;;;;;;;;;;;;;;;;;;;;;;;;;;kC3WuDHE;kCAYAE;uBApHN;;;;;;;;;;;;;;;;;0BAkII;8CAAuB;2BADvB;;;2BADSrlL;;8CiJjGL6lI,WjJiGKy/C,YAAM;;mCAAN1/M,IiJjGL+/J,ajJiGKn0D,oCAEkC;;;;;;;;;;0BAG7C;;;;;;;;;mC4HmEQmvC;4C5HlEO5vF;qCAAU;0DAAgB,iBAA1BA;sCAAU;;sCAAV/wB;;yDiJvGT6lI,WjJuGS5M,YAAM;;8CAANr5H,MiJvGT+lI,ajJuGSn0D,oCAA6C,EAAE;;;sB5B3H1D6nB;sBI4HFyV;sB8bxDgB;uB8B7EL;;uBCEA;;;;;;;uBCDE;;;;uBCGG;;;;;;;;;;uBCJL;;;;uBCCE;;;;;;;;;;;;;;;;uBCDF;;uBCFA;;uBCEA;;uBCAA;;;;uBCAA;;;;;;;;;;;;;;;;;;;;;;;;;;uBCAA;;uBCCD;;;uBCDC;;;uBCCE;;uBCDF;;;;;;;;;;;uBCAO;;;;;uBCAP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB7eoIXD;sBJ5HEzV;sBkfVN;;sBAwPG;;sBlf7OGC;sBI4HFyV;sBADAD;sBJ5HEzV;sBmfVN;;sBjD+EoB;uBiDrEdosF;2DAA4Ch4N;sBAwC/C;;sBnfvCG6rI;sBI4HFyV;sBADAD;sBJ5HEzV;sB6BVN;;sBqa+EoB;uBraxEC;;;;;;;;;;;;;;;;;wCA+EJ,uBAFT2sF,IA/CFL,SAiDyB;yBA/E3BD;wBAgGS,qBgKzFT/4J;;;;wBhK4F+B;;0BAArB,gBgK5FVA;;;0BhK4F+B,gBgK5F/BA;;;sBqQiEgB,Ira+Bds5J;;;;;;;;;wCAES,+BAAwB;;;;;;;;;;0BACxB,uBAHTA,2BAGqC;;;;;;;;;;0BAC5B;gDAJTA,6BgKhGFt5J,ahKoG0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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CrOsNd4nB;2C7BnRF5nB;sBkQ6DgB;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCtQ+ed5C;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDP/CE;gD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0ByC4CuC;0B,SAUxBk4K,W;mCADDC,W;;oCAAAA;oCACCD;oCACAD;oCACCD;kC;;;;;;;;;;;;;;;;;;sCvMpkBFnwM;;;;;0B;;;;;;;4B8J4gBd;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uC7QgcZ,oB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4E2CvgBFw4D;;uB;;;;;;;sBkOuEc;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;;;;;;uB;;;sBAAA;uB;;;;;sBAAA;;;;0B;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kC7QgcZ;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCyCqpBAe;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BzCrpBA,yB;;;;;;sB6QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4D1QqvBdlhC;;qC;;;;;;gD8BxyBFixB;;;;;+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAAAA;;;;;;;;;;;8B;;;;gDAAAA;;;;;;8B;;;;;gDAAAA;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BjCmfI,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CO+CFnxB;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAAAA;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAAA;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCP/CE;;iD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAAA;;;;;;;;;;;2C;;;;;;;;;;;2DwW5cGo4K,M;;;;;;6CtgBhEWvwM;4B;;;gEwMgBlBziB,a;;;;;;;;;;;;;;;;;;;;;;;;0B1C4fI;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEwW5cGgzN;0B;;;;;;;0BxW4cH;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;kC;;;;;;;;;kEmB5dJlwK,4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CEwCO;6CD+HT,uBADS3mE;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;;;;;;;;;;;;0BgC0vBuC;;;;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qE+TxyBnCs0O;mC;;;;;qEAAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;0B,mDAAAA;0B;;;;;;;;;;;;;;sB3FYS,uB;;;;;sBAAA;;;;;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC2FZTA;uB;;;;;;;;;;;;;;;0BxW4cH;0B;;;;;;;;;;;;;;;;yCwW5cGA;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BxW4cH;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDarfJ50K;iC;;;;;;kDAAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BbqfI;;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;;;;;;;;;;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;sE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wE+BpYgBriE,E;yEAAAA,E;qEAAAA,I;kEAAAA,I;;;2CyUxEbi3O;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BviBoJT;;;8B;;;;;;;8B+LwTM,c;;;8B/LxTN;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4cxIkB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oC4FrCH,WAAJr5O;oCAAI,YAAJA;;;;;mC;;2CAAAA,E,gDAAAA;iC;;;kC1UkGX;wCAAIkd,IADkB9a;oCACtB,GADsBA,QAClB8a,IACoB,OAFF9a,EAHpBwyE;oCAIF;qCAC4D,MAFtCxyE;qCXmftB;;wC;qCAAA;sDAGkB;oCACT;qCAGA;sCAMA;wCAOA,mBAQF;wCAPH;8CWvgBA8a;yCXugBA;0CApBAsqB,MAoBIoyI;;6CAEH,qBWzgBD18J;6CX0gBC,UW1gBDA;6CX2gBC,UW3gBDA;6CX4gBC,UALG08J;;;uCAPJ;+CWhgBA18J;wCXggBA;yCAbAsqB,MAaI8xM;;4CAEH,qBWlgBDp8N;4CXmgBC,UWngBDA;4CXogBC,UAJGo8N;;;sCANJ;8CW1fAp8N;uCX0fA;wCAPAsqB,MAOI+xM;;2CAEH,qBW5fDr8N;2CX6fC,UAHGq8N;;;sCAHJ,qBWvfAr8N,eAEApY;gDAEE,OALgB1C,EAHpBwyE;oCASG,OALD13D,MAEApY;;;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iC/BiYE;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B7QgcZ;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;;;;;;;;;;;;;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,gB;;;;;;;;;;;;;;;0BAAA,+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,qB;;;;0DGqTFq8D;mC;;;;;;;;iCAhyBFe,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BH2eI,mB;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;0B7QgcZ;;qD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;;;;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;0E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,gB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CyCqpBAmgC;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BzCrpBA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B7QgcZ,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCwW5cGg3I;;;2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BxW4cH;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kD2FZTA,Q;;;;;;;;;;;;;;;;;;;;;;;;6BAAAA;;;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAAA;;;;;4B;;;;;;;;;;;;sCAAAA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB3FYS;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6B2FZTA;;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAAAA;;;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCxW4cH;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;;;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8B7QgcZ;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B7QgcZ;;;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CwW5cGA,mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAAA,M;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BxW4cH;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAAA,qB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAAA;;8C;;;mDgBtfJrzK;;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BhBsfI;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B7QgcZ,uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEwW5cGqzK;6B;;;;;;;;;;;;;;;;;;;;;;;;;kEAAAA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB3FYS;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gE2FZTA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAAAA;;;6B;;;;;;;;sB3FYS;uB;;;;;;;;;;;;;;;;;0B7QgcZ;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDejcA7zK,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB8PCY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8B7QgcZ;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEwW5cG6zK;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BxW4cH;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDarfJ50K;;0B;;;;;;;;;;;;;;;;;;;;;;qCbqfI;sC;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mC7QgcZ,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;;;;;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;;;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAAA;;;;;;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;gC;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B7QgcZ;;;;;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;;;;;;;;;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;sC7QgcZ,mB;;;;;;;;;;;;;;;;;;sB6QhcY;mD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gD2FZT40K;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mC/TimCHh3I;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAAA,oBCjpCJh8E;yC;;;;;;;;;;;;;;;;uDvBsBA6iD,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCnBseI;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B7QgcZ;4B;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;;gEpQ3ChB5C,oB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCT2eI,uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAAA;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;qD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;gD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCSyDN,SAAQkzK,OAAOr8F,MAAMj4E;oCACnB,SADai4E;sCAGX;;kEAAmBtyG,IAAI5oC,GAAK,UAALA,EAAJ4oC,IAAe,QAHjBq6B;oCAKR,qBALQA;oCAKR;0CAEMF,cAAH/iE;sCAAiB,UAAjBA,EAAiB,OAPlBk7I,cAOIn4E;oCADF,QACqC;kCAPtD,0BADSI;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BTxDH;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCyCqpBAi9B;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CzCrpBA,sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iC7QgcZ;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEwW5cGg3I;;;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BxW4cH,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;;;0B;;;;;;;;sBAAA;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCpOqlCZh3I;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BzCrpBA;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCgBpfM;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BhBofN;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAAA;mD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;;;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B7QgcZ;;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,mB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEwW5cGg3I;;;;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCvV3CPnzK,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB4PuDgB;;;;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B7QgcZ;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCyCqpBAm8B;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qD+TjmCGg3I;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BxW4cH,+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDAAA;;;0D;;;uEwW5cGA;0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BxW4cH;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAA;wD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAAA;8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B7QgcZ;mC;;;;;;;;;;;;;;;;;;;;;;;;;8BwW5cGA;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BxW4cH;wE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DwW5cGA,kB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCxW4cH;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;;;;;;;;;;;;;;;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;;2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;;;;;;;;;;;;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAAA;;;;;;;;;;;;;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CAAA,gB;;;;;;;;;;;;;;;;4BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;kC;;;;;;;;;;;;;;;;;;8BAAA;;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gFwW5cGA,S;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4ChVpBP7uK;;;;mC;;;;;;;;;4C1NjBiBO;;;;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BkMifb;qC;;;;;;;;;;;;;;;;;;;;;;;;yES3dJpxD;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;;;;gC;;;;;;;;;;;;;;;;;uEAAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEAAAA;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iEAAAA;;;;mD;;;;;;;;;;;;;;;;;;;;6CMlBIsrD;kC;;;gEAAAA,6B;4DAuBAI;4B,OAlCJT;0B,IAEO3iE,E;iDAAO,UAAPA,EAFP2iE,O;;;;;;;iEN6BAjrD;6B;;;;;;;0CM7BAirD;kC;;;;;;;;;2CAWIK,+B;;;;;;;;;;+DAXJL;oC;;;;;;;;;6CAWIK;kC;4DAuBAI;4B;;;;;qCAvBAJ;0B,OAXJL,K;;;;;;;wDAWIK,uB;;;;;;;;;;;uENkBJtrD;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDT2dI;;mD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDezeAwrD;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCyCqpBAk9B,oD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBoOrlCY;;;0B;;;;;;;;;;;;;;;;;;;;;8B7QgcZ;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAA;;;;wD;;;;;;;;;;;;;;;;0BAAA;;;;;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qFiB9fJrpF;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BjB8fI;;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,mB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;;oC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sEwW5cGqgO;;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BxW4cH;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCuB3UN;;;;iCACar5O;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;;;;;;;;;;;;;sFwW5cGq5O,M;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCxW4cH;2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDwW5cGA,Q;;;2EAAAA;oC,kCAAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAAAA;;;;;;;;;;;;;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BxW4cH;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;;;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAA;oD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCGqTFl4K;;;;;8BHrTE;8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qDhQrDhBsD;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+E2VyCO40K,yB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CxW4cH;wD;;;;;;;iFwW5cGA,O;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCxW4cH;kD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEwW5cGA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DxW4cH;;;;;;;2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAAA;;;;;;;yD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yDAAA,yB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EwW5cGA;oD;;;yEAAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB3FYS;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEpOqlCZh3I,oBCjpCJh8E;uD;;;;;;;;;;kEDipCIg8E,oBCjpCJh8E;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBmO4DgB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kC7QgcZ;;;;;;;;oC;;;;;;;;;;;;;;;;0BAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDarfJo+C;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DAAAA;wC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAAAA;iD;;;;;;;;;;;;;;;;;;;;;;;;;;;gDbqfI,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DarfJA;yC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yEAAAA;oC;;;;;;;;;2EAAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDAAAA;oC;;;;;;;;;;;;;;;;;;;;sBgQqDgB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kC7QgcZ;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CwW5cG40K;;;;;uC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BxW4cH;uD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8DgBvfJvzK,sB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BhBufI;;;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0DwW5cGuzK,a;;;;;;;;;;0DAAAA;;;;;iE;;;sB3FYS;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6B7QgcZ;+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAAA;oG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wEgBxfJxzK,+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BhBwfI;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAAA;6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAA;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gD2FZTwzK,uB;;;uEAAAA,K;;;wDjW2fLp4K,gB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BP/CE;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yEwW5cGo4K;;;;;;0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCxW4cH;;;;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;mC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;;kC;;;;;;;;;;;;4BAAA;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCarfJ50K;;0B;;;;;;;;;;;oEhN6BAL;;;qEAJAF;;6C;;;;;;;;;;;;;;;;;;;;;;;;;sBgd4BgB;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8B7QgcZ;;;;kC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDQ7dAhD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;uB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qC7P7DhB0E,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BhB6fI;;;0BiBzfO;4BAAqB,IAALnhE;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;;;;;2B;;;;;;;;;;;;;;;;;;;;;;;;uChd1BhB+hE;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BmM0dI,mB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oDwW5cGk1K;iC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BxW4cH;uC;;;;;;;;;;;0BAAA;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAAA;qC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6CnMxdJj1K;6C;;;;;;;;;;;;;;;;;;;+CAAAA,oB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BmMwdI,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAAA;qD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAA;0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+B7QgcZ,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA;;;4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAAA,wB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAA;;;sC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAAA;gC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAA,a;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB6QhcY;;;;;sB;;;;;;sBAAA;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B7QgcZ;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAAA,Y;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;6BADAW;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;;;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;0BAzBJ;;;;6CACIlC;;8CACAC;;+CACAC;;gDACAC;;iDACAC;;kDACAC;;mDACAC;;oDACAC;;qDACAC;;sDACAC;;uDACAC;;wDACAC;;yDACAC;;0DACAC;;2DACAC;;4DACAC;;6DACAC;;8DACAC;;+DACAC;;gEACAC;;iEACAC;;kEACAC;;mEACAC;;oEACAC;uEACAC,wEAE0D;uBA3B9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAyBInuW,ImHyFJsuG,enHlHA47B,KAyBIuiO;;2BADAn9T,MmH0FJg/D,enHlHA47B,KAwBIsiO;+DACA5/N;2BAFAngD,MmH2FJ6hB,enHlHA47B,KAuBIqiO;+DACA1/N;2BAFAlgD,MmH4FJ2hB,enHlHA47B,KAsBIoiO;+DACA34N;2BAFA9mD,MmH6FJyhB,enHlHA47B,KAqBImiO;+DACAz4N;2BAFA5mD,MmH8FJshB,enHlHA47B,KAoBIkiO;+DACA3lN;2BAFAr5D;;8ByPgFS6nQ;8C,OtIeb3mP,enHlHA47B;8BAmBIiiO;+DACAh7K;2BAFA3jG,MmHgGJ8gB,enHlHA47B,KAkBIgiO;+DACA96K;2BAFA8b,MmHiGJ5+F,enHlHA47B,KAiBI+hO;+DACAh/J;2BAFAG,MmHkGJ9+F,enHlHA47B,KAgBI8hO;+DACA7+J;2BAFAG,MmHmGJh/F,enHlHA47B,KAeI6hO;+DACA1+J;2BAFAG,OmHoGJl/F,enHlHA47B,KAcI4hO;iEACAv+J;2BAFAG,OmHqGJp/F,enHlHA47B,KAaI2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C;2BAnBJ,MAoBIC;2BApBJ,MAqBIC;2BArBJ,MAsBIC;2BAtBJ,MAuBIC;2BAvBJ,MAwBIC;2BAxBJ,MAyBIC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BADAW;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;;;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;0BAzBJ;;;;6CACIlC;;8CACAC;;+CACAC;;gDACAC;;iDACAC;;kDACAC;;mDACAC;;oDACAC;;qDACAC;;sDACAC;;uDACAC;;wDACAC;;yDACAC;;0DACAC;;2DACAC;;4DACAC;;6DACAC;;8DACAC;;+DACAC;;gEACAC;;iEACAC;;kEACAC;;mEACAC;;oEACAC;uEACAC,wEAE0D;uBA3B9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCACI5zW;;mCACAq9W;;oCACA9lV;;qCACAz3B;;sCACAs9W;;uCACAD;;wCACAD;;yCACAD;;0CACAD;;2CACAD;;4CACAD;;6CACAD;;8CACAD;;+CACAD;;gDACAD;;iDACAD;;kDACAD;;mDACAD;;oDACAD;;qDACAD;;sDACAD;;uDACAD;;wDACAD;;yDACAD;4DACArI,yDAE0D;uBA3B9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCACI5zW;kCACAq9W;kCACA9lV;kCACAz3B;kCACAs9W;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACArI,+BAE0D;uBA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AX/yb,GAAsB;0BAD5D;kCAANw+U;2CACmBx+U,GAAa,4BAZvBgD,EAYUhD,GAAkB;wCAA8B;uBAxFrE;;;;2B7ZkRsBq+X;;;;;;;;;;;uB6ZlRtB,OlkBiwCEi7E;uBkkBjwCF,yBlkBiwCEA;uBkkBjwCF,SlkBiwCEA;uBkkBjwCF,alkBiwCEA;uBkkBjwCF,MlkBiwCEA;uBkkBjwCF,YlkBiwCEA;uBkkBjwCF,QlkBiwCEA;uBkkBjwCF,YlkBiwCEA;uBkkBjwCF,elkBiwCEA;uBkkBjwCF,YlkBiwCEA;uBkkBjwCF,oBlkBiwCEA;uBkkBjwCF,SlkBiwCEA;uBkkBjwCF,YlkBiwCEA;uBkkBjwCF,UlkBiwCEA;uBkkBjwCF,SlkBiwCEA;uBkkBjwCF,alkBiwCEA;uBkkBjwCF,clkBiwCEA;uBkkBjwCF,gBlkBiwCEA;uBkkBjwCF,YlkBiwCEA;uBkkBjwCF,iBlkBiwCEA;uBkkBjwCF,kBlkBiwCEA;uBkkBjwCF,UlkBiwCEA;uBkkBjwCF,UlkBiwCEA;uBkkBjwCF,SlkBiwCEA;uBkkBjwCF,gBlkBiwCEA;uBkkBjwCF,SlkBiwCEA;uBkkBjwCF,mBlkBiwCEA;uBkkBjwCF,KlkBiwCEA;uBkkBjwCF,alkBiwCEA;uBkkBjwCF,elkBiwCEA;uBkkBjwCF,oBlkBiwCEA;uBkkBjwCF,mBlkBiwCEA;uBkkBjwCF,2BlkBiwCEA;uBkkBjwCF,0BlkBiwCEA;uBkkBjwCF,mBlkBiwCEA;uBkkBjwCF,gBlkBiwCEA;uBkkBjwCF,wBlkBiwCEA;uBkkBjwCF,wBlkBiwCEA;uBkkBjwCF,gBlkBiwCEA;uBkkBjwCF,gBlkBiwCEA;uBkkBjwCF,oBlkBiwCEA;uBkkBjwCF,yBlkBiwCEA;uBkkBjwCF,YlkBiwCEA;uBkkBjwCF,QlkBiwCEA;uBkkBjwCF,mBlkBiwCEA;uBkkBjwCF,wBlkBiwCEA;uBkkBjwCF,0BlkBiwCEA;uBkkBjwCF,YlkBiwCEA;uBkkBjwCF,yBlkBiwCEA;uBkkBjwCF,WlkBiwCEA;uBkkBjwCF,clkBiwCEA;uBkkBjwCF,SlkBiwCEA;uBkkBjwCF,alkBiwCEA;sBkkBjwCF,Q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hBloBCjqC;0BvhBhDI4P;4BjBERhuD,0BkP2PsBrnC,e3UzMvB2zF;uB2G8nBI6L;;;;wBlBhrBHn4D,0BkP2PsBrnC,e3UzMvB2zF;uB2G8nBIm8B,uBgOrbmB9vH,e3UzMvB2zF;uBsHnBH;;;;;;;;;;;wCXipBO99a;kC;0CATLipb;;;2CASKgxB;;;;;;8CgU1eJhrS;;+ChU0eI6qS;;;;;;;uBWjpBP;;0BAAoEtyB;0B;kCAApE0yB;;;mCAAoE1yB;uEAyBrB;uBAzB/C;;0BAAM6yB;0BAA+BC;;0BAArC;;;;;;4CqN4N0BlwH,csFzKxB18K;gD,OxUlFN+jN;gD,OiBFAiuD;;+CiO6P8Bt1F,csFzKxB18K;mCtTslBOitS;4B,OlBxqBblpF;0BkBuqBM;2BAAOkuD,6BgO5aiBv1F,csFzKxB18K;2BtTqlBA,KWxoBF+sS;2BXwoBE,KWxoBFA;2BXiZE,KAuPAz4U;2BAvPA,KAuPAA;2BAvPA,KAuPAA;2BArbE,KA8LFH;2BA9LE,KA8LFA;2BA9LE,KA8LFA;2BAzYI,KA2MF8B;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME;;;;4DAgoBGg8S,kBAhoBHy7B;;;4DAgoBGz7B,kBAhoBHhpD;;;;;;;;8BnFuHdhmN,kBmF0gBiBgqS,yBAjoBHO;2BzBmKR,GyBnKQD;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR;;;;;;;2ByBwCM;;;;;;gCA3MEl5G;gCzBmKR;2ByBwCM;0DshBpMJ8tE,oBthBoMImrC;2BA8LF;;;;8BA9LE;2BA8LF;2BAuPA;;;;8BAvPA;;;2CWjZIX,+BXiZJQ;2BWjZF;;;;8BXwoBE;;;2CWxoBmCP,+BXwoBnCM;2BzBglBMU;;;2BAAV,KoCxtCEd;2BpCwtCF,KoCxtCEA;2BpCwtCF;mCA3CYe;;6BA4CU/8Z;;;iEADZ88Z,kBACY/8Z;;gEADZ+8Z,kBACY98Z;0BA5CpB;gCA2CF0jF;2BA3CE,KA2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nBE;2BAqDmB,QArDnBA;2BAkDE;;oCAEiB,OApDnBA,WAFA3qd;2BA4EK;;8B6jBjMPg8c;uC7jBiMgEp+c;gCACxC,mBADwCA,GACpD,mBADoDA,SAC7B;2BAIL,oB8jBjL9Bw+c;2B9jBiLY,YAAG,W8jBjLfA,gB9jB2KS/uc;2BAUS,SANT00b,GAMS,W8jBrLlBqa;2B9jB2IY;oCA9CXoO,kCA+Ce,OsjBqBD/4c,KtjBrB0B;2BAG7B;;;;+BAlDX+4c;;iCAmDe,uByjB7HZz6J;iCzjB6HY;0CyjB7HZA;wDhedJxyP,iBgecIwyP,MzjB6HwC;;2BAZ5B,cAxCmB30T,kBAwCQ,O+jBtHzCohd,W/jBsHkE;2BAApD,mByjBlGZhjJ;2BzjBkGY;;8ByjBlGZA;4Che7BJj8P,iBge6BIi8P;2BzjB8FQ;2BAEoC;2BAf5B,2BAtBWwuH;0BAsBX,GAtBnBwiC;;;0CAoBuB;;;;;;0BA8CL;2BArCM;2BADC,iB8jBvH1BjgC;2B9jBsHyB,iB8jBtHzBA;0B9jBqH0B;;;;;4EnCq8BhBvyY;sCylB35BKvmC;;;;;;0CtjBqBd;uBAvKG;;;;;mCA8KJoyM,UACE9oN;qCA/KE6vd,+BHtBF7vd;;8BG4MI,e2gBlKMA;gC3gBkKN,S2gBlKN+oN,O3gBkKM/oN;kCARN;;sDAQMA;+CARN;8EAQMA,mCAAoB;wDAApBA,EAAuC;2CAAvCA,EAA+D;gC2gBlKrE,6BtTiMA2gW,asTjMA53I,QAAY/oN,E3gBmKO;;+BH7MjBgvT;;;;kCGoMF;;iCHpME9nF;;8BG2MI,kDAAmB;8BHlMnB;+BATJ2iG;;;;kCGoMF;;iCHpME7a;+BASI,gCATJ6a;8BASI,oBATJo/B,SG+MqD;4BAVrD,SA/KE6mH,+BX4UE9vd;;8BW5JA,e2gBjLMA;gC9gBgCV,S8gBhCF+oN,O9gBgCE/oN;kCADF;;sDACEA;+CADF;8EACEA,mCAAoB;wDAApBA,EAAuC;2CAAvCA,EAA+D;gC8gBhCjE,6BtTsNAy/V,asTtNA12I,QAAY/oN,E3gBkLJ;;+BX2JFgvT;;0CW9JN;iCX8JM9nF;oDW7JA,uBX6JAlnO;2DWzJmD;4CAnLrDytD;mENmJJ;sC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C;yC2gBlKNs7O;kD3gBkKMt7O;2C,OZvNNgqU;6DYuNMhqU;sD,O7BrNNg8Q,2B6BqNMh8Q;;;;;;;qCAtLF4zW,+BA+KAxrT;8B,IACEpoD,4BADFooD;4DHjJJ41S,eGkJMh+V,IADFj/G;sCA/KAA;qCXwoBE8yd,2BWpoBM7zW;8B,O7BnCZy7Q;gD6BmCYz7Q;yC,kBfwBR8zO,evGTFh7O,csHfUkH;;;qCXooBNiqU,oBWtoBMjqU;8B,kBf0BR8zO,evGTFh7O,csHjBUkH;;;;;6BXMFm0P,OAgoBJ0/G,2BWxoBFH;6BXQMt/G,OAgoBJ61E,oBAhoBI91E;oCAgoBJ81E,oBAhoBI71E;oCAgoBJy/G,2BAhoBIx/G;6BzBmKRE;;gCmHoXAn9P;gC1FyGIy8W;gCAhoBIv/G;;;6BzBmKRt0P;;;;;;;6BoC/JU8zP,+BpC+JVD;;6ByBwCMigH;;gCshBpMJ/4H;yCvhBhDJ/6O;+DY6CYA;oC,O7B3CZy7Q;sD6B2CYz7Q;+C,kBfgBR8zO,evGTFh7O,csHPUkH;;;yCZ7CZiqU;gCY6CYn2E;;6BXqYNU,wBA9LEs/G;6BA8LFr/G,OAuPA62E,iBAvPA92E;6BAuPAE,OWxoBFk/G,+BXiZEn/G;6BzBw0BSE,OoCztCXg/G,+BXwoBEj/G;mCWxoBF3zW;qCpCwtCFgzd,oBoCnsCU/zW;8B;gFAAAA;;qCpCwpCRg0W,kBA4CoBh0W;;;;qCADtB+zW,oBACsB/zW;qCADtB+zW,oBACsB3rT;;;;6BAATngG;;;6BA5CXgsS,uBA4CWD;6BADbD,MA9xBAR,eAmvBEygH;6BoC7qCA9/G,wBpCwtCFH;mCoCxtCEhzW;;;6BNnBF6zW;;gCihBaE/a;yCjhBVK75O;;;;;;;gCMgBLk0P;;;6BNbI9rS;;qEANNwsS,OAMMq/G;6BANNn/G,wCAMMD;;6BAgKRE;;gC2Nobe/c;yC3NllBNh4O;;;;;;;gCARP80P;;;;6BA0CA4zB;;gCihB7BE7uC;yCjhBgCK75O;;;;;;;gCAyHT+0P;;;6BA5HE4zB;;gCihB7BE9uC;yCjhBmCK75O;;;;;;;gCANP0oR;;;6BAQQpgU;;qEARRqgU,OAQQurF;6BARRrrF,wCAQQD;;6B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A;0B,qBqNhHwB+9U,csFzKxB18K;;4B,OxUlFN+jN;;4B,OiBFAmuD;;;;8B4QoIAh1D;;gC,O2QpFIilD;4C3QoFJjlD;;4B,OnQzHEgpF;;4CwNkP4BxpH,cxNzM1BgqH;;iCGnBAsK;;qC,OX4UE93B;;mCWAAv6a;;;uBAC6C;iCAlB/CA;0B,qBqN/F0B+9U,csFzKxB18K;;4B,OxUlFN+jN;;4B,OiBFAmuD;;;;8B4QoIAh1D;;gC,O2QpFIilD;4C3QoFJjlD;;4B,OnQzHEgpF;;4CwNkP4BxpH,cxNzM1BgqH;;iCGnBAyK;;qC,OX4UEj4B;;mCWjBFv6a;2CAkB+C;uBAlB/C;uCAAKmhd;sByVhRO;uBzVgRZ;;;;;;;;;;;;8CA4CmBn8d,GAAI,kBARZk9d,UAQQl9d,EAAa;uBA5ChC,uBA8CmBA,GAAI,kBAVZi9d,UAUQj9d,EAAa;uBA9ChC,SA4CQo9d,cAEAC;uBA9CR;;yBAAKlB;yBAALC;;;;mD;uBAAA;;;;;;;;uBAgCF;;sByVhTc;uBzVgTd;;;;;;;;;;;4C;;wBf1SU5xC;0B0hBlCAnM;4BvhBhDI4P;8BjBERhuD,0BkP2PsBrnC,e3UzMvB2zF;uBsHwUL;6Bf1SU/B;;;2B,OYvE0Cq3B,gB3FqJ1DzhS;;6B+EnGgBiqQ,gBYTHy4B;;;wC,ORyTiC9tB;uBWiDtC;;;;;;;4C,OA7XoE4zB;;uBA6XpE;uBAmB+C;wC,UAnB/CoV;uBAmB+C;iCAnB/Cz7d;0B,qBqNjK0Bs2V,csFzKxB18K;gD,OxUlFN+jN;gD,OiBFAiuD;gD,OuhBgDI7P;gD,O1hBkCAmM;;gD,OAAAA;;4B,OYvEFs3B;yCZkDEx/c;4B,kBoOgM0Bs2V,cpOhMrB5oL,UAAL1tK;;iCe5BAsmd;mD,OX4UE5zB;;mCWiDF1yb;uBAmB+C;iCAnB/CyY;0B,qBqNjK0B89U,esFzKxB18K;;4B,OxUlFN+jN;;4B,OiBFAkuD;;4B,OuhBgDI9P;;4B,O1hBkCAmM;;;4B,OAAAA;;4B,OYvEFy3B;;yCZkDEnnc;4B;gDoOgM0B89U,epOhMrB5oL,SAALl1J;;iCe5BA+xc;;qC,OX4UE33B;;mCWiDFp6a;;qCAmB+C;;iCAD7CA;0B,qBqNnLwB+9U,csFzKxB18K;;4B,OxUlFN+jN;;4B,OiBFAmuD;;4B,OuhBgDI/P;;4B,O1hBkCAmM;;;4B,OAAAA;;4B,OYvEF43B;;4B,OZkDEj4B,cYTAy4B;;iCGnBAsK;;qC,OX4UE93B;;mCWmEAv6a;;;uBAC6C;iCAnB/CA;0B,qBqNjK0B+9U,csFzKxB18K;;4B,OxUlFN+jN;;4B,OiBFAmuD;;4B,OuhBgDI/P;;4B,O1hBkCAmM;;;4B,OAAAA;;4B,OYvEF43B;;4B,OZkDEj4B,cYTAy4B;;iCGnBAyK;;qC,OX4UEj4B;;mCWiDFv6a;2CAmB+C;uBAnB/C;uCAAKijd;sByVlVO;uBzVkVZ;;;;;;;;;;;;;8CA6CmBj+d,GAAI,kBARZg/d,UAQQh/d,EAAa;uBA7ChC,uBA+CmBA,GAAI,kBAVZ++d,UAUQ/+d,EAAa;uBA/ChC,SA6CQk/d,cAEAC;uBA/CR;;yBAAKlB;yBAALC;;;;mD;uBAAA;;;;;;;;uBAiCF;;sByVnXc;uBzVmXd;;;;;;;;;;sBAoBH;;sBzG3cGxvV;sBI4HFyV;sB8bxDgB;;;;;;;;;;;;;;;;;;;;;;;;;;;sB9buDhBD;sBJ5HEzV;sB0qBVN;;sBxO+EoB;uBwO/EpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAEkD;;sB1qBS5CC;sBI4HFyV;sBADAD;sBJ5HEzV;sB0GVN;;sBAiBM;;;;;;;;;;;;;;;;sBwV8Dc;uBxV3DR;iCAM+BysP;0BACzB,IAAZooF,UAAY,sCADyBpoF;0BAGzB;uEAFZooF,WAEwC;uBATlC;;;;;;;;;;;;;;;;;;uBAgBC;uBAII,uB4hBmHNpjC,SxiBorCHo5B;uBYvyCS;;gC4hBmHNp5B;uB5hBnHM;wC,aZuyCTo5B;uBYvyCS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA8BTh1Z;2BA5CJ+6a;uBAca;;;;;;;;;;;;;;0BA4Cf;;;;;;;2B4hBwEE;2BACQ;;8BADJx8d,kBAC8B,kBxiBkrC9By2c,mBwiBlrCsD;0BAAlD,eAYDp5c;4BACK,IAAJK,EAAI,mBAfL2/a;4BAgBH,OAFGhgb,EAEa,iBADZK;4BACJ,wBADIA,EAEgB;0BAfhB,eAKDL;4BACH;8BAEM,IADEK,EACF,mBAAiB,OAVpB2/a,SxiBorCHo5B;8BwiBxqCI,OALDp5c,EAKiB,iBAHZK;8BAGJ,wBAHIA,EAIe;4BALvB,kBxiB4qCA+4c,iBwiBvqCyB;0BAXrB;iCxiBkrCJA;2BwiB/qCF,iBxiB+qCEA,awiBnrCAz2c,ExiBmrCAy2c;0BwiB/qCF;mCxiB+qCEA;;;;;;;mCwiBlrCAp5c,E5hBxEyB;sBwVNb;;;uBxV+BJ,kB7BqEV8hY,cAtGAu9C;uB6BiCU;kCZiuCR+5B;uBYjuCQ,OZiuCRA;uBYjuCQ,KZiuCRA;uBYjuCQ,QZiuCRA;uBYjuCQ,SZiuCRA;uBYjuCQ,UZiuCRA;uBYjuCQ,WZiuCRA;uBYjuCQ,WZiuCRA;uBYjuCQ,WZiuCRA;uBYjuCQ;iCAcGt5c;0BAAsB;mCAHS6/d,QAG/B7/d,EAAsB,WZmtCjCs5c,mCYntC4C;uBAdpC,SZiuCRA;uBYjuCQ,SZiuCRA;uBYjuCQ,UZiuCRA;uBYjuCQ,WZiuCRA;uBYjuCQ,WZiuCRA;uBYjuCQ,WZiuCRA;uBYjuCQ;iCA0BQt5c,EAAEzB,GAAI,kBZusCtB+6c,aYvsCgBt5c,EAAEzB,EAA0B;uBA1BpC;iCA4BMyB,EAAEzB,EAAEy5B,GAAI,kBZqsCtBshb,aYrsCct5c,EAAEzB,EAAEy5B,EAA0B;uBA5BpC;;;;iCAmCCz0B,EAAQvD;0BACA;mC7BiCnBgiY;mC6BjCmB,W7BzEVz2L,Q6ByEiB,W7BwC1B02L,U6BzCW1+X,GAAQvD,GACwB;uBApCjC;;0BAsC2B,kB7B+BrCgiY,c6B/BqC,W7B3E5BlpS,U6B2EwC;uBAtCvC,WZiuCRwgX;uBYjuCQ;iCA0CAlzY,GAAGF;0BACX,SAAIv8D;4B,IAAS3J;8CZsrCbs5c,kCYtrCat5c;0BACV,WAFKomE,IAEW,OAFRF;0BAGH,WAHGA,IAGa,OAHhBE;0BAKoB;4C7B6B9B67T,U6BlCa/7T;2BAKE,a7B0Cfs5W,W6B1Ce,W7B6Bfv9C,U6BlCU77T;0BAKK;4BA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,qBgD9HfA;8BhD8He,UAAR24e,IAAQC;;qCAKlBN;qCACAC;qCACAE;qCACAC;qCACAG,OgDrIkC;+BAF/BlqV;;6BhDkIP;;iCgDlIOpnK;8BhDkIP,GgDlIOA;8BhDkIP,GgDlIOA;8BhDkIP,KgDlIOA;8BhDkIP,KgDlIOA;8BhDkIP;;8BAxBA,GAwBA0nU;8BAxBA,GAwBAA;8BAxBA;8BAwBA;;;;iCAxBA;8BAwBA;8BAJA,KAIAylC;8BAJA,KAIAA;8BAJA;;;sCAIAI;sCAJA;oCgD9HOxmM;;;8BhDkIP,GgDlIO/mK;8BhDkIP,GgDlIOA;8BhDkIP,GgDlIOA;8BhDkIP,KgDlIOA;8BhDkIP,KgDlIOA;8BhDkIP,uBgDlIOyY,UhDkIP21H;qDgDlIO31H,IhDkIPs+B;8BAxBA,GAwBA2wR;8BAxBA,GAwBAA;8BAxBA,qBgD1GOjvT,IhD0GPqgC;qDgD1GOrgC,IhD0GPC;8BAwBA,uBgDlIOD,IhDkIPi6B;8BAJA,KAIAy6T;8BAJA,KAIAA;8BAJA,uBgD9HO10V,IhD8HPugC;qDgD9HOvgC,IhD8HPk8B,WgD5HsC;;4BAF/BqyH;qCAAKT,YAALS;;;;;;;qCAAKT;qCAALS;;;0CAE+B;sBAGi0B;;sB9rBCn2B76B;sBI4HFyV;sBADAD;sBJ5HEzV;sB+rBVN;;sBAAS,wBlDcLyoE;sBkDZK,sBlDYLA;sB3MiEgB;uB6P7EX;;0BAMmB,uBDPxBm8S;0BCOwB;mCDPxBA;iD5fyBA7wb,iB4fzBA6wb,kBCO0D;uBANrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;uBAAA;sBAmBL;;;;;;;;;;;;;;;;sB7P0DgB;uB6P1DhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;sBAQD;;sB/rBlBG3kX;sBI4HFyV;sBADAD;sBJ5HEzV;sBgsBVN;;sBAY6C;;sBhsBDvCC;sBI4HFyV;sBADAD;sBJ5HEzV;sBisBVN;;sB/P+EoB;uB+P/EpB;;mCAGMolC;4BAAKkgV,QAAQC,QAAQC,YAAYv/c,MAAM6zS,UAAUjP;4BACnD;;;;;;;;;qCADe06K;8CAaiBh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uBAA8D;wC,UAA9DqjV;;;;;;;;;yC1G8IR9iV,2B0G9Iay6C;;uBAAL;uBAA8D;wC,UAA9DsoS;uBAA8D,mBAA9Dz9f,iBAA8D;;iCAA9DyX;;mDsDsFA6gK,ctDtFA7gK;6B6lBXFmlf,ezjBmBEzH,oBpCRA19e;;;0BAA8D,OAA9DzX,CAA8D;;iCAA9DyX;;;;;;;0BAA8D,OAA9DzX,CAA8D;0CAA9D49f;uBAA8D;iCAA9D59f;;;;;mEsDsFAo4K,ctDtFA3uH;;mD6lBXFszc,czjBkBA9H,mBpCPEvrc,IAA8D;;iCAA9DjyC;;;;;0CsDsFA4gK,etDtFA5gK;iC6lBXFulf,ezjBkBA9H,oBpCPEz9e,WAA8D;0CAA9Dsmf;uBAA8D,YAA9DL;uBAA8D;uBAchE;;;;;;;4C,O6lBzBwBnB,8BpTiMnBpiV;;uBzSxKL;uBAuBG;wC,UAvBHgkV;uBAuBG;iCAtBD18b;0B6lB1BF;8B7lB0BEA;2B6lB1BF,G7lB0BEA;2B6lB1BF,wCzjBkBAwzb,cyjBlBAxrc;;uB7lBgDG;iC6lBhDHhyC,U7lB0BEgqD;0B6lB1BF;8B7lB0BEA;2B6lB1BF,G7lB0BEA;2B6lB1BF,ezjBkBAyzb,eyjBlBAz9e;4D7lB2BmC;uBAqBhC,mBkCLW4mf;uBlCKX;iCAtB6C5mf,I6lB1BhDmjI,Q7lB0BgDsrB;0B6lB1BhD;uB7lBgDG;iC6lBhDHzuJ;0BAEI;0CzjBiBF09e,eyjBnBF19e;2BAEgB,yBAFhBA;0BAEgB,UAAZolf,IAAYC,S7lByBmB;uBAqBhC,mBkCLW2B,cMqLdD;uBxChLG,YkCLgEJ,WlClBnEG,gBACEG;uBAsBC;;iCAtBDn4V;0B6lBxBM,G7lBwBNA,gB6lBxBM;0B7lBwBK,qB6DunCT+uV,S7DvnCF/uV;sEAA8D;uBAsB7D;iCAtBDoD;0B6lBxBM,G7lBwBNA,gB6lBxBM;0B7lBwBK,I6lBxBLrqK,E7lBwBK,WolB+Ffw1f,YplB/FInrV;uC6lBxBMrqK,EAAiB,iB7lBwBvBqqK,mB6lBxBMrqK,C7lBwBwD;uBAsB7D;iCAtBD0qK;0B,I6lB1BFpoD,eTyHFizY,eplB/FI7qV;0D6lB1BFpoD,I7lB0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uKAz1b;6BPvKA,GOuKAA;;6BPvKA;;;;;0BOuKA,kBHxKF,KGwKEG;;;;mCHxKF,kDG2KuD;;iCAHrD91H;;;;;6BPvKA,GOuKA21H;6BPvKA,GOuKAA;6BP9IF;6BAzBE,qBOuKA31H,IP9IFs+B,MAzBE0T;oDOuKAhyC,IPvKAC;0BOuKA;;;2BHxKF,KGwKE61H;2BHxKF,yBGwKE91H,IHxKFqgC;kDGwKErgC,IHxKFi6B,WG2KuD;;iCAHrDj6B;;;4BP9IF;;6BArBM,4BOmKJA;6BPnK+B,0BOmK/BA;6BPnK+B,SAA3ByrjB,cAA2BC;sCOmK/B75Z;;4BHxKF,4BGwKE7xJ;4BHxKF;6BACsB;2DGuKpBA;yCHvKoB2rjB;;iCGuKpBz5P,QHxKF,uBGwKE/uL;;mEAGqD;;iCAHrD1oC;;;;;;;;;;;;4B8B6VE,c9B7VF;;;;;;;;;;;;;;;;;;;;kCHxKF,SGwKE9yG;;;;;;;2DHxKF,2BGwKEA;;;;;;;;;;;;;0CHxKF;;;;;;;;;;;;;;;;;;;;;uDACsB;mFADtBunO;;;;0EACsBh5C,aADtBlxL;;8DACsBkxL,aADtB,sCGwKEvuL;yDHvKoB;;sDADtB;;;;;8CGwKE4iD;+CHxKF,mDGwKE5iD;;6CHxKF;kDGwKE4iD,KHxKF,0CGwKE5iD;;+CHxKF,UACsBkkkB;+CADtB;gFGwKEthhB,QHvKoBuhhB;;;iDGuKpBvhhB;kDHxKF;;oDGwKE5iD;gEHvKoBkkkB;;;2CGuKpBthhB,KHxKF,mCGwKE5iD;;8CHxKF,kCGwKEA;uDHxKF,2BGwKEA;;;;;;;gCPvKA,SOuKA8vI;0CPvKA,oCOuKAA;;kCPvKA;+COuKAA;mCPvKA;;;;;;;;;;;;;;;;;;;;;;;;;iGOuKAA,KPlKsD;yDALtDZ;;;;;;gDAII;0EAJJF;;kDAII;;;;;+CAA2B;yEAJ/BA;;iDAI+B;;;;8CAJ/B;;;;;sCOuKAe;uCPvKA,iDOuKAD;;qCPvKA;0COuKAC,KPvKA,wCOuKAD;;uCPvKA;8CAIIs0b;wCAJJ,MAI+BC;;;;;yCAA3BE;yCOmKJx0b,QPnKIw0b,kBAA2BD;;;;;yCOmK/Bv0b;0CPvKA;;4COuKAD;;sDPnKIs0b;yDAA2BC;;0COmK/Bt0b;;iEAGqD;;;0BAHrD;4BACE;;6BPxKF,SOwKED;6BPxKF,cOwKEA;6BPpK6B;;6BAA3B;iEAA2BK;6BAA3B;kDOoKFnwI;0BACA;;2BH1KJ,eG0KI+vI;2BHzKkB;;;gDGyKlBntF,SACmD;;iCAHrDgoH;0B,SAAArnK;4BACE;gCADFA;6BACE,iCADFqnK;;6BPvKApoD,ea+NAy9Y,ebtMFhqJ,MO+IIpW;oDPxKFr9O,IOwKEq9O;0BACA,SAFFt8V,OAEE,iCAFFqnK;4CMwDAq1V,eT/NA/pJ,MGyKEq6D;uBAFF;uCAAKmzJ;sB2SnGS;uB3S8Gd;;;;;;;;;0CP/IGre;6CI1BA0O;;uBGyKH;uBAMqD;wC,UANrD4Q;uBAMqD;;0BANrD;;;6BPvKA,GOuKA32b;6BPvKA,GOuKAA;6BPvKA,GOuKAA;6BPvKA,GOuKAA;;6BPvKA;;;sEkmBLFg0a,clmBKE16O;;;;;0BOuKA;;2BHzKF,KGyKEn5L;2BHzKF,KGyKEA;2BHzKF;;;;0FG+KuD;;iCANrD91H;;;;;6BPvKA,GOuKA21H;6BPvKA,GOuKAA;6BPvKA,GOuKAA;6BPvKA,GOuKAA;6BP/IF;6BAxBE,qBOuKA31H,IP/IF2gC,MAxBEqR;oDOuKAhyC,IPvKAC;8CkmBLF2piB,e3lB4KE5piB,IPvKAi6B;oDOuKAj6B,IPvKAk8B;0BOuKA;;;2BHzKF,KGyKE45F;2BHzKF,KGyKEA;2BHzKF,yBGyKE91H,IHzKFsjC;kDGyKEtjC,IHzKFs+B;kDGyKEt+B,IHzKFqgC,WG+KuD;;iCANrDrgC;;;4BP/IF;;6BAvBM,0BOsKJA;6BPrKI,4BOqKJA;6BPpKI,sBkmBRN6piB,e3lB4KE7piB;6BPnKI,0BOmKJA;6BPnKI,SAHA2sjB,YACAlB,cACAmB,WACAlB;sCOmKJ75Z;;4BHzKF,4BGyKE7xJ;4BHzKF;6BAEQ;wDGuKNA;8BHtKM,6BGsKNA;yCHvKM6sjB,YACAlB;;iCGsKNz5P,QHzKF,uBGyKE/uL;;mEAMqD;;iCANrD1oC;;;;;;;;;;;;4B8BkVE,c9BlVF;;;;;;;;;;;;;;;;;;;;kCHzKF,SGyKE9yG;;;;;;;2DHzKF,2BGyKEA;;;;;;;;;;;;;0CHzKF;;;;;;;;;;;;;;;;;;;;;;;;;;;yGGyKEA,GHpK6C;iEAL/CkvI;;;;;;wDAGQ;oFAHRq4F;;0DAGQ;;;;;uDADA;mFAFRA;;yDAEQ;;;;sDAFR;;;;;8CGyKE3kL;+CHzKF,mDGyKE5iD;;6CHzKF;kDGyKE4iD,KHzKF,0CGyKE5iD;;+CHzKF;sDAEQolkB;gDAFR,MAGQlB;;;;;iDADAmB;iDGuKNzihB,QHvKMyihB,gBACAlB;;;;;iDGsKNvhhB;kDHzKF;;oDGyKE5iD;;8DHvKMolkB;iEACAlB;;;2CGsKNthhB,KHzKF,mCGyKE5iD;;8CHzKF,kCGyKEA;uDHzKF,2BGyKEA;;;;;;;gCPvKA,SOuKA8vI;0CPvKA,oCOuKAA;;kCPvKA;+COuKAA;mCPvKA;;;;;;;;;;;;;;;;;;;;;;;;;;;iGOuKAA,KPjKsD;yDANtDZ;;;;;;;;kDAGI;4EAHJF;;oDAGI;;uEkmBRNmza,clmBQM/zX;;;iDAFA;2EADJp/C;;mDACI;;;;;gDACA;0EAFJA;;kDAEI;;;;;+CAEA;yEAJJA;;iDAII;;;;8CAJJ;;;;;sCOuKAe;uCPvKA,iDOuKAD;;qCPvKA;0COuKAC,KPvKA,wCOuKAD;;uCPvKA;8CACIw1b;wCADJ,MAEIlB;wCAFJ,MAGImB;wCAHJ,MAIIlB;;;;;yCADAmB;yCADAjB;yCADAkB;yCOsKJ11b;;2CPtKI01b;2CACAlB;2CACAiB;2CACAlB;;;;;yCOmKJv0b;0CPvKA;;4COuKAD;;sDPtKIw1b;;uDACAlB;;wDACAmB;2DACAlB;;0COmKJt0b;;iEAMqD;;;0BANrD;4BACE;;6BPxKF,SOwKED;6BPxKF,WOwKEA;6BPxKF,cOwKEA;6BPxKF,YOwKEA;6BPpKE;;6BADA,iBkmBRNsya,clmBQM6iB;iEACA90b;6BAFA;iEACAC;6BAFA;iEACA8G;6BADA;kDOuKFl3I;0BACA;;2BH3KJ,eG2KI+vI;2BH3KJ,YG2KIA;2BHxKI;;2BADA;+DACAia;2BADA;gDGyKJpnG,SAImD;;iCANrDuzT;0B,SAAA5yW;4BACE;gCADFA;6BACE,iCADF4yW;;6BPvKA3zP,eaoNAy9Y,eb5LF7pJ,MOgJIvW;6BPxKFj1L,iBaoNAq1V,ebpNAz9Y,IOwKEq9O;6BPxKFoW,iBkmBLFqsM,elmBKE13Y,MOwKEi1L;oDPxKFoW,MOwKEpW;0BACA;gCAFFt8V;2BAEE,iCAFF4yW;2BHxKAD,iBSqNA+pJ,eTrNA5pJ,MG0KEk6D;4CM2CF0vF,eTrNA/pJ,MG0KEq6D;uBAFF;uCAAKq0J;sB2S9GS;uB3S8Gd;;;;;;;;;0CP/IFlf;6CI1BA0O;;uBGyKE;uBAMqD;wC,UANrDyR;;;;;;;;;yC5I1BNvqZ,2B4I0BWwqZ;;uBAAL;uBAMqD;wC,UANrDC;uBAMqD,oBANrDnlkB,iBAMqD;;iCA2CrDulkB;;4BAIsB;2DAJtBC;6BAII,gCAJJD;4BAII,oBAJJ95Q,SAKsD;uBAhDD;iCA2CrD85Q;;4B;8BAAA;;;;;;;;qCAIIl5b,KAJJC;qCAII7vI;qCAJJ,kCAIIA,GAJJqqI;0CAIIuF;qCAJJ/sH;;;mCAIsBknT,KAJtBl6L;mCAIsBpiF;mCAJtB,qCAIsBA;mCAJtBoiF,KAIsBk6L;mCAJtBlnT;;;;;;gGAKsD;4BALtD,YAKsD;;uBALtD;;;;;;;;;;iCAAsBmjjB;0B,UAAtBiD,mBAAsBjD,mBAKgC;uBALtD;iCAAMoD,eAASC;0BAAf;;;mEAAMD,eAANp8gB;;8DAAeq8gB,aAAfp8gB,IAKsD;uBALtD;iCAAMs8gB,aAASC,WAAfxujB;;;;4CAAMuujB,aAANvujB;4CAAewujB,WAAfxujB,aAKsD;uBALtD;iCAAM0ujB,UAASC,QAAf3ujB;0BAII;+CAJE0ujB,UAAN1ujB;2BAIsB,kBAJP2ujB,QAAf3ujB;0BAIsB,UAAlB4ujB,SAAkBC,OACgC;uBALtD;;;;;;;;;;;;;;;;;;;;;oC8BiSE;sC9BjSF;;;;;;;;;8FAKsD;iDALtDh4b;;;;;;wCAII;kEAJJF;;0CAII;;6DAJJ+3b,UAII34Y;;;uCAAkB;iEAJtBp/C;;yCAIsB;;8DAJtBg4b,QAIsB34Y;;sCAJtB;;;;;;;;sCAII+4Y,gBAJJ,MAIsBC;;sDAAlBE;qDAAkBD;4BAJtB;;;;+CAIIF;kDAAkBC,8BACgC;uBALtD;;;;;2BAIsB,eAJtBL,QAIsBE;;2BAAlB,iBAJJH,UAIIE;+DAAkB92b;0BAAlB,iBACkD;uBALtD;;0B,IAAAy6B;;;;0BAIa,GAJb+6M,gBAIa;2CAJbkiN;0BAIa,eAAgB,WAJ7BC,4BAIa5nkB,CAAO;;uBAJpB;;;;;;;;;;uBAAsB8nkB;uBAAtB;;;;;;;;;;;uC5I3EN1sZ;;;;yC4I2E4B1uD;mC,UAAtBm7c,mBAAsBC;;;;uBAAtB,qCAKsD;uBALtD;;;oCAII3E,UAAkBz2c,QACgC;uBALtD;;;oCAIIy2c,OAAkBz2c,KACgC;uBALtD;uBAkBF;;;;;;;;+B,OAlBwB25c,gBAzKjB5F;8BA6GA+C;;uBA8EP;uBAC+C;wC,UAD/C2E;uBAC+C;iCAD/CzokB;0B,OAlBE4mkB,cAzKA5F,cA6GA+C,cA8EF/jkB;uBAC+C;iCAD/CyY;0B,OAlBEsujB;mCAzKA9F,eA6GA+C,eA8EFvrjB,UAC+C;;iCAD/CA;0B,OAlBEyujB;mCAzKA9F,eA6GA6C,eA8EFxrjB,YAC+C;;iCAD/CzX;0B,OAlBEumkB,cAzKA3F,cA6GAyC,cA8EFrjkB;uBAC+C;iCAD/ChB;0B,OAlBE4nkB,cAzKArF,cA6GAqC,cA8EF5kkB;uBAC+C;iCAD/C4iH;0B,OAlBEild;mCAzKArF,eA6GAqC,eA8EFjid;;uCAAK8ld;sB2SjLW;uB3SiLhB;uBASA;;;;;;;;+B,OA3BwB/B,gBA1JjBhE;8BAyGAqC;;uBA4EP;uBAC+C;wC,UAD/CkE;uBAC+C;iCAD/ClpkB;0B,OA3BE4mkB,cA1JAhE,cAyGAqC,cA4EFjlkB;uBAC+C;iCAD/CyY;0B,OA3BEsujB;mCA1JAlE,eAyGAqC,eA4EFzsjB,UAC+C;;iCAD/CA;0B,OA3BEyujB;mCA1JApE,eAyGAqC,eA4EF1sjB,YAC+C;;iCAD/CzX;0B,OA3BEumkB,cA1JAvE,cAyGAuC,cA4EFvkkB;uBAC+C;iCAD/ChB;0B,OA3BE4nkB,cA1JAzE,cAyGA2C,cA4EF9lkB;uBAC+C;iCAD/C4iH;0B,OA3BEild;mCA1JAzE,eAyGA2C,eA4EFnjd;;uCAAKumd;sB2S1LW;uB3S0LhB;;;;;;;;qCA3BEn8c;+B,UAAAq7c;8BAjDAjC;;uBA4EF;uBAC+C;wC,UAD/CuD;;;;;;;;;yC5ItGJjuZ,2B4IsGSkuZ;;uBAAL;uBAC+C;wC,UAD/CC;uBAC+C,oBAD/C7okB,iBAC+C;;iCA7E7CyX;0BA4EF;qDoB9JI6gK,cpBkFF7gK;2BAiDA,0BoBnIE6gK,cpBkFF7gK;2BAzGA,0BoBuBE6gK,cpBkFF7gK;2BAzGA;;;;2BA/BE,0BoBsDA6gK,cpBkFF7gK;2BAvIM,uBAuINA;2BAtIM,eAsINA;2BArIM,kBAqINA;2BApIM,yBAoINA;2BAnIM,+BAmINA;2BAlIM,wBAkINA;2BAlIM;;6BALA4ojB;6BACA0B;6BACAzB;6BACAC;6BACAC;6BACAC;0BANJ;;0BA+BF;;0BAqLF;2BA5EE,0BoBlFEnoZ,cpBkFF7gK;;;4BP/IF;uD2B6DI6gK,cpBkFF7gK;6BP/IF;6BAxBE,wB2BqFE6gK,cpBkFF7gK;6BPtKI,eOsKJA;6BPrKI,iBOqKJA;6BPpKI,cOoKJA;6BPnKI,0BOmKJA;6BPnKI,SAHA2sjB,YACAlB,cACAmB,WACAlB;4BAJJ;;4BAwBF;;gCO+IE9vd;;;6BHzKF;wDuBuFIilE,cpBkFF7gK;8BHzKF,wBGyKEA;6BHzKF;8BAEQ;8CGuKNA;+BHtKM,kBGsKNA;+BHzKFzX,KAEQskkB,YACAlB;;kCAHRpjkB,yBGyKE46I;6BHzKF;;iCGyKEvnC,OHzKFrzG;;gCGyKEqzG;;;0BA4EF,WAvBMgzd,SArDJhzd;0BAiDA;;0BA2BF;;0BAC+C,OAD/CwH,GAC+C;;iCAD/C76G;;;;;;+DoB9JIo4K,cpB8JJq3R;2BA3BE,mBA2BFsY;2BA3BE;;;+DoBnIE3vS,cpBmIFo3R;;;2BA1JA,mBA0JAh5T;2BA1JA;;;+DoBuBE4hC,cpBvBFlrC;;;;;2BA/BE,mBA+BF44U;2BA/BE;;;+DoBsDA1tS,cpBtDArrC;;;;;;;;;;;;2BAyLF;;;;;;gCA1JAggO;;;kCA/BED;;2BAwIF,mBAiDAo6G;2BAjDA;;;+DoBlFE9uS,cpBkFFniC;;;;4BP/IF,kBO+IEJ;4BP/IF;;;gE2B6DIuiC,c3B7DJhrC;;4BAxBE,gBAwBFw0P;4BAxBE;;;gE2BqFExpN,c3BrFFr8D;;;;;;;;;;;;;;iCAwBFuwP;;;mCAxBED;;;2BOuKA;;4BHzKF,mBGyKEr2N;4BHzKF;;;gEuBuFIoiC,cvBvFJ1pC;;;;;;;;;;;;mCGqPAy+N;;;qCA3BED;;gFAjDAF,iBA6E6C;;iCA7E7Cv1V,IA4EF2lC;;;;;6CoB9JIi7H,epBkFF5gK,IA4EF2lC;2BA3BE,mBA2BF2qa;2BA3BE;;6CoBnIE1vS,epBkFF5gK,IA4EFglC,OA3BE+yZ;;;2BA1JA,mBA0JAh5T;2BA1JA;;6CoBuBE6hC,epBkFF5gK,IAzGAilC;;;;;2BA/BE,mBA+BFopa;2BA/BE;;6CoBsDAztS,epBkFF5gK,IAzGAwkC,OA/BE8wF;;;;;;;kDAwIFt1H,IAxIEokC;sCAwIFpkC,IAxIEqjC;sCAwIFrjC,IAxIE2jC;mDAwIF3jC,IAxIE0jC;mDAwIF1jC,IAxIEyjC;mDAwIFzjC,IAxIEwjC;2BAwIF,mBAiDAisa;2BAjDA;;6CoBlFE7uS,epBkFF5gK,IAiDAujC,OAjDAi7F;;;;;6BP/IF,kBO+IEJ;6BP/IF;;8C2B6DIwiC,epBkFF5gK,IP/IFukC;;6BAxBE,gBAwBF4lV;6BAxBE;;8C2BqFEvpN,epBkFF5gK,IP/IFqgC,MAxBEikE;;;;;sCOuKAtkG,IPvKAs+B;wCOuKAt+B,IPvKAC;wCOuKAD,IPvKAi6B;oDOuKAj6B,IPvKAk8B;0BOmPF;2BA5EE;;2BHzKF,mBGyKEqiG;2BHzKF;;4CuBuFIqiC,epBkFF5gK,IHzKF+kC;;;oDGyKE/kC,IHzKFsjC;sCGyKEtjC,IHzKFugC;sCGyKEvgC,IHzKF2gC,WGsP+C;;iCAOvCone,IAAKmgD,aAAcP,MAAOM,YAAap6iB,KAAM0mG;0BAM/C;qCANEwzZ,IAAKmgD,aAAcP,MAMrB,QAN4BM,mBAAap6iB;kCAAM0mG,KAUtD;uBAjBgD,eAmB1ChsH,GAAS,OAATA,OAAqB;uBAnBqB;iCAyBpCA;0BAAS,kBwlBhOtBy4iB,UxlBgOaz4iB,QuQwoBTqijB,evQxoB0E;uBAzB7B,iBA2BxCrijB,GAAS,OAATA,OAAuB;uBA3BiB,qBA6BlCA,GAAS,OAATA,OAA6B;uBA7BK,gBA+BzCA,GAAS,OAATA,OAAsB;uBA/BmB;iCAqCrCA;0BAAS,UAATA;0BApFV;gCACUigP;8CwlBzJZw4T,UxlByJYx4T,WuQ+sBRoiU;0BvQ5nBiB,IAhFf,mBH7LO,aG4LQynB;0BH5LR,kB2lBiCbrxB,U3lBhCiBsxB,a0Qw4Bb1nB,evQ5nBqC;uBArCQ;iCA2CvCrijB;0BACV,UADUA;0BACV;4BAEI,IADMigP,iBACN,UADMA;0BAGN,QAAI;uBAhDyC,SPhN/C+kU;uBOgN+C;;iCA4ExCyd;0BAEsB;sDAFtBA;2BAEP;4CAAiB;0BAAjB,eAGMz2c,MACR,UANSy2c,OAKDz2c,KACa;0BAhJnB;4BAGK,mBAAsC,IAALnzH,WAAK,UAALA;4BAAf,IAAL+Z;4BAAK,UAALA,EAA4C;0BP1IhE,eACSq3jB;2CACDpqY,QACR,UAFSoqY,YACDpqY,OACoB;4BADX,yCOoITmqY;4BPpIS;0BAFjB;uEagTEt3a;;;;;;uCnJtWEw0B;gC,sBAFMwsY,cAENxsY;;;;;;;;2CADAE;oC,sBADE8iZ,cACF9iZ;;;2E6I8UiB;oDA/OjBw7Y;sBA+PyC;sBvJjWzCz3b;sBADAD;sBwvBRN;sBA4QG;sBxvBnQGC;sBADAD;sBuvBTN;sBrT8EoB;uBqT9EpB;;0BAOE;;;;;;;kCACI1tI;qCACA4skB,aACAH,eACAryB,YACA/3W,aAEoB;uBAd1B;;0BAOE;;;;;;;;;;oCACIriM,IACA4skB,UACAH,YACAryB,SACA/3W,OAEoB;uBAqEtB;;;;2BjmBqKA6+X;8BjCxJEv+D;0BkoBzFJgqE;;;;uBA4EE;;0BAmDA;;;;;;;;kCACI3qD;;mCACAgrD;sCACA7K,gBACAP,SACAM,eACAp6iB,YAEoB;uBA3DxB;;0BAmDA;;;;;;;;;;;;oCACIk6f,IACAgrD,UACA7K,aACAP,MACAM,YACAp6iB,KAEoB;uBAiDxB;;;;;uCloB/FE66e;0BkoBsCFoqE;;;;uBAyDA;;;2BAkB6Dv+c;;2BAA/C1mG;2BAAgCo6iB;2BAAPN;2BAAdO;2BAALngD;mCAAyCxzZ;;;4BA5LR6zE;4BAAboqY;uCA4LftK,aA5LesK,YzVq5BtC5nB,eyVr5BmDxiX;;;oCA4LQ7zE;4BArL1B+9c;;kCAqLVpK,aArLUoK,azV84BjC1nB;;qCyVztBkB7iC,IzVytBlB6iC,eyVztBuBsd,aAAcP,MAAOM,YAAhCp6iB;;uBAlBd;iCAiCOm9iB;yCACDz2c,MACR,UAFSy2c,OACDz2c,KACoC;oCAFnCy2c;0BA3LP,eACSjlkB;4BAIiB;;6BAApB;8CAAQ;4BAAR,OAJGA;;mCAEEwkC,IACH4oiB,4BADF3oiB;yCAAKD,cAALC;;mCAAKD,IACH4oiB,4BADF3oiB;;+BAgBE,mBAhBGD,UAALC,IAgBG;4BAdiB,IAHlB85S,eAmBN,qBAlBI95S,IAAKD;mCAFFxkC;yCAuBLm0J;;;;iCAKE,2BzVw2BJ0wZ;;;;gCyV72BE1wZ;iCAOE,2BzVs2BJ0wZ;;;;gCyV72BE1wZ;iCASE,2BzVo2BJ0wZ;;;;;+ByV72BEzK;+BADAqyB;+BADAG;+BApBIvqY;wCADCriM,IAqBL4skB,UACAH,YACAryB,SAtBI/3W;;iE1lB6URntC,Q0lBvTIf;iE1lBuTJe;iE0lB7UQqpL;;0BAFR,wCjmBrBAsgP;;oDC4FEuG;sBgmB+HJ;;2BA9CI8H,UA3GAJ;wBAuJA/C;wBACAC;wBADAD;wBACAC;sBrT5Jc;uBqTkLhBvrD;;;2BAA2BjwZ;2BAARy2c;2BAxIwC5iY,OAwIhC7zE;2BAxIsB4rb,SAwItB5rb;2BAxISi+c,YAwITj+c;2BAxIFo+c,UAwIEp+c;2BAxIPxuH,IAwIOwuH;0BAvIpB,cRtGGu2b,SQqGuC3K,SzVkzB/CyK;4ByV1yBG;;6BADA,2BAPsDxiX;6BAKtD,sBAL+BoqY;6BAI/B,sBAJoBG;6BjmBqGE,gBAAoB,gBimBrG3B5skB;6BjmBnFD8P;6BAAJF;6BAAJD;;;;iCC6DPo1a,aD7DOp1a,MAAIC,MAAIE;;;iCCrBjByxjB;;;gC/DiEA18I;6B+DgB0D/8Z,KgmB+JzCm9iB;6BhmB/J4B/C,YgmB+J5B+C;6BhmB/JqBrD,MgmB+JrBqD;6BhmB/JO9C,agmB+JP8C;6BhmB/JEjjD,IgmB+JFijD;6BhmBvJd,gBAAU,iBAR6Cn9iB;6BAOvD,uBAP0Co6iB;6BAM1C,uBANmCN;6BAKnC,sBALqBO;mC/DhBxBt9I;qC+DmBG;;6DAHgBm9F;wCAjFnBu/C;;;;;uC/DiEA18I;;;sB+pBuNW;sBvvB9RXl3S;sBADAD;sBwJVN;sB0S+EoB;uB1S/EpB;;mCAwBQq6E;;8BAKsC;6DALtCwlX;+BAKwB,gCALxBD;+BAKI;uDALJD;8BAKI,oBALJvkQ,SAM+C;mCAN/C3qQ;;8B;oCAAAoG;;;;;;;;;yCAKwBsqE,KALxBC;yCAKwB7vI;yCALxB,mCAKwBA,GALxBsqI;8CAKwBsF;yCALxB/sH;;;uCAKsCknT,KALtCl6L;uCAKsCpiF;uCALtC,+CAKsCA;uCALtCoiF,KAKsCk6L;uCALtClnT;;;qCAKImnT,KALJn6L;qCAKI78C;qCALJ,mCAKIA,KALJq3C;0CAKI2/L;qCALJnnT;;;;;;;;;kHAM+C;8BAN/C,YAM+C;0BAN/C;;;;;;;;;;;;mCAAiCimJ;4B,UAAjC3uB,eAAiCqpG,gCAMc;0BAN/C;4BAAM+qV,gBAAUC,WAAKC;4BAArB;;;;qEAAMF,gBAANvhhB;0EAAgBwhhB,WAAhBvhhB;;kEAAqBwhhB,kBAArBxkQ,IAM+C;0BAN/C;4BAAMykQ,cAAUC,SAAKC,gBAArB5zjB;;;;;8CAAM0zjB,cAAN1zjB;8CAAgB2zjB,SAAhB3zjB;8CAAqB4zjB,gBAArB5zjB,aAM+C;0BAN/C;4BAAM6zjB,mBAAUC,cAAKC;4BAArB;;qCAAqBA;+BAArB,MAAgBD;+BAAhB,MAAMD;8BAAN;gC,OAAAvla,6CAM+C;4BAN/C;;;+CAAMula;+CAAUC;+CAAKC;+CAArBxskB,EAM+C;;0BAN/C;4BAAMyskB,WAAUC,MAAKC,aAArBl0jB;6EAM+C;0BAN/C;4BAAMg0jB,WAAUC,MAAKC,aAArBl0jB;4BAKI;kDALEg0jB,WAANh0jB;6BAKwB,oBALRi0jB,MAAhBj0jB;6BAKsC,uBALjBk0jB,aAArBl0jB;4BAKsC,UAAlCm0jB,UAAoBC,SAAcC,YACS;0BAN/C;4BAAMC,mBAAUC,cAAKC;4BAArB;8B,OAAAhma;uCAAM8la;uCAAUC;uCAAKC;uCAArBx0jB;;4CAM+C;4BAN/C;;sC,OAAA0uJ;+CAAM4la;+CAAUC;+CAAKC;+CAArBx0jB;uDAM+C;;0BAN/C;;;;;;;;;0CAM+C;0BAN/C;;;4BAKc,GALd8uJ,gBAKc;6CALd8la;4BAKc;8BAAmB,mBALjCC;8BAKiC;uCAAiB,WALlDC;uCAKiCvrgB;4BAAnB,QAAQ;0BALtB;;;;;;;;;;;;;;;;;;;;;sC6BufA;wC7BvfA;;;;;;;;;gGAM+C;mDAN/CstE;;;;;;;2CAKwB;qEALxBF;;6CAKwB;;gEALxBs9b,MAKwBl+Y;;;0CAAc;oEALtCp/C;;4CAKsC;;iEALtCu9b,aAKsCl+Y;;;yCAAlC;mEALJr/C;;2CAKI;;gEALJq9b,WAKI99Y;;wCALJ;;;;;;;;;qCAKI6+Y;+BALJ,MAKwBC;+BALxB,MAKsCC;;;;iCAAdE;iCAApBC;wDAAoBD,aAAcD;8BALtC;;;;iDAKIH;;kDAAoBC;qDAAcC,oCACS;0BAN/C;;;;;6BAKsC,eALtCf,aAKsCG;;6BAAd,iBALxBJ,MAKwBG;iEAAct8b;6BAAlC,iBALJk8b,WAKIG;iEAAoBp8b;4BAApB,iBAC2C;0BAN/C;;;;;;;4BAKc,GALd+3B,gBAKc;iDALd8ka;4BAKc;8BAAmB,qBALjCC;8BAKiC,2BALjCC;8BAKiC;;;wCAAX;0BALtB;;;;;;;;;;;;mCAAiCp3W;4B,UAAjCI,iBAAiC0qB,gCAMc;0BAN/C;4BAAM+qV,gBAAUC,WAAKC;4BAArB;;;;qEAAMF,gBAANvhhB;0EAAgBwhhB,WAAhBvhhB;;kEAAqBwhhB,kBAArBxkQ,IAM+C;0BAN/C;4BAAMykQ,cAAUC,SAAKC,gBAArB5zjB;;;;;8CAAM0zjB,cAAN1zjB;8CAAgB2zjB,SAAhB3zjB;8CAAqB4zjB,gBAArB5zjB,aAM+C;0BAN/C;4BAAM6zjB,mBAAUC,cAAKC;4BAArB;;qCAAqBA;+BAArB,MAAgBD;+BAAhB,MAAMD;8BAAN;gC,OAAA5oE,+CAM+C;4BAN/C;;;+CAAM4oE;+CAAUC;+CAAKC;+CAArBxskB,EAM+C;;0BAN/C;4BAAMyskB,WAAUC,MAAKC,aAArBl0jB;6EAM+C;0BAN/C;4BAAMg0jB,WAAUC,MAAKC,aAArBl0jB;4BAKI;kDALEg0jB,WAANh0jB;6BAKwB,oBALRi0jB,MAAhBj0jB;6BAKsC,uBALjBk0jB,aAArBl0jB;4BAKsC,UAAlCm0jB,UAAoBC,SAAcC,YACS;0BAN/C;4BAAMC,mBAAUC,cAAKC;4BAArB;8B,OAAAtpE;uCAAMopE;uCAAUC;uCAAKC;uCAArBx0jB;;4CAM+C;4BAN/C;;sC,OAAAm4f;+CAAMm8D;+CAAUC;+CAAKC;+CAArBx0jB;uDAM+C;;0BAN/C;;;;;;;;;0CAM+C;0BAN/C;;;;;;;;;;;;2C7I2IRijK;;4C6I3IyCy6C;;;0BAAjC;4B,UAAAuiT,iDAM+C;0BAN/C;4BAAMszD,gBAAUC,WAAKC;4BAArB;;;qEmBmFA9yZ,cnBnFA3uH;;;;;uCAAMuhhB,gBAAUC,WAAKC,kBAArBxhhB,IAM+C;0BAN/C;4BAAMyhhB,cAAUC,SAAKC,gBAArB5zjB;;;;8CmBmFA4gK,enBnFA5gK;;qCAAM0zjB,cAAUC,SAAKC,gBAArB5zjB,aAM+C;0BAN/C;4BAAM6zjB,mBAAUC,cAAKC;4BAArB;;qCAAqBA;+BAArB,MAAgBD;+BAAhB,MAAMD;8BAAN;gC,OAAA51W,oDAM+C;4BAN/C;;;+CAAM41W;+CAAUC;+CAAKC;+CAArBxskB,EAM+C;;0BAN/C;4BAAMyskB,WAAUC,MAAKC,aAArBl0jB;6EAM+C;0BAN/C;4BAAMg0jB,WAAUC,MAAKC,aAArBl0jB;;kDmBmFA6gK,cnBnFA7gK;;6CAAMg0jB,WAAUC,MAAKC,aAArBl0jB;oDAM+C;0BAN/C;4BAAMs0jB,mBAAUC,cAAKC;4BAArB;8B,OAAAr2W;uCAAMm2W;uCAAUC;uCAAKC;uCAArBx0jB;;4CAM+C;4BAN/C;;sC,OAAAo+M;+CAAMk2W;+CAAUC;+CAAKC;+CAArBx0jB;uDAM+C;;0BAN/C;;;;;;;;;;;;0CAM+C;0BAN/C,iCAM+C;0BAN/C;;;;;;;4BAM+C,OAN/CzX,CAM+C;0BAN/C;;;;;;;4BAM+C,OAN/CA,CAM+C;0BAN/C;;;8B,OAAAmnK;;;;sC,OAAAD;0CAM+C;0BAN/C;wEAM+C;0BAN/C;4B,OAAAwuD,8CAM+C;0BAN/C;;;8B,OAAA1uD;;;;sC,OAAAD;0CAM+C;0BAN/C;;;;wFAM+C;0BAN/C;;;6BAAiCouD;6BAAjCstS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAAiCl9V;6BAAjCO;;;;;;;;;;;;;;;;;;8BAKsC;6DALtCila;+BAKwB,gCALxBD;+BAKI;uDALJD;8BAKI,oBALJvkQ,SAM+C;0BAN/C;;8B;oCAAAvkQ;;;;;;;;;yCAKwBsqE,KALxBC;yCAKwB7vI;yCALxB,mCAKwBA,GALxBsqI;8CAKwBsF;yCALxB/sH;;;uCAKsCknT,KALtCl6L;uCAKsCpiF;uCALtC,+CAKsCA;uCALtCoiF,KAKsCk6L;uCALtClnT;;;qCAKImnT,KALJn6L;qCAKI78C;qCALJ,mCAKIA,KALJq3C;0CAKI2/L;qCALJnnT;;;;;;;;;kHAM+C;8BAN/C,YAM+C;0BAN/C;;4BAKc,GALdipJ,gBAKc;6CALd8ja;4BAKc;8BAAmB,mBALjCC;8BAKiC;uCAAiB,WALlDC;uCAKiCvrgB;4BAAnB,QAAQ;0BALtB;;;;;;;;;;;;;;;;;;;;;sC6BufA;wC7BvfA;;;;;;;;;gGAM+C;mDAN/CstE;;;;;;;2CAKwB;qEALxBF;;6CAKwB;;gEALxBs9b,MAKwBl+Y;;;0CAAc;oEALtCp/C;;4CAKsC;;iEALtCu9b,aAKsCl+Y;;;yCAAlC;mEALJr/C;;2CAKI;;gEALJq9b,WAKI99Y;;wCALJ;;;;;;;;;qCAKI6+Y;+BALJ,MAKwBC;+BALxB,MAKsCC;;;;iCAAdE;iCAApBC;wDAAoBD,aAAcD;8BALtC;;;;iDAKIH;;kDAAoBC;qDAAcC,oCACS;0BAN/C;;;;;6BAKsC,eALtCf,aAKsCG;;6BAAd,iBALxBJ,MAKwBG;iEAAct8b;6BAAlC,iBALJk8b,WAKIG;iEAAoBp8b;4BAApB,iBAC2C;0BAN/C;;;;;;;;4BAKc,GALdm6B,gBAKc;iDALd0ia;4BAKc;8BAAmB,qBALjCC;8BAKiC,2BALjCC;8BAKiC;;;wCAAX;0BALtB;;;;;;;;;;;;mCAyBF32O,YACEn5V;2CAEEA,6BAAqB;4BAFvB,eACEA,yBAAsB;4BADxB,eAAEA;8BD8MG,eAAqBA;gCA9E5B,SA8E4BA;kCA9E5B;wCA8E4BA;mCPrP5BknO,mBA0BoC,0BO6IpC4iG;mCPvKA9a;gDA0BC,W2gB6DDwzM,apgBgFA14L,UPvKA5iG;;gCOuKA;wCA8E4BlnO;iCHtP9B6pU,qBACqC,WugBuFnC24L,apgBgFAv9H;;;;;kFHxKFp7D,mBGsP8C;8BAA9C;;kDA9NI7pU;;+DAwCE,uBAxCFA;iEAuCE,uBAvCFA;iEAsCE,uBAtCFA;;yDAqCE,WogB2BJwigB,apgBhEExigB;;yDAoCE,0BApCFA;wEA8NwB;;uCC9MtBA,EAAmB;4BADvB;iFACEA,EAGgB;0BA7BhB,SAyBF24G,SACE34G;2CAEEA,6BAAqB;4BAFvB,eACEA,yBAAsB;4BADxB,eAAEA;8BD8MG,eAAqBmzF;gC,UAAAA;;;;;;;;;;4CA5E1B;;;4DAFF22O,MAEE,aAFFA,MAEoD;sDAFpDg7D;;;;;;;;;;;;;;;;;oDHvKA;8DADFG;sDACE,SADFA,UACE34B;;;;;4DAAmC;6DAAfD,KAApBC;6DAAoBt5Q;6DAAe,mBugByFnCyva,avgBzFoBzva;6DAApBs5Q,KAAoBD;6DAApB1vT;;;;;;;;2FADFmtR,MACE,aADFA,MACwE;;;;;4CiCogBpE;mD+Q7gBJ1kH;;;;0C7SiLI;;;0DADF0kH,MACE,aADFA,MAC0C;;mDAD1C66D;;;4CPvKA,OOuKAA,UPvKA90P;;;;;;;mDAI+Bk6L,KAJ/Bl6L;mDAI+BpiF;mDAJ/B7Q,gBA0BoC,0BAtBL6Q;mDAJ/BoiF,KAI+Bk6L;mDAJ/BlnT;;;;mDAII+sH,KAJJC;mDAII7vI;mDAJJ46C,WA0BC,W2gB+DD6nd,a3gBrFIzigB,GAJJqqI;wDAIIuF;mDAJJ/sH;;;;;;;;;;0GAKsD;;;iDoTdxDuiM;gC7SgLE,YA8E4C;8BAA9C;2DAAUplN,uBAAkB,SC9MtBA,EAAmB;4BADvB;iFACEA,EAGgB;0BAJlB;;;;;;;;;sED+MGirkB;kCT5OAhrB;;2BU6BE51Y,iBAALlB;;4B;mDD+MF+ha,oBT5OAhrB,cU6BE39iB;;4B;;qDD+MF4okB,qBT5OAhrB;qCU6BEnliB;;uCAKwC;8BALxCwwJ;kDAIExwJ;4B;;qDD2MJowjB,qBT5OAhrB;qCUiCIpliB;;;mCAJFuqiB;4B;;qDD+MF6lB,qBT5OAhrB;qCU6BEpliB;6CAKwC;;2BALxC2wJ;sCAAKtB,cAALmB;;;;4BAIE,eADEosM;6DAAqB;4BACvB,eAFEF,4CAAsB;4BAExB,eAHEppM;8BD8M0C,eAAlB46M;gCA9E5B,GA8E4BA,gBA9E5B;yCA8E4BA;;;oCA7Eb,IAAbvN,MA6E0BwN;oCPjPV,aOoKhBxN,MPpKgB;oCOoKH,IPpKG94W,EAsBjB,uBO8IC84W;iDPpKgB94W;6CAsBkB,oCO8IlC84W;6CPpKgB94W;kCOoKhB;0CA6E0BqmX;kDA7E1B;gCACsB,IAAtBrN,MA4E0BsN;gCHtP9B,iBG0KItN,QH1KJ,uBG0KIA,SA4E0C;8BAAE;gDAAtCmN;yCAvNI,GAuNJA,gBAvNI;yCA6BR,IA7BQl7Q,IA6BR,2BA0LIk7Q;kDAvNIl7Q;2CA8BR,IA7BiBrpC,IA6BjB,cAyLIukT;oDAtNavkT;6CA8BjB,IA7BUF,IA6BV,wBAwLIykT;sDArNMzkT;+CA8BV,IA7BgB1hE,EA6BhB,wBAuLImmX;4DApNYnmX,EA8BhB,wBAsLImmX,mBApNYnmX;6CADN;2CADO;yCADT,UAuNc;;uCC9MtByrK;6CAAmB;4BAGrB;sEAJFqsD,YAIkB;mCAJlB9jH;4B;oDD+MFw0d,clCrCF7mE,cyBvME67C,cU6BE98iB;;4B;oDD+MF+nkB,clCrCF/mE,cyBvME+7C,cU6BE/9iB;;4B;;qCD+MFgpkB;qClCzFEpnE;qCyBnJFq8C;qCU6BEr7b;;mCAOIikG,iBAPJ,YAKwC;mCAMtC6qV;4B,IAXF9ub,IwFiIAzH;;qCxFjIA66G,kBAWEv4N,GAA6C;mCAE7CwpF,0BAA6C;;;;6BAb/CqgB;;;;6BAWEoqc;6BAXFpqc;;;;6BAaErgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAMEgnf,8BAA6C55e;4B,IAAlB4sJ;4BD4PnC,GC5PqD5sJ;8BDkQjD;8CACmC65e,SAAW,UAAXA,kBAAmC;+BAAnE,gBAAW,SCnQiBjtV;8BDkQ9B,uBClQ8BA;4BD8P/B,eAEUitV,SAAW,UAAXA,kBAA+B;4BADxB,sBC/PcjtV;4BD+P3B,2BC/P2BA;mCAG3BktV,oBAAqBntkB;4BACvB,sBACK,IAAMktkB,iBAAN,OAAMA,OAA6B;4BAD/B,sCADcltkB,WAEiB;0BAxB1C;wCAAK8mK;0BAAL;+DAAKA;2BAAL07V;;;;;;;;;;;;;6C7IkHN9nV,2B6IlHM8nV;;;;;;;qEmB0DEpqV,cnB1DF3uH;iFAKwC;mCALxC+jhB;;;;8CmB0DEn1Z,enB1DF5gK;gEAKwC;;2BALxCg2jB;;;6EAKwC;mCALxCE;;kDmB0DEr1Z,cnB1DF7gK;;oDAKwC;;2BALxCm2jB;;;;;;;6DAKwC;mCALxC1la;;;;;;;4BAKwC,OALxCloK,CAKwC;mCALxCmoK;;;;;;;4BAKwC,OALxCnoK,CAKwC;8BALxCwpK;;mEAKwC;mCALxCxB;4EAKwC;;2BALxCoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAAKtC;6BAALgpW;;;;;;;;;;;6BAOIjqT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAYAonX;6BAGAE;;mCAQJ52O,YACE95V;2CAEEA,6BAAqB;4BAFvB,eACEA,yBAAsB;4BADxB,eAAEA;8BDyLG,eAAqBA;gCA5E5B,SA4E4BA;kCA5E5B;wCA4E4BA;mCA5E5B;mCP9IA;6CAAEA,qB2gBmDFwigB,a3gBnDExigB,EAAiC;mCAzBnCknO,mBA2BE,0BO4IF4iG;mCPvKA9a,qBA0BE,aO6IF8a,UPvKA5iG;mCAEI,qCOqKJ4iG,UPvKA9a;mCACI,qCOsKJ8a,UPvKAD;;;;gCOuKA;wCA4E4B7pU;iCHrP9BkpW,qBAGuB,WugB2ErBs5J,apgB2FAv9H;iCHzKF97B;8CAEoB,WugB4ElBq5J,apgB2FAv9H,YHzKF/7B;;;;;qGGqP8C;8BAA9C;;kDApNIlpW;;+DAqCE,uBArCFA;iEAoCE,uBApCFA;iEAmCE,uBAnCFA;;yDAiCE,WogBYJwigB,apgB7CExigB;iEAkCE,aAlCFA;;yDAgCE,0BAhCFA;wEAoNwB;;uCCzLtBA,EAAmB;4BADvB;iFACEA,EAGgB;mCAJlB44G,SACE54G;2CAEEA,6BAAqB;4BAFvB,eACEA,yBAAsB;4BADxB,eAAEA;8BDyLG,eAAqBwuG;gC,UAAAA;;;;;;;;;;4CA1E1B;;;4DAFFs7N,MAEE,aAFFA,MAEoD;sDAFpD66D;;;;;;;;;;;;;;;;;oDHxKA;8DADFM;sDACE,SADFA,UACE74B;;;;;;;6DACMO,KADNP;6DACM/9P;6DADN9xD,WACkB,WugB8ElBkmd,avgB9EMp0Z,KAFR22R;6DACE54B,KACMO;6DADNlwT;;;;6DAEMmwT,KAFNR;6DAEMj+P;6DAFN3xD,WADFsoV,OAGuB,WugB6ErB29H,avgB7EMt0Z;6DAFNi+P,KAEMQ;6DAFNnwT;;;;;;;;;8DADFuoV;;gEACE;yEADFF,sBACE,aADFh7D,WAIO;;;;;4CiCufH;mD+Q7gBJ1kH;;;;0C7S4LI;;0DADF0kH,MACE,aADFA,MAC0C;2CP/I1C;qDAAE9pU,qB2gBqDFyigB,a3gBrDEzigB,EAAiC;;;mDO8InCurY;;;gDPvKAjmU,GOuKAimU,UPvKA17P;;;;;;;;;;;mDAIIy8N,KAJJz8N;mDAII18C;mDAJJz2C,0BA2BE,0BAvBEy2C;mDAJJ08C,KAIIy8N;mDAJJzpV;;;;mDAEImnT,KAFJn6L;mDAEI78C;mDAFJ,gCAEIA,KAFJs3C;wDAEI0/L;mDAFJnnT;;;;mDACIknT,KADJl6L;mDACIpiF;mDADJ,2BACIA,KADJ48E;wDACI0/L;mDADJlnT;;;;mDAGI+sH,KAHJC;mDAGI7vI;mDAHJ46C,qBA0BE,WAvBE56C,GAHJksW;wDAGIt8N;mDAHJ/sH;;;;;;;;;;;;;;;;0IAMsD;;;iDoT1BxDuiM;gC7S2LE,YA4E4C;8BAA9C;;kDAAUpgJ;2C,UAAAA;iDApNNM,GAoNMN,SApNN6qE;;;;;;;;;;;;;;;;;;4DAKID,KALJC;4DAKI7vI;4DALJ46C;oFAoCE,uBA/BE56C,GALJgsW;iEAKIp8N;4DALJ/sH;;;0DAIIknT,KAJJl6L;0DAIIpiF;0DAJJ7Q;6EAmCE,uBA/BE6Q,KAJJw+S;+DAIIliC;0DAJJlnT;;;wDAMImnT,KANJn6L;wDAMI78C;wDANJr2C;qFAqCE,uBA/BEq2C;wDANJ68C,KAMIm6L;wDANJnnT;;;sDAEIypV,KAFJz8N;sDAEI18C;sDAFJz2C,gBAkCE,WAhCEy2C,KAFJm3C;2DAEIgiO;sDAFJzpV;;;oDAGIwpV,KAHJx8N;oDAGI1hC;oDAHJ1xD;kEAiCE,WogBcJgmd,apgB5CMt0Z,KAHJ+9P;yDAGIG;oDAHJxpV;;;kDACIupV,KADJv8N;kDACIxhC;kDADJ7xD;sDAgCE,0BA/BE6xD,KADJg8B;uDACI+hO;kDADJvpV;;;;;;;;;;;;;;;;;;;0KAQsD;2CARtD,YAoNwB;;uCCzLtB7iB,EAAmB;4BADvB;iFACEA,EAGgB;0BAJlB;;;;;;;;;sED0LG0rkB;kCTrPAzrB;;2BU2DE50Y,iBAALiB;;4B;mDD0LFq/Z,oBTrPAzrB,cU2DE39iB;;4B;;qDD0LFqpkB,qBTrPAzrB;qCU2DEnliB;;uCAKwC;8BALxCgzJ;kDAIEhzJ;4B;;qDDsLJ6wjB,qBTrPAzrB;qCU+DIpliB;;;mCAJFu2jB;4B;;qDD0LF1F,qBTrPAzrB;qCU2DEpliB;6CAKwC;;2BALxCmzJ;sCAAK9C,cAAL2C;;;;4BAIE,eADEm3L;6DAAqB;4BACvB,eAFEH,4CAAsB;4BAExB,eAHEP;8BDyL0C,eAAlBytB;gCA5E5B,GA4E4BA,gBA5E5B;yCA4E4BA;;;oCA3Eb;2CA2EaC;qCPvN5B;+CAHEna,8CAAiC;oCAxBnB,aOuKduE,MPvKc;oCOuKD,IPvKC15W,0BOuKd05W;oCPvKc;sCACE,gCOsKhBA;sCPtKgB;wCAwBhB,IAvBa93S,IAuBb,WkmB/BJugf,qB3lB6KIzoM;qDPrKa93S;iDAwBb,oCO6IA83S;iDPrKa93S;sCADG;oCADF;kCOuKd;0CA2E0BytT;kDA3E1B;gCACsB,IAAtBu/M,MA0E0Bt/M;gCHrP9B,aG2KIs/M,MH3KJ;gCG2K0B,IHzKN3je,2BGyKhB2je;gCHzKgB,iBACG,uBGwKnBA,UHzKgB3je,GGmP0B;8BAAE;gDAAtCkkR;yCAnNI,GAmNJA,gBAnNI;yCA+BR,IA/BQjkR,IA+BR,2BAoLIikR;kDAnNIjkR;2CAiCR,IAhCctpC,IAgCd,W2lBtENugf,Y3lBwPUhzL;oDAlNUvtT;6CA+Bd,IA9BiBqpC,IA8BjB,cAmLIkkR;sDAjNalkR;+CAgCjB,IA/BUvpC,IA+BV,wBAiLIytT;wDAhNMztT;iDAgCV,IA/BgB1hE,EA+BhB,wBAgLImvX;8DA/MYnvX,EAgChB,wBA+KImvX,mBA/MYnvX;+CADN;6CADO;2CADH;yCADN,UAmNc;;uCCzLtB4hW;6CAAmB;4BAGrB;sEAJFH,YAIkB;mCAJlBsjC;4B;oDD0LFkkM,clC9CFtnE,cyBvME67C,cU2DE98iB;;4B;oDD0LFwokB,clC9CFxnE,cyBvME+7C,cU2DE/9iB;;4B;;qCD0LFypkB;qClClGE7nE;qCyBnJFq8C;qCU2DEr7b;;;4B,IAAAA,IwFmGAzH;;qCxFnGA48G,qBAKwC;mCAEpCyvK;4BAGE;6BAH4B84K;6BAAR6uB;6BAATluV;6BAGX;gEAHWA;6BAGX;;+BAHWA;;;+BAETy/U;+BAFSz/U;6BAGX,MAHWA;4BAGX;6BAcI;;2CADMmuV;8BAFRpid,QAGM89c;;6BAOJ;;8BJnFiCC,aIkFlBsE;8BATjBrid,WJzEmC+9c;4BI8DrC,IAFAuE,aAKE7L,OAQAz2c;4BAaJ,UA1BEsid,UADoBH,OAAQ7uB;0BAPlC;0CAAKx3Y;0BAAL;;;;;;;;;;kED0LFgha;oClClGE1nE;kCyBnJF28C;;2BU2DOxvC,mBAALlkW;;4B;;qCD0LFk/Z;qClClGEhoE;qCyBnJF28C;qCU2DEl/iB;;4B;;;uCD0LFwqkB;uClClGEhoE;uCyBnJF28C;qCU2DE1miB;;uCAKwC;8BALxCg3jB;kDAIEh3jB;4B;;;uCDsLJuxjB;uClClGE1nE;uCyBnJF28C;qCU+DIxmiB;;;mCAJFk3jB;4B;;;uCD0LF3F;uClClGE1nE;uCyBnJF28C;qCU2DExmiB;6CAKwC;0BALxC;;;+BAAK82f,gBAALkgE;;;;;;;;;6C7IoFN/zZ,2B6IpFW6zV;;2BAALsF;;;;;qEmB4BEz7V,cnB5BF3uH;iFAKwC;mCALxCslhB;;;;8CmB4BE12Z,enB5BF5gK;gEAKwC;;2BALxCu3jB;;;6EAKwC;mCALxCE;;kDmB4BE52Z,cnB5BF7gK;;oDAKwC;;2BALxC03jB;;;;;;;6DAKwC;mCALxC9la;;;;;;;4BAKwC,OALxCrpK,CAKwC;mCALxCupK;;;;;;;4BAKwC,OALxCvpK,CAKwC;8BALxC8rK;;mEAKwC;mCALxC3C;4EAKwC;0BALxC;;;;;;6BAAKolW;6BAALggE;;;;;;;;;;;;;;;;;;;;;;;;+DAAKzma;2BAAL6qW;;;;;;;;;;;;;6C7IoFNj4V,2B6IpFMi4V;;;;;;;qEmB4BEv6V,cnB5BF3uH;iFAKwC;mCALxCgmhB;;;;8CmB4BEp3Z,enB5BF5gK;gEAKwC;;2BALxCi4jB;;;6EAKwC;mCALxCE;;kDmB4BEt3Z,cnB5BF7gK;;oDAKwC;;2BALxCo4jB;;;;;;;6DAKwC;mCALxCnla;;;;;;;4BAKwC,OALxC1qK,CAKwC;mCALxC2qK;;;;;;;4BAKwC,OALxC3qK,CAKwC;8BALxC+vkB;;mEAKwC;mCALxCvla;4EAKwC;;2BALxCwla;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAAKloa;6BAALg6Y;;;;;;;;;;;;;;6BAOIt7K;;;2BAlDQ2I;;;;;;iEAiFb;mCAjFaC;;;;;;;;;;wFAiFb;4BAjFa;;+FAiFb;;;;;sCAjFa33X;;8DAiFb;2BAjFa0+M;;;;;;iEAiFb;;mCAjFaC;;;;;;;;;;wFAiFb;4BAjFa;;+FAiFb;;;;;;6BAjFa+4K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAyFZmwK;4B,IAAiBA;mCAEjBr/T,e,IAAeA;0BAET,SAANu/R,W,OS8CI3/Z,UV8GN6pd,MC9JEzpV;0BAIQ,SAARm/U;4B,OS4CIv/c,UVsHN+pd,QCtKE3pV;0BAIQ,SAERkuV,c,IAASA;0BAFD,SAIR3D,iBAAoB,OsQoyBpBnoB,ctQpyBoC;0BAJ5B,SAMRsd;4B,IAAgB1/U,iBDwJK,OCxJLA;0BANR,SAQRiwV;4B,IAAajwV,wBDwJf0pV,UCxJe1pV;0BARL,SAURkwV;4BDgL+D;6BChLjDlwV;6BDgLiD,YChLjDA;6BDgLiB;4B4lB+KhC;;;wCrV+bCoiU;wCqVlcsBQ;wCrVkctBR;;0BtQxyBQ,SAYRxpd,aDyEgB,OuQmtBhBwpd;0BtQxyBQ,SAcR4nB;4BD4JoB,IC5JLqE,mBD4JK,MC5JLA;4BDiEjB,mBAEI,IADMruV,iBACN,OADMA;4BA0FY,IAxFH6pV;4BACf,OADeA;0BClFT,SAgBRsG;4B,IAAYnwV,wBD4Jd4pV,SC5Jc5pV;0BAEH,SAATjgD;4B,OS0BIngF,UVsINggF,OCtLEogD;0BAwBO,SAAP36N,Y,OSwBIu6F,UV0HN20a,OC1KEv0S;0BA0Bc,SAAdowV;4B,OSsBIxwd,UVwHN6/c,YCxKEz/U;0BA0Bc,SAEdziP;4B,IAAOyiP,iBDsED,aCtECA;0BAFO,SAIdtmC,WAAY35M,GACd,aADcA,sBAKE;0BATA,SAWdkggB,gBAAiBjgR;4BAED,iDAFCA,SAEiC;0BAbpC,SAedqwV,aAAc30E,eAAgB4I,YAC7BtkR;4BAED,0BAFCA;4BAED;+CAHc07Q,eAAgB4I,kBAGL;0BAlBX,SAoBdlpgB,KAAMsggB,eAAgB40E,GAA2BtwV;4BAIrC,uBAJN07Q,eAAgB40E,MAA2BtwV;4BAIrC,UAJqCA,QAA3BswV,YAKvB;0BAzBe,SA6BZC,gBAA6BD,GAC5BtwV;4BACH,UADGA,QAD4BswV,MWkiD7BnyB,cXhiD8D;0BA/BlD,iBA6BZoyB;0BA7BY,SAmCZC;4BAAWp1kB,KAAoDq3J,QAC7D1pH,UAED0niB,UAAUC;4BACb,GAHI3niB,IAAQ,QAARA,aAAQi9B,aAARm5f;4BAGJ;6BAFc,mBAAVwR,QAAUpgf;;iCAAVogf;4BAGU;4DAHVA;6BAGU,QAAVC,YAFDH;6BAEW;6BAMZ,+BANEG,UACAC;6BAKF;;;;+BACExrjB;+BAFAk6f;;+BAHsCqqD;+BAAhCsE;6CAMFnid;gCAKE;wDANN1mG;iCAGF;6CALEk6f,IAMc,WATR2uD,WANN/O,cAYIpzc;gCAEN,kBAfW3wH,KAOH8ykB,OAONluV,QAOgB;8BARL,qBAVF0wV,YAI6B9G;8BAM3B;;;4DAHXtsD,eAEA9qX;iEAZ6DC;6EAqB7C;0BAxDN,SA0DZq+a,yBAA0Bn+a,KAAMwd;4BACO,IqlBvLlC1uK,ErlBuLkC,WADbkxJ;;kCqlBrLdh2J,WAAVD,uBAAUC;gCrlBsLV81J,+BqlBvLGhxJ;8CrlBsL2B0uK,IAC9B1d,QACQ;0BA5DE,SA+DVs+a;4BAAW31kB,KAAoDq3J,QAC9D0sa,MAAQp2hB,IAAiBghiB,WAAY4G,QAASF;4BACjD,GADW1niB,IAAa,QAAbA,kBAAai9B,aAAbgrgB;mCA7BXR;qCA4Bap1kB;qCAAoDq3J;qCAC9D0sa;qCAAqCwR;qCAASF;;uCAE9C,IAAmB7G;uCAAnB,eAEKhqY;yCAKU,wBAPIgqY,UAEdhqY,QAKgD;uCAPrD;;wCAGD,+BALSoxY,WAAiBjH;wCAK1B;wFAIsD;0BAzE5C,SA2EV55Z,IAAMpnI;4B,GAAAA;6BAAY,QAAZA,iBAAYi9B;;iCAAZirgB;4BACR,gBADQA;8BAKJ;;;kC;gEA5DN71kB;8BA4DM;gC,OAjBF21kB;;4BAeE;gD;4BAAA;8B,OAfFA;;0BA/DU,SAkFVG;4BAA8BD;4BAAWt+a;4BAAMwsa;4BAAO6R;4BACrDjH;4BAAY4G;4BAASF;4BACxB;qCAF2C99a;8CAEDF;uCACtC;oDAH4Bw+a;gDAEUx+a;gDAFO0sa;gDAAO6R;gDACrDjH;gDAAY4G;gDAASF,UAGR,EAAE;0BAtFN;;+BA+DVM,YAYA5ga,IAOA+ga;0BAlFU,SA0FVp8W,MAAKriE,QAAS0sa,MAAOwR,QAASF;4BAChC;8BACE,IAAoB3G;8BAIO,kCAJPA,gBAI6C;4BALnE;;mD;qCADOr3a;qCAAS0sa;qCAAOwR;qCAASF;2CAMmC;0BAhGvD,SAkGVU;4BAA8Bx+a,KAAMwsa,MAAOwR,QAASF;4BACtD;qCADgC99a;;uC;gDAR9BmiE,YAQoCqqW,MAAOwR,QAASF,mBACc;0BAnGxD;+CA0FV37W,MAQAq8W;2BAlGU;;;;mCA+GZj8a,SASE76J,OAAS0uC,IAAmBuoiB;4BAChC,GADavoiB;6BAAY,QAAZA,iBAAYi9B;;iCAAZirgB;4BACb,eAESM;8BAGD,GAHCA,iBAGoB;8BAEV,IqlB9PHlykB,ErlBsPgBiykB;8BAQb;gCA2Cf;iCA1CwBE;iCAAjBC;iCA0CP;;oCAnD4BH;oDAmDf,IAAYnS,eAAZ,OAAYA,KAAmB;gCAA5C;yCA1COsS;kDAkDuCE;2CACH;;8DAnDnBH,gBAkDsBG;2CAN/B;gDAGR7vgB,YAALtlE,sBAAKslE;;sDADH;2CAKuC;4CAAzB8vgB;4CAAZC;4CACqB,yBA7DCP,aA2DkBK;4CAEnB;2CACzB,iBArDsBH,gBAkDsBG;;2CAC5BC;2CAAyB;4CAG7B,uBAbZF,eAS4CC;4CAKjB,uBADvBxS;2CACJ,iBAdAuS,eAS4CC;2CAK5C,eACSpyD;6CAUwC;yEAVxCA;8CAUP;+DAAkC,qBAfhCsyD;6CAeF,eAEOjI;+CAQS;uEAxBdkI;gDAyBF;;mDArBOvyD,IAoBHwyD,YAtBF5S,oBAcKyK,SAHLhqY;gDAYF,oBAtFKqxY,UApGb71kB;gDAqMgB,iBAPN+3H,SA7BA2+c,UAuBA9xV;+CAaM,wCAAuB;6CAhB5B;uFqlBvUK3gP;;;;0DrlBoUIub;mDACU;2EA/EE02jB,aA8EZ12jB;oDACU;qEAAd01jB,MAC6B;8FAiBN;2CAzBxB;uEAZLuB;4CAWO;4CAAL;4CADO;4CAAT;4FA2B6B;8BAzFpB;gCAqCgB,IAASG;gCAAT;yCAASA;kDACPruiB;2CACzB;oDADyBA;6DACEkD;sDACC;kFADDA,UACmB,EAAE,EAAI;8BAxC7C,eAGLoriB;gCAGa;0DAHbA;;;;gCAGa,eAEbR;iDAOAD;oCAeT;gEAtBSC,gBAOAD,iBAegC;kCqlBnSlD,SAAQttX,GACHpiJ,GrlBqRgBvnE;oCqlBpRhB,mBrlBoRgBA,EqlB/QD8E;sCALH;sDAAa7C,GAAK,aAALA,EADzBslE,IrlBqRgBvnE,UqlBpRmC;;iDrlBqRhC43kB;0CACc;kEA3BFb,aAyBf/2kB;2CAEiB;6CADd43kB;+CAELC,gBADGvsc;;2CAKA;uEALAA;4CACHusc,gBAGA;0CAIF;mDqlBxLfv7B;mDrlBiLiBu7B;mDAOF,iBArBJF,iBAWQ33kB,UAUe;;;6EWsyC9B00J;;oC0kBnkDW,uBAFZntF,IAEuB;mDAH5B;;;;oCxe+mB+B;;;;;wC7G/VK;;yD;;qC6G+VhB;;;;;kCADV;;mCwellBV,YADUq3C;mCAXV;6CAAW95G;sCACN,mBADMA,EAHWojB;;;mDAKT4vjB;4CACT,KANkB5vjB,IAGXpjB,EAEEgzkB,UACT,UAHOhzkB,UAIG;wCAFU;kFAFbA,EAHWojB;;sCAQf,iBAReA,IAQL;gDALjB;oFrlBmRkD;8BA1BvC;gDqlBnKT+zhB,arlB0JW+6B,WqlBzPOlykB;+BrlBiQZ;;+EAsFqC;4BA7FvC;;qCAJEhF,O9I7HJu1J;4B8IiIE,iDA6FuC;0BAzN3B;;;6BAmCZ4gb;6BAuBAM;;;6BA4CAtU;6BAEA4U;6BAEA3U;6BAEA4U;6BAGAn8a;0BA/GY,SAgOZ2hM,YAASr6V,sCAAW;0BAhOR,SAgOZ64G,SAAS74G,sCAAW;0BAApB;;2BAAKusK,iBAALupa;;;;;;;sCAAKvpa,cAALwpa;;;;;;;wEAA2D;0BAA3D;;;;;0CAAKxpa;0BAAL;;;;;;6BAAKA;6BAALyC;;;;;;;;;;;;;;;;;qFAA2D;0BAA3D,wDAA2D;0BAA3D;;;;;wEAA2D;0BAA3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAgBFona,gBAAgB7ykB,GAClB,oBADkBA,EACuC;0BAjBrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA1SGy/f;6BAALqzE;;;;;;;;;;;;;;;;;;;;;;;;6BAiUE1khB;6BAEAuyY;2BAzBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAmCFwzI,gBAAiBx4E;4BAGjB;6BAHoD2jD;6BAAR6uB;6BAATluV;6BAGnC,sBAHmCA;6BAEnC,iB3EpOAo8L,Y2EkO4C8xJ;4BAE5C;+CAFiBxyE,eAAmC2jD;0BAnClD,SAwCF80B,YAAYp0kB;4BACE,2BADFA,GAEC,qBAFDA;4BAEC,UADX2pkB,aACAE,YACmB;0BA3CnB,SA6CFwK,iBAAiBr0kB;4BACnB,eAAqC2sY,IAClB,0BADkBA,IACQ;4BADhC,6BADM3sY,SAE4B;0BA/C3C,SAiDFs0kB;4BAA+B34E,eAAe2jD,UAAU6uB,OAAOluV;4BACjE,eACSkuV;8BACT;oCAHiEluV,QAExDkuV,OAFuC7uB;+BAIhC,sBAJiB3jD,eAG7B37f;+BACY,YAAqC,iBADjDA;8BACmE,qBADnEA,EACsE;4BAFxD,qBAFwCmukB;4BAExC,iDAEwD;0BArDtE,eAyDKv7a;4BAID,kBAJCA;4BAID,wDAAyD;8BAN/D2hb,iBAGA,qBhC3YFztE;;;;;;;;;;8BgCiZA;;;;;;;;;uCATEytE;gDAS0Cv0kB;yCAAY,qBAAZA;uEAA+B,EAAC;;;;;;;;;;8BAG5E;;;;;;;;;uCAZEu0kB;gDmgB3YuDv0kB;yCngBwZrD;;;0CmgBvZE,uBAAY,oBADuCA;yCACnD;0CAEF,2CAHqDA,EAEpD4V;;0CAGD,iDADI7G;;uEngBoZqE,EAAE;mCAG7E0wB,MAAMz/B;4BAAoB;qDAApBA;6BAAoB,YAAqB,iBAAzCA;4BAA2D,qBAA3DA,EAA8D;mCAGpEw0kB,yBAAyBx0kB;4BAAmB,iCAAnBA,KAAwC;mCAEjEy0kB,aAAaz0kB,GAAI,OAAJA,CAAK;mCAElB00kB,sBAAsBC,cAAcv2E;4BACtC;qCADwBu2E;8CACUC;uCAKvB,2BAN2Bx2E;uCAK9B,sB,OS7RFv+Y;uCT2RA,iCAF4B+0d,oBAMA,EAAE;;;;;;;;;4CAMpC,gCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAvV/Bt1B;kCAEAr/T;kCAEAu/R;kCAEA4/C;kCAEA+O;kCAEA3D;kCAEA7K;kCAEAuQ;kCAEAC;kCAEAt3e;kCAEAoxe;kCAEAmG;kCAEApwY;kCAEA16K;kCAEA+qjB;kCAEA7ykB;kCAEAm8M;kCAOAumT;kCAIAowE;kCAKAj1kB;;;;kCA4NAw3kB;;;;;;kCAmBAsB;kCAKAC;kCAKAC;kCAIAC;kCAMAC;kCAgBA90iB;kCAGA+0iB;kCAEAC;kCAEAC;uBAvcN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;uBAAA;;;;;;;;;;;;;;;;;sBAud6C;sBxJ5cvCvpc;sBADAD;sByJRN;sByS6EoB;uBzS7EpB,8BkB8WUk1T,elBhWF/xY;uBAdR;;;;;;;;;;uBA0BM;;uBAEG;wC,UAFHwmhB;uBAEG,mBAFH5/E;uBAEG,mBADDE,ekB8VEC;uBlB7VD,YADI0/E,gBADPC,gBACEC;uBACC,iBADDv4kB,6BAAsE;uBACrE,gBgjBqGLq4f,YhjBtGIC;uBACC;;;2BgjBqGLF;2BhjBvGEI;;2BACEE;2BkB8VEC;2BlB9VG0/E;2BADPC;2BACEC;;;2BgjBsGJlgF;2BhjBtGIE;;uBACC;uBAFH;uCACO8/E;sBySkDO;uBzShCdM;wBAAQ,iBAA8B;sBA8EzC;sBzJlHGjqc;sBADAD;sByvBVN;sBvT+EoB;uBuT/EpB;;;;;;;;;;;sBAA4C;sBzvBWtCC;sBADAD;sB0JVN;sBwS+EoB;uBxS/EpB;0CAMMu1T,eAFAnyY;uBAJN;;;sBASY,2BwBkvCF+mc;sBgR5qCU;uBxS7DhB;;uBAEG;wC,UAFHggF;uBAEG,mBDQDpgF;uBCRC,mBDSCE,ekB8VEC;uBjBvWH,YADIkgF,gBADPC,gBACEC;uBACC,iBADD/4kB,6BAAsE;sBACrE,U+iB+GHq4f,YhjBtGIC;sBCTD;;yB+iB+GHF;yBhjBvGEI;;yBACEE;yBkB8VEC;yBjBxWCkgF;yBADPC;yBACEC;;yBDUEzgF;yBgjBsGJD;yBhjBtGIE;yBCVF0gF;sBwS4Dc,IxS7DhBC;uCACOL;sBAc+C;sB1JtBpDnqc;sBADAD;sB0vBTN;sBxT8EoB;uBwTtEd;;;;;;;;;uC/uB0JN0wC,mB+IhJW05Z;0ClBWAnrC;;uBknBrBL;uBAImC;wC,UAJnCyrC;;uCAAKC;sBxTsES,IwTtEd;sBA8BA;;;;;;0C,OpnBhCYtzC;4BonBEPszC;;sBAoDR;sB1vBlDG1qc;sBADAD;sB2JVN;sBuS+EoB;;uBvS/Dd;;;;;;;;;;iCAAQvuI,G,UAARo5kB,mBAAQp5kB,KAC8C;uBADtD;;0BAyBJ;oCAAuBqoH,WAAi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hOAy9e,eIgOAz9e;kClJzFNqkK,mB4I9GoBwiV,iBMuMd7mf;6CJhOAy9e,eIgOAz9e;2BhBxNF;;;;0BAjBE,GgByOAs0V;2BhBzOA;+BgByOAA;4BhBzOAK,GgByOAL;4BhBzOArlC,GgByOAqlC;4BhBzOAriT,GgByOAqiT;4BhBzOAtiT,GgByOAsiT;4BhBzOA,uBgByOAt0V,IhBxNFwjC;4BAjBE,uBgByOAxjC,IhBzOAC;mDgByOAD,IhBzOAi6B;mDgByOAj6B,IhBzOAk8B;mDgByOAl8B,IhBzOAs+B;4BgByOAiF,OhBzOA,iBgByOAvjC,IhBzOAqgC;;+BgByOAkD,OhBzOA,mBgByOAvjC,IhBxNFwjC;0BgBwNE;iClJzFN6gI,mBiJ+CIgja,eC0CErnkB,eAa+C;;iCAb/CA;2EAa+C;;iCAb/CA;0BACI;sDADJA;2BAEI,sBqlBvPNipiB,erlBqPEjpiB;2BAGI,gCAHJA;2BAII,oCAJJA;2BAKI,+BALJA;2BAMI,gCJrOF09e,eI+NF19e;2BAOIyskB,WlJhGVnoa,kB4I9GoB0iV,cMuMdhnf;2BAQI,wBJvOF09e,eI+NF19e;2BhBxNF;;;;2BAjBE,wBgByOAA;0BhBzOA;+BgBkPI2skB;;;4BhB/OI;wEgBsOR3skB;6BhBrOQ,8BgBqORA;6BhBpOQ,gCgBoORA;6BhBnOQ,kCgBmORA;6BhBlOQ,qCgBkORA;6BASI2skB;;+BhB/OIC;+BACAC;+BACAC;+BACAC;+BACAC;;gCgB2OJL,ShBlPJ,uBgByOAxpc;0BACI;2BASA,6BAVJnjI;2BAWIktkB,QlJpGV5oa,kBiJ+CIgja,eC0CEtnkB;;kCACIgvf;kCACA49D;kCACA0f;kCACAC;kCACAzjB;kCACA0jB;kCACAC;kCACAC;kCACAC;kCACAM;kCACAC,QAE2C;uBAb/C;uCAAKjB;sBqS7KS;uBrS6Kd,yBACiB,YAAiC;uBADlD;iCA2BFx5hB;;0BAWY;;;6BD/EV;uCAGEztD,4CAAa;6BAlCfsqW,sBA9CW,UC4JDt3Q;6BD9GVu3Q,mCC8GUv3Q,SD9GVs3Q;;0CAmCE,uBC2EQt3Q,SD9GVu3Q;mCC8GUv3Q;6BD9GVy3Q;;;;sDk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icCzrd,gBzE3hBH87S;uByEwjBFi2K;;;;;;;;;;;;kCACI/xd;;mCACAs5b;;oCACA6iB;;qCACAD;wCACA1ikB,SACAw+jB,gBACAF,gBACAuX,gBAEc;uBAVlB2C;;;;;;;;;;;;;;;;;;;kCACIhyd;kCACAs5b;kCACA6iB;kCACAD;kCACA1ikB;kCACAw+jB;kCACAF;kCACAuX,OAEc;6BA3bRzD;6BN0DAxZ,gBnBxLH/tC;6BmBwLG+tC,gBnBxLH/tC;6BmBwLG+tC,gBIxMH8T;6BE8IG0F;;6BN0DAxZ,gBmQXH1yB;;wC,OhQnMwB8kC;uBGuwB3B;;;;;;;;+B,ODnwBGiC;;;uBCmwBH;uBAS+C;wC,UAT/CwL;uBAS+C;iCAT/C/4lB;0BDxwBF;8BCwwBEA;2BDxwBF,GCwwBEA;2BDxwBF,GCwwBEA;2BDxwBF,KCwwBEA;2BDxwBF,KCwwBEA;2BHvwBF,GEDA+8G;2BFCA,GEDAA;;;2BFCA;oDH8MAo8d,cF1LAljF,cKpBAxrc;2BEDA;;;;oDFCAhoD,KGoJAkwlB,oBHpJAjoiB;2BEDA;;gDL+MAyuhB,cF1LAljF,cOrBAx+W;;;gDL+MA0hc,cF1LAljF,cOrBAvuL;;;gDL+MAyxQ,cF1LAljF,cOrBA7oJ;8DCqJAulP,oBDrJAxlP;uBCixBiD;iCHhxBjD10V,QGuwBEzY;0BDxwBF;8BCwwBEA;2BDxwBF,GCwwBEA;2BDxwBF,GCwwBEA;2BDxwBF,KCwwBEA;2BDxwBF,KCwwBEA;2BHvwBF,GEDA+8G;2BFCA,GEDAA;2BCwwBE;;2BHvwBF/jE,MH8MAogiB,eF1LAljF,eKpBAz9e;2BEDAqgC,MCqJA85iB,qBHpJAn6kB;2BEDAs+B,ML+MAqiiB,eF1LAljF,eKpBAz9e,IEDAqgC;iCL+MAsgiB,eF1LAljF,eKpBAz9e,IEDAs+B;iCL+MAqiiB,eF1LAljF,eKpBAz9e,IEDAk8B;iCCqJAi+iB,qBHpJAn6kB,IEDAi6B,SCixBiD;;iCHhxBjDj6B;0BGuwBE;;;2BHnwBEsrhB,OH0MJs1C,eFzLEljF,eKrBF19e;2BAIyBozkB,iBGgJzBgH,qBHpJAp6kB;2BEWIs2kB,YFPAhrD,OAAqB8nD;2BEQrBiD,OLkMJzV,eFzLEljF,eKrBF19e;2BEaIo2kB;4BLiMJxV,eFzLEljF,eKrBF19e;2BEgBIm2kB,kBL8LJvV,eFzLEljF,eKrBF19e;2BEiBIk2kB,eCmIJkE,qBHpJAp6kB;;kCEWIs2kB;kCACAD;kCACAD;kCAGAD;kCACAD,eC+vB6C;;iCAT/C3tlB;0B;0BAOI,sB,OA1nBN8xlB;0BAynBM;4B,ON/jBNxZ,cFzLEvjF;0BQuvBI;4B,ON9jBNujF,cFzLEvjF;0BQsvBI;4B,ON7jBNujF,cFzLEvjF;0BQsvBI;0BAFE,sB,OArnBR+8F;0BAonBQ;4B,ON1jBRxZ,cFzLEvjF;0BQmvBI;mD,OHxwBNy1F;;;;;mCGuwBExqlB;uBAS+C;iCAT/ChB;0B;uDAnnBFmzlB;;4B,ON0DA5Z,cFzLEvjF;;4B,OEyLFujF,cFzLEvjF;;4B,OEyLFujF,cFzLEvjF;;gD,OQ+HFm9F;;4B,ON0DA5Z,cFzLEvjF;iCOtBF04F;mD,OFCA9C;;;;;mCGuwBE5rlB;uBAS+C;iCARzC4iH,IADNj/G;;;2BAEM6yW,MN3jBRijO,qBM0jBQ72d;2BAGF2zP,MAvnBN68O,+BAqnBQ58O;2BAGFF,MN9jBNmjO,qBM6jBMljO,MAJJ5yW;2BAMI0yW,MN/jBNojO,qBM8jBMnjO,MALJ3yW;2BAOIqnK,MNhkBNyua,qBM+jBMpjO,MANJ1yW;iCAnnBFyvlB,4BA0nBMpob,MAPJrnK;uBAS+C;iCAT/CguX;0BAQE,eADEumG;4BAAmB;8CAAnBvF;kFAAkB;qCAAlBuF;2CAAsC;0BACxC,eAFEshI;4BAAuB;8CAAvBE,iDAAsB;qCAAtBF;2CAAuC;0BAEzC,eAHE5gI;4BAAuB;8CAAvBghI,iDAAsB;qCAAtBhhI;2CAAuC;0BAGzC,eAJE1G;4BAAuB;8CAAvB4nI,iDAAsB;qCAAtB5nI;2CAAuC;0BAIzC;4CAPEN;qCAEA,eADEE;uCAA4B;yDAA5BE;gGAA2B;gDAA3BF;sDAA+C;qCACjD;uDAFEkoI;gDAA+B;kEAA/BE,iDAA8B;yDAA9BF;+DAA+C;;8CAAjDpoI;oDAE6B;;;;;mCAHjCjgG;yCAQkB;uBARlB;uCAAKqnO;sBiShsBO;uBjS+sBZqB;iCAAQl0lB;0BACV,SACIqgjB,OAAOrgjB;4BACT;qCAAIw2D;8B;;;;gEHzxBNqvhB;4BG8xBoB;4CA7mBlB8H;6BA6mBkB;6BAFlB;;gCACQ,yB,ONrjBV9Z;;gCMgjBW7zkB;4BAIT;2DH5xBF8llB,0BGgyB6D;0BAT7D;mCAWItvhB;4B;;;;8DDnyBJ2yhB;0BCwyBgB;0CApnBdyE;2BAonBc;2BADG;qD,ON9jBnB/Z;2BM8jBmB;2BADC;qD,ON7jBpBA;2BM6jBoB;2BADZ;qD,ON5jBRA;2BM2jBA;2CAAqC,SAXjCxzB,gCAFMrgjB;0BAaV;yDDpyBAoplB,2BC0yB8C;;;;;;;;;;0BAG9C;;;oCAAI9ulB,QAEA9C,OAFA8C;2BAiBO,gBAAQ;2BACM,iCADrB6miB,KACOzje;2BAAa,8BADpByje;2BACoB;;2BAAbx0f;;2DAAC;;mCAAD4d;mCA4ET2oiB;mCA5ES/0e;;;;;sCAA8D;sBiSvvB3D;;iCjS2vBLkic;yCAKAtgjB;2CACAunlB;6CACAC;gCACT;+CAEQ+B;kCAOR;0CAjBSjpC;0CAKAtgjB;0CACAunlB;0CACAC;0CAGD+B,aAO8D;gCAH/D,2BALH+K;gCAEF;;2CACE,iBACG,iBALHC;;+CASkE;8BAV3C;4BADC;0BADZ;;iCAJLxzgB;yCACDklgB;4BACR,UAFSllgB,KACDklgB,eACkC;0BADjB;uBAJzBuO,uBAGgB;uBAkBhBC;;0BAeW;2BAVRlL;2BADA/B;2BADAD;2BADAvnlB;;2BADiBimlB;2BAANllgB;2BAcH,qBAvxBXqrgB,UA6wBG7C;2BASK,qBAxgBRzhD,WA8fG0/C;2BASK,qBAvgBR1/C,WA6fGy/C;2BASK,qBAnfRuH,aAyeG9ulB;2BASQ,qBAtwBX86L,SA4vBoBmrZ;0BASZ;kDA7gBR2I,mBAogBc7tgB,azEz0BhB27V;uByEq2BIg4K;;0BAeW;2BAVRnL;2BADA/B;2BADAD;2BADAvnlB;;2BADiBimlB;2BAANllgB;2BAcH,qBApzBbqrgB,UA0yBK7C;2BASK,0BAriBVzhD,WA2hBK0/C;2BASK;gDApiBV1/C,WA0hBKy/C;2BASK,0BAhhBVuH,aAsgBK9ulB;2BASQ,qBAnyBb86L,SAyxBsBmrZ;0BASZ;uDA1iBV2I,mBAiiBgB7tgB;mCzEt2BlB27V;;;;;;;uByE63BE;;;;;;;;;;;0BAKKm4K;0B;kCALLF;;;mCAKKE;2FA+BgE;uBApCrE;;;;;;;;;;;kCAiBIA;;mCACAhtD;;oCAYAqtD;;qCACAjP;;sCACAvmD;yCACAu1D,sBACAD,wBAEiE;uBApCrE;;;;;;;;;;;;;;;;;kCAiBIH;kCACAhtD;kCAYAqtD;kCACAjP;kCACAvmD;kCACAu1D;kCACAD,gBAEiE;uBApCrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCoBnYA;sCpBmYA;;;;;;;;;8FAoCqE;iDApCrE5rd;;;;;;;;;;;6CA+BI;uEA/BJF;;+CA+BI;;kEA/BJ4qa,UA+BIxrX;;;4CAEA;sEAjCJp/C;;8CAiCI;;mEAjCJ+pd,cAiCI1qa;;;2CAhBA;qEAjBJr/C;;6CAiBI;;kEAjBJmsd,uBAiBI5sa;;;0CAiBA;oEAlCJv/C;;4CAkCI;;iEAlCJ+pd,cAkCI5qa;;;yCAJA;mEA9BJn/C;;2CA8BI;;gEA9BJ0/Z,UA8BIr7W;;;wCAEA;kEAhCJrkD;;0CAgCI;;+DAhCJosd,eAgCI7na;;;uCAdA;iEAlBJvkD;;yCAkBI;;8DAlBJ0/Z,UAkBIj7W;;sCAlBJ;;;;;;;;;mCAiBI4na;6BAjBJ,MAkBIh0J;6BAlBJ,MA8BIi0J;6BA9BJ,MA+BIhQ;6BA/BJ,MAgCIhkJ;6BAhCJ,MAiCIi0J;6BAjCJ,MAkCIC;;;;;;;;;;;;;;;;;+BADAE;+BADAn0J;+BADAgkJ;+BADAoQ;+BAZAn0J;+BADAo0J;;;sCACAp0J;sCAYAm0J;sCACApQ;sCACAhkJ;sCACAm0J;sCACAD;4BAlCJ;;;;+CAiBIJ;;gDACAh0J;;iDAYAi0J;;kDACAhQ;;mDACAhkJ;;oDACAi0J;uDACAC,8CAEiE;uBApCrE;;;;;;;;;;;;;;oCAoCqE;uBApCrE,6CAoCqE;uBApCrE,yBAkCIv8lB,cAAe;uBAlCnB,4BAiCIA,cAAkB;uBAjCtB,mCAgCIA,cAAyB;uBAhC7B,0BA+BIA,cAAc;uBA/BlB,4BA8BIA,cAAkB;uBA9BtB,2BAkBIA,cAAiB;uBAlBrB,6BAiBIA,cAAmB;uBAjBvB;iCAkCIA,+CAAe;uBAlCnB;;;yCAkCI,QAAe;;;yBAAf67lB;;uBAlCJ;iCAiCI77lB,+CAAkB;uBAjCtB;;;yCAiCI,QAAkB;;;yBAAlB87lB;;uBAjCJ;iCAgCI97lB,+CAAyB;uBAhC7B;;;yCAgCI,QAAyB;;;yBAAzBumiB;;uBAhCJ;iCA+BIvmiB,+CAAc;uBA/BlB;;;yCA+BI,QAAc;;;yBAAd88lB;;uBA/BJ;iCA8BI98lB,+CAAkB;uBA9BtB;;;yCA8BI,QAAkB;;;yBAAlB+7lB;;uBA9BJ;iCAkBI/7lB,+CAAiB;uBAlBrB;;;yCAkBI,QAAiB;;;yBAAjB0uiB;;uBAlBJ;iCAiBI1uiB,+CAAmB;uBAjBvB;;;yCAiBI,QAAmB;;;yBAAnB07lB;;uBAjBJ;;0BAKK6B;;;;;;;;;;;sDAYDF,sBAZCt7D;;;;;oDAaDq7D,oBAbCp7D;;;;;qDAyBDm7D,qBAzBCj7D;;;;;iDA0BDg7D,iBA1BC96D;;;;;;8BA2BD66D;8BA3BCtzD;;;;;qDA4BDqzD,qBA5BCnzD;;;;;kDA6BDkzD,kBA7BC/yD;;;;;;;;;;;;;;;;;;;;;4DAAC;kCAADuoB,cAAC;6BA3vBA8gC;;;uBAsvBN;6BN5rBMxZ,gBmQXH1yB;uB7PmvBL;;;;;;;;+B,OAvCOs0C;8BAxIA9B;;uBA+KP;uBAO+C;wC,UAP/CwE;uBAO+C;iCAP/Cx8lB;0B;0BAII,sB,OAtyBJ8xlB;0BAsyBI;0BADA,sB,OAryBJA;0BAqyBI;0BADA,sB,OApyBJA;0BAmyBI;mD,ONzuBJxZ,cFzLEvjF;;;;mCQkvBAqjG;mCA+KFp4lB;uBAO+C;iCAP/ChB;;;;;mCA5CE8uiB,iB,OAtvBFqkD;0BAsvBE;6CA4CFnzlB;2BA5CE,qBA4CFA;2BA5CE,4BA4CFA;2BA5CE,iBA4CFA;2BA5CE,qBA4CFA;2BA5CE,oBA4CFA;2BA5CE,sBA4CFA;2BAVM;;2BADA;+DACAuwI;2BAFA5/C,MAtxBNwigB,oBAsxBMprJ;+DACAv3T;2BAFAhgD,MArxBN2igB,oBAqxBMtH;+DACAv0c;2BAFA;+DACAC;2BAbA;+DAYA6S;2BAbAr5D,MN7sBNwof,cFzLEvjF,cQs4BI+nG;+DACAjpa;oCADAC;uBAkCyC;iCAP/Ckpa;0BAME,SAlDAE,eAiDEC;2DAAsB;0BACxB,SAlDA/O,WA8CEiP;4BAAmB;8CAAnBE;kFAAkB;qCAAlBF;2CAAsC;0BA7Bd,GA2B5BL,gBA3B4B;;iCA2B5BC;2BA3B4B,MA2B5BD;2BACmC;;uCAA/BS,iDAA8B;;;mCA5BNjzf;4BACF,iBA0B1Bwyf;4BA1B0B;8BAYC,mBAc3BA;8BAd2B;gCACJ;uCAavBC;iCAbuB,MAavBD;iCAIgC;;6CAA5BW;oFAA2B;;;yCAjBRrzf;kCACW;yCAYlC2yf;mCAZkC,MAYlCD;mCAG0C;;+CAAtC99O;mFAAqC;;;2CAfP30Q;oCACP,uBAW3Byyf;oCAX2B,iBACH,eAUxBA,mBAX2B/7hB;kCADO;gCADX;8BADI;4BAZD;0BADE,UAiCV;uBANlB;uCAqlB8Cu7hB;sBiSp8ChC;uBjS+2Bd;iCAaQt3lB;0BACV,SACIw2D,OAAQ6/d;4BACV;;8B,2BADUA;;gC;;gEA3DRy/D,sBA4DqD;0BAStC;sDAzLf5B;2BAwLkB,2BAxLlBA;2BAuLyB,2BAkX3BrG;2BAnXgB,2BA3xBdF;2BA0xBkB,2BAxxBlBC;2BAuxBiB,2BAvxBjBA;2BAuxBiB;0BADI,sB,ONjuBvB/Z;0BMguBF;;;8BACuB;;;;;;;8BANb7zkB;0BAKV;yDA9DI+1lB,2BAsEqE;uBA1BvE;;iCAgCOnuD;0BAEP;2BADEkxD;4BACF;;8BADF;;;;;0BACE,eAMO7D;2CAKAjP;6CAGAvmD;gC;yCAtKL80D;kDA0KKS;2C;oDA1KLT;6DA2KIQ;sDACR;8DAvBI8D;8DACKjxD;8DAQAqtD;8DAKAjP;8DAGAvmD;8DAIAu1D;8DACDD,gBAQP;8BAZC;4BAHA;0BALA;;qCACE,uBATA+D;yCA4BH;uBAjCCC,eAI2B;uBA+B3BC;;;2BAOGjE;2BADAC;2BADAv1D;2BADAumD;2BADAiP;2BADArtD;2BADAgtD;0BAUiB,SAAlBz/lB,c,OApyBF84lB,YA/IE9B;0BA27BA;gDAZC4I;2BAWD,qBAZCC;2BAWQ;;yCAr4BT3I,cAy3BC5sD;;2BAWQ,qBA36BT5kW,SA+5BCmrZ;2BAWD,gBAZCiP;2BAWD,gBAZCrtD;0BAWK;kDAruBN2mD,QAytBCqG;mCzEz+BHn4K;;;;;wC,OsEb6B0oK,gBgQmMxB9kC;;;2B,O9P/LA+mC;;oCDEAP;oCvBgBA7hD;;;;;;;uByB8/BH;;;;;;;;+B,OArIK2vD,gB6P5sBFt0C;;;uB7Pi1BH;uBAc+C;wC,UAd/C44C;;uCAAKC;sBiS78BO;uBjS68BZ;iCAmCmBl5lB;0BACrB,SACIqgjB,OAAOrgjB;4BACT;qCAAIw2D;8B;;;;gEH1jCNqvhB;4BG8jCoB;;6BADlB,mBAAiD,gCAJxC7llB;4BAIT;2DH7jCF8llB,0BGgkC6D;0BAR7D;mCAUItvhB;4B;;;;8DDnkCJ2yhB;0BCskCgB;;2BAD6B;2BAAzB;2BAD2C;2BAA/D;2CAAgD,SAV5C9oC,gCAFiBrgjB;0BAYrB;yDDpkCAoplB,2BCukC0E;uBAkG7C,4BAt1B3BuF;uBAu1BmB,oBA90BnB9mD;uBA+0BmB,oBA5zBnBgnD;uBA6zBkB,iBA9lClB1C;uBA+lCkB,gBAllClBtxZ;uBAmlCuB,qBA5iCvBwxZ;uBAgjCA;;;6BATAgN,wBAIAI;0BH5qCF1T;;;;uBGurCA;;;;2BARIsB;;4BALFkS;+BADAD,gCAEAE;0BD5qCFnQ;;;;uBC6rCF;;;;2BApBIgQ;;4BAGAG;;;;8BACAC;iCACAC,iBACA7E;0BApSAC;;;;uBAkTJ,mBAYE9piB;;;;;;;;;;0BA+BS;2CAAQ;2BACM,iCADrBm2e,KACOy4D;2BAAa,8BADpBz4D;2BACoB;;2BAAbx0f;;2DAAC;;mCAAD2d;mCAlTTktiB;mCAkTSr5e;;;;;sCAA8D;sBiSjqCzD;uBjSivCd;;8CApqCQoue;uBAoqCR;uBAC+C;wC,UAD/CwN;;uCAAKC;sBiSjvCS;uBjS2vChB;uBAEiB,cAnsCb3N;uBA0tCF;;uBAC+C;wC,UAD/C+N;;uCAAKC;sBiSpxCS;uBjSoxCd;;0BAoDF;oCAAWG,QAAoB/d,SAAwC;uBApDrE;;0BAoDF;oCAAW+d,KAAoB/d,MAAwC;uBApDrE;;0BA4FgB;iCAAO+d,KAAM/d,mBASlB;uBArGX;;0BAmFgB;mCAEV;mCAEA;mCAEA;oCAEA,aAAgB;sBAXxB;;;wBA5BA8d;;;;sBiSx0CgB;;;uBjSi4CZ;;;;;;;;;6BN1vCMxnB;uBM0vCoC4nB,mBNh8CpC9pB,gBAyRHqD;uBMuqCH;uBAaF;;;;;;;qCAb4CrvjB;+B;uCAA1C61kB;;0CAmE4CpL,aAnEFqL;;;uBAa5C;uBAK+C;wC,UAL/CC;;uCAsD8Cv6e;sBiSp8ChC;;;;uBjSo8Cd;;;;;;;;;;6BN7zCQ0yd,gBJjK2D95E;uBUm/CrE;;;;;;;qCArBgDzxH;+B;uCAA9CszN;;0CAA8CxL;;;uBAqBhD;uBAM+C;wC,UAN/CyL;;uCAAKC;sBAgEJ;sBjK7lDCh1d;sBADAD;sBmKVN;sB+R+EoB;uB/RxDd;;;;;;;uBAK+C;wC,UAL/Cm1d;;uCAAKC;sB+RwDS;uB/RxDd;;0BAYF;;;;;kCACIK;qCACAD,aACAD,0BAE6B;uBAjB/B;;0BAYF;;;;;;oCACIE,UACAD,UACAD,sBAE6B;uBAjB/B;iCAYF5/kB;;;;;oCAKiC;uBAjB/B,qCAYF,QAKiC;uBAjB/B,+BAeExiB,cAAqB;uBAfvB,mBAcEA,cAAS;uBAdX,mBAaEA,cAAS;uBAbX,eAeEA,2BAAqB;uBAfvB;;;yCAeE,QAAqB;;;yBAArBoimB;;uBAfF,eAcEpimB,2BAAS;uBAdX;;2CAcE,QAAS,cAATqimB;uBAdF,eAaErimB,2BAAS;uBAbX;;2CAaE,QAAS,cAATsimB;uBAbF;;0BA2BA;;;;;kCACIA;qCACAD,aACAD,0BAEc;uBAhClB;;0BA2BA;;;;;;oCACIE,UACAD,UACAD,sBAEc;uBAWlB;;;yEGkzCAlrG;0BHl0CA2rG;;0BAfFV;;uBA+BE;iCAKUr7lB;0BACV,SACIw2D;4B;;;;8DAtCNkliB;0BAwCI;;2BAGuB,mCAJrBJ;2BAGiD;2BAAlB;2BA1ChC,+BACDQ,YAmCQ97lB;2BApCP;;4DAED67lB,YAFC5gE;;;;;;8BAGD2gE;8BAHC1gE;;;;;;mCAALygE;;6CAAKz7jB;;;;;;0FAAC;oCAADk7f,eA4CuD;uBAb1D;;0BAwBoC;2BAElC;2CAE0B,WPwMlCs5C;2COnMkC,WPmMlCA;0BOhMQ,IADI4mB;0BACJ,cADIA,sBAC0D;uBApChE;;0BAsCwC,4BAQtC;;4BAFA,IADqCA;4BACrC,UADqCA;0BAHrC,QAMqC;uBA4+CrCqB;;;mCAz+CgBC;4BACpB,iCADoBA,cACiD;uBAEnEC;iCAAQ78lB;0BACV;yCAfE08lB,kBAdAD,cAnBEP,WA+CMl8lB,IAGc;uBAOxB;;4CA/DIi8lB,OAyBFQ,cAcAC;uBA+BA;;uBAY+C;wC,UAZ/CK;;uCAAKC;sB+RxDS;uB/R2EhB;;iCAqOAthlB;;;oCAKiC;uBA1OjC,qCAqOA,QAKiC;uBA1OjC;;0BAqOA;;;oCAEI6hlB,qBACAD,uBAE6B;uBA1OjC;;0BAqOA;;;;oCAEIC,kBACAD,oBAE6B;uBA1OjC,6BAwOIpkmB,cAAmB;uBAxOvB,2BAuOIA,cAAiB;uBAvOrB,eAwOIA,sBAAmB;uBAxOvB;;;yCAwOI,QAAmB;;;yBAoGnBokmB;;uBA5UJ,eAuOIpkmB,sBAAiB;uBAvOrB;;;yCAuOI,QAAiB;;;yBAmGjBqkmB;;uBAtFA;;;;0BAfJF;;;;uBAeI;;iCAQS/lmB;0BAAL,wBAAKA,KAAL,kBAAKA;0BAAL;4BAKM;6BAFA0gC;8BAEA,oBALEulkB,kBAAmBD;4BAKrB,eAKKM;8BACT,+BARI5lkB,IAOK4lkB,YACiC;4BADnB,8BAPnB5lkB;4BAOmB,oDACmB;0BAT5B,qBAXb2lkB,UASErmmB;0BAEW,oDAS8B;uBAnBlD;;;0BADOqmmB;;;;;;;uBACP;iCAsBU3rD;0BAIP;2BAJ0CsrD;2BAAnBC;2BAIvB;sCACG,WALIvrD,cAAmCsrD;0BAE1C;;8CACG,WAHItrD,cAAgBurD;;mC3E/Y5B9gL;uB2EyXE;;0BAyCa,yBAQX,8BAAsE;uBAjDxE;;0BAmDa;mCAEX;mCAEA;oCAEA,aAAyD;uBAzD3D;iCA2DQz8a;0BACV;mCACIw2D;4B;;;;8DA5EN2miB;0BA8EyB;;2BADoB;2BA7ElC;6DAEPO,oBAwEQ19lB;2BA1ED;;;;sDAGPy9lB,sBAHOxiE;;;;;;;;;+EAAC;6BAADC;;yDAAXkiE,2BA+E4C;uBAhExC;iCAqEMp9lB;0BAGR;;6CA/BE+9lB,WAUAC,WAQAC;2BAoB2B;0BAF3B;;;uDACyB;;mCAPzBM;mCAFMv+lB,IAY6B;uBA2BvC;qDA/GI69lB,OAsDAG,WAVAD;uBA4EA;;;;;;;;;;;;;;;;;uBAQqE;wC,UARrEU;uBAQqE;;0BARrE;;;;;;;;;;;;;;mFAQqE;;iCARrEnslB;;;;;;;;;;;wEAQqE;;iCARrEA;0BAEI;;sDAFJA;2BAGI,oCAHJA;2BAII,yCAJJA;2BAKI,wCALJA;2BAMI,8CANJA;0BAMI;kCAJA4skB;kCACAC;kCACAC;kCACAC;kCACAC,oBAEiE;;iCARrEvye;;;;;;;;;;;;;;;;;;;;;;;oCkBYA;sClBZA;;;;;;;;;8FAQqE;iDARrEo8B;;;;;;;;;2CAKI;qEALJF;;6CAKI;;;;;0CACA;oEANJA;;4CAMI;;;;;yCAJA;mEAFJA;;2CAEI;;;;;wCACA;kEAHJA;;0CAGI;;;;;uCACA;iEAJJA;;yCAII;;;;sCAJJ;;;;;;;;;mCAEI6qa;6BAFJ,MAGIC;6BAHJ,MAIIC;6BAJJ,MAKIC;6BALJ,MAMIC;;;;+BADAE;+BADAC;+BADAC;+BADAC;;;sCACAD;sCACAD;sCACAD;sCACAD;4BANJ;;;;+CAEIL;;gDACAC;;iDACAC;;kDACAC;qDACAC,8CAEiE;;;0BARrE;;;;;;2BAMI;;2BADA;+DACA9pa;2BAFA;+DACAC;2BAFA;+DACA8G;2BAFA;+DACAC;0BADA,iBAMiE;;iCARrE30B;;;;;;;;uCAAKiif;sB+RpbO;uB/RobZ;;;;;;;;;;oCAQqE;uBARrE,6CAQqE;uBARrE;;;;;;;;;;;;;;;;;;;;;;;;oCkBYA;sClBZA;;;;;;;;;8FAQqE;iDARrEv1d;;;;;;;;;2CAKI;qEALJF;;6CAKI;;;;;0CACA;oEANJA;;4CAMI;;;;;yCAJA;mEAFJA;;2CAEI;;;;;wCACA;kEAHJA;;0CAGI;;;;;uCACA;iEAJJA;;yCAII;;;;sCAJJ;;;;;;;;;mCAEI6qa;6BAFJ,MAGIC;6BAHJ,MAIIC;6BAJJ,MAKIC;6BALJ,MAMIC;;;;+BADAE;+BADAC;+BADAC;+BADAC;;;sCACAD;sCACAD;sCACAD;sCACAD;4BANJ;;;;+CAEIL;;gDACAC;;iDACAC;;kDACAC;qDACAC,8CAEiE;uBARrE;;;;;;;;2BAMI;;2BADA;+DACA9pa;2BAFA;+DACAC;2BAFA;+DACA8G;2BAFA;+DACAC;0BADA,iBAMiE;uBARrE;;;;;;;;;kCAEI2ja;;mCACAD;sCACAD,gBACAD,kBACAD,wBAEiE;uBARrE;;;;;;;;;;;;;kCAEII;kCACAD;kCACAD;kCACAD;kCACAD,kBAEiE;uBARrE,6BAMIz7iB,cAAiB;uBANrB,0BAKIA,cAAc;uBALlB,wBAIIA,cAAY;uBAJhB,sBAGIA,cAAU;uBAHd,mCAEIA,cAAuB;uBAF3B,eAMIA,qCAAiB;uBANrB;;;yCAMI,QAAiB;;;yBAAjBsmmB;;uBANJ,eAKItmmB,qCAAc;uBALlB;;;yCAKI,QAAc;;;yBAAdummB;;uBALJ,eAIIvmmB,qCAAY;uBAJhB;;;yCAII,QAAY;;;yBAAZwmmB;;uBAJJ,eAGIxmmB,qCAAU;uBAHd;;2CAGI,QAAU,cAAVymmB;uBAHJ,eAEIzmmB,qCAAuB;uBAF3B;;;yCAEI,QAAuB;;;yBAAvB0mmB;;uBAoCJM;iCAAUrlmB;0BAMR;yDANQA;2BAKR,0BALQA;2BAIR,8BAJQA;2BAGR,0BAHQA;0BAER;2DAFQA,a3EphBZ4hb,S2E2hBG;uBAKC85H;uBACAC;uBAJF2pD;;yBAGE5pD;yB0jBjiBRjjC;yB1jBkiBQkjC;yB0jBliBR3jC;yB1jBkiBQ2jC;uBAQF4pD;iCAAmBvlmB,GACrB,UADqBA,yBAOlB;uBAEDwlmB;iCAIMxlmB,GAHR,OAGQA,oCAOD;uBAGPylmB;;;;;;;;;kCACIvrD;;mCACAD;sCACAD,gBACAD,kBACAD,wBAEc;uBAPlB4rD;;;;;;;;;;;;;kCACIxrD;kCACAD;kCACAD;kCACAD;kCACAD,kBAEc;uBAUd6rD;;0BAaE;2BARC7rD;2BADAC;2BADAC;2BADAC;2BADAC;2BAYD,8BARCJ;2BAOD,8BARCC;2BAOD,8BARCC;2BAOD,6BARCC;0BAOD;2DARCC;mC3EllBPt4H;uB2EonBA;;;;;;0BApDA6jL;;0BAlFEhB;;uBAsIF;iCAUUt/lB;0BACV;mCACIw2D;4B;;;;8DAlJF0oiB;0BAsJmB;;2BADoB;2BAAzB;2BADF;2BADmC;2BAnJ1C;;0DAEDe,0BA8IIjgmB;2BAhJH;;6DAGDggmB,aAHC/kE;;;;wDAID8kE,eAJC7kE;;;;;iDAKD4kE,iBALC1kE;;;;;oDAMDykE,oBANCvkE;;;;;;;;;;;;;;;;;;yDAAC;6BAADuH;;yDAALs8D,2BAuJmC;yCRpkB7B3tB,gBnBxDHxsC;yCmBwDGwsC,gBQ6aDktB;yCR7aCltB;;yDTwSLxrB;yCSxSKwrB;yDJjC2Dv4E;uBY8mBnE;;;;;;;;;;;+BgdnpBQk8E,gBxdsEA3D;;;uBQ6kBR;uBAaqE;wC,UAbrEmvB;;uCAAKC;sB+RplBS;uB/RolBd;;;;;;;;;;;;;;;;oCAaqE;uBAbrE,6CAaqE;uBAbrE,sBAWI1nmB,cAAU;uBAXd,kBAUIA,cAAM;uBAVV,wBAQIA,cAAY;uBARhB,qBAOIA,cAAS;uBAPb,uBAMIA,cAAW;uBANf,4BAIIA,cAAgB;uBAJpB,oBAGIA,cAAQ;uBAHZ,qBACIA,cAAS;uBADb;iCAWIA;yEAAU;uBAXd;;2CAWI,QAAU,cAAV8nmB;uBAXJ;iCAUI9nmB;yEAAM;uBAVV;;2CAUI,QAAM,cAAN+nmB;uBAVJ;iCAQI/nmB;yEAAY;uBARhB;;;yCAQI,QAAY;;;yBAAZgomB;;uBARJ;iCAOIhomB;yEAAS;uBAPb;;2CAOI,QAAS,cAATiomB;uBAPJ;iCAMIjomB;yEAAW;uBANf;;;yCAMI,QAAW;;;yBAAXkomB;;uBANJ;iCAIIlomB;yEAAgB;uBAJpB;;;yCAII,QAAgB;;;yBAAhBmomB;;uBAJJ;iCAGInomB;yEAAQ;uBAHZ;;2CAGI,QAAQ,cAARoomB;uBAHJ;iCACIpomB;yEAAS;uBADb;;2CACI,QAAS,cAATqomB;uBADJ;;;;;;;;;;;;kCACIpzK;;mCAEA0uJ;;oCACA9pG;;qCAEA2pG;wCACAtnF,aACA6nF,gBAEAN,UACAC,oBAEiE;uBAbrE;;;;;;;;;;;;;;;;;;;kCACIzuJ;kCAEA0uJ;kCACA9pG;kCAEA2pG;kCACAtnF;kCACA6nF;kCAEAN;kCACAC,WAEiE;uBAbrE;iCAmBM/4iB,UAAiDhf,GACtDs9kB;0BACH,GAFQt+jB;2BAAgB,QAAhBA,qBAAgBi9B;;+BAAhBshiB;0BAER;2BAFiD,mBAAhB/uG,cAAgBhoa;;+BAAhBgoa;0BAEjC,eACSllE;2CAQA0uJ;6CAIA9pG;+CAaA2pG;iDAQAtnF;mDAWA6nF;qDAOAL;wCAIT;;kDAvDSzuJ;kDAQA0uJ;kDAIA9pG;kDAaA2pG;kDAQAtnF;kDAWA6nF;;kDAOAL,YAeA;sCAfa;oCALlB,IADEylB,UACF;oCAGF,qBAJIA;kCAVF,IADEC,QACF;kCAOF,qBARIA;mCApCHH;;mCA+BMI,SA/BNJ;kDAgCWzlB,aACR,UADQA,YACmB;kCjB/UnC,OiB6UW6lB;;yCjB7UPC,kBA1TAnhD;;yCA0TAmhD,kBA9TAphD;gDA8TAohD,kBAtTAlhD;kCAgUJ;;6CACS4B;qDACAF;uDACA55E;yDACA25E;2DACAD;6DACA2/C;gDAEP;iDADE38C;kDACF,iBAAqD;gDAArD,eAEOlD;iEACAD;mEACAD;qEACAD;uEACAD;yEACAD;2EACAU;8DAMT;;;wEArBSC;wEAeAD;wEAdAD;wEACA55E;wEACA25E;wEACAD;2EACA2/C,0BACL38C;wEAGKlD;wEACAD;wEACAD;wEACAD;wEACAD;wEACAD,YAqBN;;wFApWCjB;;sFAsTAkhD;;;;;;;;;gDAkBF;4EAlBEA,wBA8CD;;0EA9CCA;;;;;;;;;;;sCAUJ,8BAVIA;;;2CiB4UI;gCAAuB;iCA/BInvG;gCAiB7B,GAjBqDxue;iCAyB5C,SAzB4CA,MAwBzC69kB;;iCAHH;;kCACW,eADPjmmB;kCAGDimmB,QAHCjmmB,KACAqkF;0CALb,MACE,UAMU4hhB;;yCAET;8BAAuB;sCA1BtBN,cAaD,aADqB,MN7U5B70c;4BM8U8B;0BAX9B,eAEWixE;4BAKmB,4BgdrqB5Bw3H,chdgqBSx3H,QAKqD;;2CAH5D,qBAAwC,2BA+DnC;uBAxFP;;0BA6FF;;;;;;;;;;kCACI2vN;;mCACA0uJ;;oCACA9pG;;qCAQA2pG;wCACAtnF,aACA6nF,gBACAN,UACAC,oBAEc;uBA9GhB;;0BA6FF;;;;;;;;;;;;;;;;;kCACIzuJ;kCACA0uJ;kCACA9pG;kCAQA2pG;kCACAtnF;kCACA6nF;kCACAN;kCACAC,WAEc;uBA9GhB;;;;;;;6CA+IwD,QAAgB;uBAAtE;;;;;;;;;;;;0BA2CA;2BAvBCA;2BADAD;2BADAM;2BADA7nF;2BADAsnF;2BADA3pG;2BADA8pG;2BADA1uJ;2BA8BD,qBAvBCyuJ;2BAqBD,qBAtBCD,OAnRDwjB,QATAD;2BAgTA;2CArBCjjB,aNrsBHhzhB,WA6BAkyhB;2BM2rBW;2BAFT;;yCACE,OAnBD/mF,UD7yBcqlF,etBgEb99J;;2BuB6vBF;2CAjBC+/J,YjBnQLrzB,SAnBAF;2BiBoSI;;;+BACE,OAhBDp2E,iB7B5yBLqrD,S4CsuCMluC,StCrqCAvzE;;2BuBuvBF;;yCAbCkgK,SAcQ,mB9C3vBX/hF;;0B8CwvBE;;;sCAZC3sE;sD,ORlnBH0kJ,kBuB8iCI3iF,StCrqCAvzE;;mCpDjEJF;uB2E6xBE;iCAwFMz8a;0BACV,SACIw2D;4B;;;;8DAzOFsqiB;0BA2OA;;;;8C,OD31BF9lD;;;2BCm2BmD;2BAHjD;;;8BAEI;kDACgB;;;2BAYL;qD,ORzzBfu3B;2BQwzBW;;gD,ORxzBXA,UyBuHEmuB;2BjBgsBe;;gD,ORvzBjBnuB,UQyyBE0K;2BAaY;qD,ORtzBd1K,UQoyBEn9E;2BAiBc;qD,ORrzBhBm9E,UyB8HEnoB;2BjBsrBmB;;;;gC,ORpzBrBmoB,UpBkcF3wC;2B4BiXe;qD,ORnzBb2wC;0BQkzBwC,sB,ORlzBxCA;0BQkzBc;;qD,Ogd/1BhBqD;2BhdumBO,+BACDmsB,YAsOI/hmB;2BAvOH;;2DAGD8hmB,WAHC7mE;;;;;mDAID4mE,mBAJC3mE;;;;uDAMD0mE,cANCxmE;;;4DAODumE,YAPCrmE;;;;wDAQDomE,eARC7+D;;;yDAUD4+D,SAVC1+D;;;;sDAWDy+D,aAXCt+D;;;;;;;;;;;;;;;;;;;;;;;kDAAC;6BAADuoB;0BAsPP;0DAtPEs1C,4BAgQM;uBAON,sCFymB8CzR;uBEzmB9C;uBAC+B;wC,UAD/BwU;;uCAAKC;sB+R31BS;uB/R21Bd;;0BAwB6B;mCAEtB,IADCE,sBACD,OADCA;mCAGD,IADC9pmB,WACD,eADCA;oCAGD,OFjdPm3lB,OEid0C;uBAR5C;;mCFxeED;uBEweF,oBAcUrxlB,KAAM,kBAANA,IAA4C;uBAkCpD;;;;;;;;;uCFmiB8Cs3lB;;wCEzmBzCyM;2CF9wBGxX;;uBEo1BR;uBAOqE;wC,UAPrE6X;;uCAAKC;sB+Rj6BS;uB/Ri6Bd;;;;;;oCAOqE;uBAPrE,6CAOqE;uBAPrE;;;oCACI/jjB,WACA6yc,WACAuxG,gBAIiE;uBAPrE;;;;;;;;oCACIpkjB,QACA6yc,QACAuxG,YAIiE;uBAPrE,qBAGIxrmB,cAAW;uBAHf,mBAEIA,cAAO;uBAFX,mBACIA,cAAO;uBADX,eAGIA,2BAAW;uBAHf;;2CAGI,QAAW,cAAXwrmB;uBAHJ,eAEIxrmB,2BAAO;uBAFX;;2CAEI,QAAO,cAAP0rmB;uBAFJ,eACI1rmB,2BAAO;uBADX;;2CACI,QAAO,cAAP2rmB;uBADJ;iCAaQ7kmB;0BACV;mCACIw2D;4B;;;;8DAfF+tiB;0BAmBa;oDFoUb1W;2BErUS,qBApDTsW;2BAmDS,qBiBnwBPvL;2BjBkvBG,6BACDoM,UAYIhlmB;2BAbH;;0DAED+kmB,UAFC9pE;;;;uDAGD6pE,cAHC5pE;;;;;;;;;;qEAAC;6BAADE;;yDAALopE,2BAoB0C;uBApB1C;;;;2BAiCEE;2BADAvxG;2BADI7yc;4CACJ6yc,QACAuxG;2DArFFR,OF6YAhK;2DA/WAnB;uBE8nBEyM;uBAxjBJC;;;oCACInljB,WACA6yc,WACAuxG,gBAE6B;uBALjCgB;;;;;;;;oCACIpljB,QACA6yc,QACAuxG,YAE6B;uBAkC7B;;;;;;;4BxJp6BRhvb;;;uBwJo6BQ;uBAI+C;wC,UAJ/Ciwb;uBAI+C;iCAJ/C9rmB;0B,OxJp6BR87K;sFwJo6BQ97K;uBAI+C;iCAJ/CyY;0B,OxJp6BRsjK;;mCwJo6BQtjK;;qCAI+C;;iCAJ/CA;0B,OxJp6BRujK;;mCwJo6BQvjK;2CAI+C;;iCAJ/CzX;0BACE;sFADFA;uBAI+C;iCAJ/ChB;0B,OqBrlBFmyG;sFrBqlBEnyG;uBAI+C;iCAJ/C4iH;0B;;4CACEA;qC;uFAAAA;mCADFA;;uBAI+C;iCAJ/C2pf;0BAGE;4CAFAE;qCACA,eADAE;2FAAsC;qCACtC,2CADAF,YACkC;mCAFpCF;yCAGM;uBAHN;uCAAKR;sB+Rx/BO;uB/Rw/BZ;;;kC2P53BG5wb;;mC3P43BE4wb;;;;;;sCxJp6Bbrwb;;uCwJ60BW8ub;;wC2PryBArvb;;;;0C3PpEAgob;6CAhHA7B;uBAgjCH;uBAeA;;;;;;;;;uCZjiCiEliG;;wC4lBd/CmiD;;yChlB4nBfwlD;;;;kD,OvC9pBiBjtF;oCHCnB3R;;;uB0CglCD;uBAiB8D;wC,UAjB9D2kG;;uCAAKC;sB+RvgCO;uB/RugCZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAiB8D;uBAjB9D,6CAiB8D;uBAjB9D,4BAeI1tmB,eAAkB;uBAftB,uBAcIA,eAAa;uBAdjB,uCAaIA,eAA6B;uBAbjC,6BAYIA,eAAmB;uBAZvB,uBAWIA,eAAa;uBAXjB,oBAUIA,cAAU;uBAVd,mBASIA,cAAS;uBATb,iBAQIA,cAAO;uBARX,gBAOIA,cAAM;uBAPV,2BAMIA,cAAe;uBANnB,wBAIIA,cAAc;uBAJlB,kBAGIA,cAAM;uBAHV,oBAEIA,cAAQ;uBAFZ,sBACIA,cAAU;uBADd;iCAeIA;;;;;;;;;;;;;;;oCAAkB;uBAftB;;;yCAeI,QAAkB;;;yBAAlB8tmB;;uBAfJ;iCAcI9tmB;;;;;;;;;;;;;;;wCAAa;uBAdjB;;;yCAcI,QAAa;;;yBAAbqlmB;;uBAdJ;iCAaIrlmB;;;;;;;;;;;;;;;wCAA6B;uBAbjC;;;yCAaI,QAA6B;;;yBAA7B+tmB;;uBAbJ;iCAYI/tmB;;;;;;;;;;;;;;;wCAAmB;uBAZvB;;;yCAYI,QAAmB;;;yBAAnBgumB;;uBAZJ;iCAWIhumB;;;;;;;;;;;;;;;wCAAa;uBAXjB;;;yCAWI,QAAa;;;yBAAbiumB;;uBAXJ;iCAUIjumB;;;;;;;;;;;;;;;wCAAU;uBAVd;;2CAUI,QAAU,cAAVkumB;uBAVJ;iCASIlumB;;;;;;;;;;;;;;;wCAAS;uBATb;;2CASI,QAAS,cAATmumB;uBATJ;iCAQInumB;;;;;;;;;;;;;;;wCAAO;uBARX;;2CAQI,QAAO,cAAPoumB;uBARJ;iCAOIpumB;;;;;;;;;;;;;;;wCAAM;uBAPV;;2CAOI,QAAM,cAANk9kB;uBAPJ;iCAMIl9kB;;;;;;;;;;;;;;;wCAAe;uBANnB;;;yCAMI,QAAe;;;yBAAfqumB;;uBANJ;iCAIIrumB;;;;;;;;;;;;;;;wCAAc;uBAJlB;;;yCAII,QAAc;;;yBAAduniB;;uBAJJ;iCAGIvniB;;;;;;;;;;;;;;;wCAAM;uBAHV;;2CAGI,QAAM,cAANsumB;uBAHJ;iCAEItumB;;;;;;;;;;;;;;;wCAAQ;uBAFZ;;2CAEI,QAAQ,cAARuumB;uBAFJ;iCACIvumB;;;;;;;;;;;;;;;wCAAU;uBADd;;2CACI,QAAU,cAAVwumB;uBADJ;iCAuBQ1nmB;0BACV,SACIw2D;4B;;;;8DAzBFswiB;0BAiCoB;2DAjgCtBjK;2BAggCiB,2BAnqBjByB;2BAkqBiC;2BAD6B;2BAA7C,2BAvHjB2G;2BAyHqD;2BAHb;2BAA7B,qBP7hCXnuB;2BO4hCkC,oBP5hClCL;2BO4hCmB;2BAD4B;2BADU,oBiBl4BvDssB;2BjBm4BU,sB+kBnkCd1lD;2B/kBkkCsC;2BA1B7B,gCACDkrD,aAsBIvomB;2BAvBH;;2DAEDsomB,WAFCrtE;;;yDAGDotE,SAHCntE;;;;;iDAIDktE,iBAJChtE;;;;;kDAMD+sE,kBANC7sE;;;yDAODg7C,SAPCzzC;;;0DAQDqlE,UARCnlE;;;4DASDklE,YATC/kE;;;;sDAUD8kE,aAVCv8C;;;;yDAWDs8C,gBAXCp8C;;;;;;8BAYDm8C;8BAZCj8C;;;;;;8BAaDg8C;8BAbC97C;;;;yDAcD67C,gBAdC37C;;;;;qDAeD07C,qBAfCx7C;;;;;;mCAAL46C;;6CAAK7mkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iEAAC;oCAAD+pkB,gBAkCyC;uBAlC9C;;;kC2P34BGj1b;;mC3P43BE4wb;;;;;;sCxJp6Bbrwb;;uCwJ60BW8ub;;wC2PryBArvb;;;;0C3PpEAgob;6CAhHA7B;uBA+jCH;uBA0DA;;;;;;;;;uCZ3lCiEliG;;wC4lBd/CmiD;;yChlB4nBfwlD;;;;kD,OvC9pBiBjtF;oCHCnB3R;;;uB0C0oCD;uBAiB8D;wC,UAjB9DmoG;;uCAAKC;sB+RjkCO;uB/RikCZ;;;kC2Pr8BGp1b;;mC3P43BE4wb;;;;;;sCAvFFvB;;uC2PryBArvb;;;;yC3PpEAgob;4CAhHA7B;uBAynCH;uBA2BF;;;;;;;;;uCZtnCmEliG;;wC4lBd/CmiD;;yChlB4nBfwlD;;;;kD,OvC9pBiBjtF;oCHCnB3R;;;uB0CqqCH;uBAgBqE;wC,UAhBrEsoG;uBAgBqE;;0BAhBrE;;;;;;;;;;;;;;;0BAppCA,UAkqCIG;2BA9pCF,IA8pCE/+Z;;2BA/pCF;+BA+pCE++Z;4BA/pCF,gBVGA56G,cUHA51f;4BA+pCEyxM,sBA/pCF7uJ;0BAipCF,IAcI4uJ,sCAdJF;0BApiCA,OAijCIm/Z;;;;0BAbJ;2BAaI/+Z,sCACAF;2BAFA;iEACAE;2BAFA;iEACAqiK;2BAvMJ,cAqMI68P;2BArMJ,UAqMIA;2BArMJ,UAqMIA;2BAlMA3/Z,OFv1BJ8hZ,2BEu1BIme;;2BADA;iEACAlga;2BAFA;iEACAE;2BADA;2BAoMAijK,sCACAF;2BAFA;iEACAE;2BAFA;iEACAE;2BAFA;iEACAE;2BAFA;iEACAE;2BvC7qCN,MuC0qCMu8P;2BvC1qCN,YuC0qCMA;2BAEA;2BvC5qCN;2BHCA,IGC4B12F;6DAF5BnqY;2BAEI;+DAAwBC;2BAAxB;2BuCwqCEykO,qCAEAF;2BA9gBJ,aA2gBIs8P;2BA3gBJ,SA2gBIA;2BA3gBJ,eA2gBIA;2BA3gBJ,YA2gBIA;2BA3gBJ,cA2gBIA;2BA3gBJ,mBA2gBIA;2BA3gBJ,WA2gBIA;2BA3gBJ,YA2gBIA;2BAhgBA/ghB,MRxlBJ0nf,cFzDEhiF,cUipBEmvF;;2BADA30f,MRvlBJwnf,cQ6aEktB,cA0KE9f;+DACA7tc;2BAHA5mD,MRrlBJqnf,ckBvDEv/Z,aV4oBEssa;+DAEA36b;2BAHAr5D,MRplBJinf,ckBvDEv/Z,aV2oBE4na;+DACAvrZ;2BAFA3jG,MRnlBJ6mf,cTwSFjpB,ciB2SM22B;+DACA3wZ;2BAHA8b,MRjlBJmnY,cgmBjEA+C,cxlBkpBIiF;+DAEApvY;2BAHAG,MRhlBJinY,cJjCE73E,gBYinBE+kF;+DACAp0Y;;2BAHAG;;8BgdppBJ6qJ;8C,OxdsEAk8O;8BQ8kBI53H;+DAEApvQ;2BAwgBAG,UA1gBAD;2BA0gBAoxK,sCACArN;2BAFA,kB+kBtqCN2sM,c/kBsqCMyjB;iEACA/iN;2BAFA;iEACAE;0BADA,kBAeiE;;iCAhBrEivP;0BACiB,GADjBA,gBACiB;gDADjBA;0BACiB;4BACF,mB+kBtqCjB3vD,Y/kBoqCE2vD;4BAEe;8BACF,UAHbC,SAGa,MAHbD;8BAtgB4C;mCAygB/BrlgB;;gCAzgB+B;;;iCgdrpB7B;;oCrTgnBFovP;6C3JqCPia;sCAAc;wDAAdv5L;qGAAa;+CAAbu5L;qDgdrpBQ;;;yChdqpB8Bn1W;kCACK;;;;;+CAAlC87K,8CAAiC;;;kCAAC;oCAET;;;;;iDAAlCG;0CwlBnpByC,eAALxQ;0FAAG;0CAAE;4DAArCqsD,iDAA8B;;mDxlBmpBlC77C;yDAAiC;;;oCAAC;sCACE;;;;;mDAAxBE,4CAAuB;;;sCAAC;wCACJ;;;;;qDAAtBo5L;gEU3oBdl9L,WV2oBck9L,YAAqB;;;wCAAC;0CAEC;;;;;uDAAjCG;kEU7oBJr9L,WV6oBIq9L,YAAgC;;;0CAAC;4CACF;;;;;yDAAxB/4L;kDAxKmB,GAwKnBA,gBAxKmB;mFAwKnBA;kDAxKmB;oDACb,gCAuKNA;oDAvKM;sDACE,mCAsKRA;sDAtKQ;wDACE,gCAqKVA;wDArKU;iEACG,2BAoKbA;iEArKU1xE;sDADF;oDADF;kDADa,QAwKI;;;4CAAC;6CACG;;;8CAggB3Ba;+CAhgB2B;0DAAvB+wE,iDAAsB;;;;iDAggB1B/wE,KAjgBwBV;;+CAigBxBU,KAlgB0BX;;6CAkgB1BW,KApgByBZ;;2CAogBzBY,KArgB6Bb;;yCAqgB7Ba,KAtgB2BlqC;;uCAsgB3BkqC,KAxgBoCpqC;;qCAwgBpCoqC,KAzgB+B9rG;uCAygB/B8rG;gCAE+B,UAL5CslgB,SAK4C,MAL5CD;gCvCpqCc;qCuCyqC8BhlgB;;iCAArC;;kCAAqCA,WvCzqC9BF,KAAkB,oCAAlBA;yCuCyqC8BE;kCACtB,0BANtBglgB;kCAMsB;oCACT,qBAPbA;oCAOa;sCACC,qBARdA;sCAQc;wCACE;;2EAThBA;wCASgB;0CACI,UAVpBC,SAUoB,MAVpBD;0CA1Lc;+CAoMMpkgB;;4CApMN;;8CACA;;+CAGR;;;gDAgMcA;iDAhMd;4DADAk5Q;gGAAkD;;;;mDAiMpCl5Q,KAnMNxB;;iDAmMMwB,KApMN1B;mDAoMM0B;4CACM,0BAX1BokgB;4CAW0B;8CACU,0BAZpCA;8CAYoC;gDAChB,0BAbpBA;gDAaoB;kDACK,UAdzBC,UAcyB,MAdzBD;kDAppCA;;;sDAEE;iFACA;oDACA;;;;sDADY,IAAZ7mc;sDAAY,kBsiByGhBkrV,kBtiBzGIlrV;;kDADA;gDA+pCkB;8CADgB;4CADV;0CADN;wCADJ;sCADF;oCADD;kCADS;gCADsB;8BAF/B;4BADE;0BADE,UAAiC;uBADlD;uCAAK8lc;sB+R5lCS;uB/R4lCd;;;;;;;;;;;;;;;;;kCACItxG;;mCACAw5C;;oCACAtqe;;qCACAs4d;;sCAEAgiB;;uCACA2zB;;wCACAkxB;;yCACAD;;0CACAF;;2CACAD;;4CACAD;+CACA1I,iBACAyI,iCAEiE;uBAhBrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCACI/tG;kCACAw5C;kCACAtqe;kCACAs4d;kCAEAgiB;kCACA2zB;kCACAkxB;kCACAD;kCACAF;kCACAD;kCACAD;kCACA1I;kCACAyI,mBAEiE;uBAhBrE;;;2BAoDGA;2BAFAzI;2BADA0I;2BADAC;2BADAC;2BADAE;2BADAC;2BADAlxB;2BADA3zB;2BADAhiB;2BADAt4d;2BADAsqe;2BADAx5C;;;kCACAw5C;kCACAtqe;kCACAs4d;kCACAgiB;kCACA2zB;kCACAkxB;kCACAD;kCACAF;kCACAD;kCACAD;kCACA1I;kCAEAyI;uBApDH;yCxJxgCNvwb;uBwJknCQ;;;;;;;;yCZhuCiEwiV;;uBYguCjE;uBAOqE;wC,UAPrE2yG;;uCAAKC;sB+RtsCO;uB/RssCZ;;;;;;;;oCAOqE;uBAPrE,6CAOqE;uBAPrE,kBAKI3ymB,cAAK;uBALT,uBAGIA,cAAW;uBAHf,eAEIA,cAAG;uBAFP,uBACIA,cAAU;uBADd,eAKIA,gCAAK;uBALT;;2CAKI,QAAK,cAAL+ymB;uBALJ,eAGI/ymB,gCAAW;uBAHf;;;yCAGI,QAAW;;;yBAAXgykB;;uBAHJ,eAEIhykB,gCAAG;uBAFP;gDAEI,QAAG,cAAHgzmB;uBAFJ,eACIhzmB,gCAAU;uBADd;;;yCACI,QAAU;;;yBAAVizmB;;uBADJ;uBAkBA;;;;;;2BACElyC;2BAFAM;2BADAlgD;2BADIphB;+CACJohB,IACAkgD,YAEAN;2DAFAuyC;;2DNj7BNj/c;uBM66BIk/c;uBAgBAC;iCAAQ1smB;0BACV,SACIq6gB,IAAIr6gB;4BACN,kCADMA,wBAEoB;0BAH5B,SAKIw2D,OAAQ6/d;4BAAY;8B,2BAAZA;;gC;;gEAnCV01E,sBAmCwD;0BAKjD;;2BAD4D;2BAA7B;;2BADpC;2BAFkD,6BALlD1xF;2BAKgC;2BApC7B,gCACDkyF,cA4BIvsmB;2BA7BH;;sDAEDssmB,MAFCrxE;;;;uDAGDoxE,cAHCnxE;;;wDAKDkxE,SALChxE;;;;;;mCAAL4wE;;6CAAK9rkB;;;;;;iFAAC;oCAADo7f,eAyCoC;uBAG3CyxE;iCAAclymB;0BAuBA;yCAvBAA;2BAaL,oBAbKA;2BAaL;;;8BF9FA++lB;;;;oC4jB5tCbtmF,Q1jByzCeinD;8BF7FFq/B;;;;2BEsFkC,8BAL7B/+lB;0BAK6B;kCAL7BA;kC2PtZdqijB;kC3P3HA2lD;;;;;kCe2cI3yG;;;;;oCfoGL;uBAuED88G;;;;;;;;;;;;;;;;;kCACI/zG;;mCACAw5C;;oCACAtqe;;qCACAs4d;;sCACAgiB;;uCACA2zB;;wCACAkxB;;yCACAD;;0CACAF;;2CACAD;;4CACAD;+CACA1I,iBACAyI,iCAE6B;uBAfjCiG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCACIh0G;kCACAw5C;kCACAtqe;kCACAs4d;kCACAgiB;kCACA2zB;kCACAkxB;kCACAD;kCACAF;kCACAD;kCACAD;kCACA1I;kCACAyI,mBAE6B;uBG3qCzBx7B;iCHitCI0hC,MAAOrymB;0BA75Cb;2BAs4CCmsmB,mBAuBYnsmB;2BAxBZ0jmB,cAwBY1jmB;2BAzBZosmB,8BAyBYpsmB;2BA1BZqsmB,oBA0BYrsmB;2BA3BZssmB,cA2BYtsmB;2BA5BZwsmB,UA4BYxsmB;2BA7BZysmB,QA6BYzsmB;2BA9BZu7kB,OA8BYv7kB;2BA/BZ4njB,gBA+BY5njB;2BAhCZ4liB,eAgCY5liB;2BAjCZstE,OAiCYttE;2BAlCZ43iB,SAkCY53iB;2BAnCZo+f,WAmCYp+f;2BAl6CoBygmB,sBA24ChC0L;2BA34CqBzL,UA24CrByL;2BA34CUxL,UA24CVwL;2BAt4CD,eALiC1L;;;6BAGjC,uBAHWE,gBAAWD;;;+BAmb1B,qBACuBjkmB,GAAqB,OAArBA,CAAsB,EAs9BxCinmB;2BAkBD,mBAnBC0I;2BAiBD,mBAlBCC;2BA1Z2BxC,YAyZ3ByC;2BAzZkBh0G,QAyZlBg0G;2BAzZS7mjB,QAyZT6mjB;oCFrGL,YAltCE9a,cE85B8BqY;2BFtc3B1U,OEsckB78F;2BFvclBslF,aEuckBtlF;2BFxclBwlF,aEwckBxlF;2BFzclBh5e,MEyckBg5e;2BF1clB0pF,SE0ckB1pF;2BF3clB2pF,mBE2ckB3pF;2BF5clB8mE,ME4ckB9mE;2BF7clBxyX,QE6ckBwyX;oCFrpBvBg7F,iBAtFEM,UAqSGuB;oCA/ML7B,iBAtFEM,UAoSGhW;8CAhTH+V;;;;;gCiCtRJ10hB,iBjCsRI00hB;;oCAkGFL,uBA6MKxV;2BAWD;;;+BACE;iCAbDx+jB;iD,OA5MLg0kB,iBA7GEI;+BzEhRF9xK;;2ByEolBa,0BAAiB,gBAZzBogK;2BAWK;;8CAhSR6R,qBAoRG5R;;2BAWQ,qBA3eXljD,QA+dGqgC;;;6BAWQ;8CAvfXmyB,UA2eGzrd,gBzErkBL87S;;2ByEylCKs4K,gBEvESz0iB;2BFsET00iB,mBEtES10iB;2BFqETm/e,0BErESn/e;2BFoET0liB,eEpES1liB;2BFmET20iB,mBEnES30iB;2BFkETsnf,kBElEStnf;2BFiETs0iB,oBEjESt0iB;0BF2EQ,SAAlBnrD,c,OA/3BF+4lB,YA9JA/B;0BAqiCE;gDAZC4I;2BAWD,qBAZCC;2BAWQ;;yCA/+BX3I,cAm+BG5sD;;2BAWQ,qBArhCX5kW,SAygCGmrZ;2BAWD,gBAZCiP;2BAWD,gBAZCrtD;;;;;gCAWK;;oDA1xBR+mD,mBA8wBGiG;;kCzEnlCLn4K;;;;2B2E47CI,kBAlBC4qL;2BAiBD,oBPl6CJzwB,eOg5CK0wB;2BAiBD,oBPj6CJvsF,eO+4CKq7D;2BAgBD,mBAjBC3zB;2BAeD;;;2CACE,4BAjBDhiB;;2BAhqBAm8C,WA+pBAz0gB;2BAhqBAw0gB,OAgqBAx0gB;2BAjqBA80gB,aAiqBA90gB;2BAlqBAitb,UAkqBAjtb;2BAnqBAu0gB,YAmqBAv0gB;2BApqBA4qa,iBAoqBA5qa;2BArqBAq1gB,WAqqBAr1gB;2BAtqBAgmX,UAsqBAhmX;2BA9oBD,qBAjBCy0gB;2BAgBD,qBAjBCD,OApLD6jB;2BAmMA,qBAhBCvjB,aN9lBLT;2BM6mBI,qBAhBCpnF,UD1vBPqlD;2BCwwBM,qBAfCiiC,YjBxVLzzB;2BiBqWI;;;+BAdCl2E,0BAcqDz7e,GAC5C,gBAD4CA,QAClB;;2BAHpC,qBAbCkmlB,W9CjqBHpiF;;;6B8C4qBE;;;kCAZCjtE;kD,ORtlBHykJ,kBfxGEj2J;;+BpDjEJF;;2B2Eo7CI,iCAhBCg2H;2BAoCwC;;8BhDn5C7C9gD;8BgD83CI,yBAhBCsH,mB3En6CLx8E;0B2Ew8Ca,6BAFHywL,cAE6D;uBAGvEC;;0BACF;;iEAx+BE3O,UA1XA1B;2BF8jBE;2BADA;2BAFA,gBLhUG/lB,SU0/BL3mF;2BL3rBE,gBAAgB,OiBkkBdF,SZyHJE;;;6BLz7BA++F;;8BAEAC;;+BAhBAF;kCANF,ONxDA1a,mBtC9QEx5E;;;6B4C6kCA2+F;;;;;gCAjmBFjH;;gCArIE3C;;iCAo4BAoK;;;6BLhyCA5jB;;;;+BUw0CAnmF;;;;;kCHpVFq1G;;kCAhDEhB;;;;2BA3GE;2BADA,gBAlVAtE,QAsFAM;2BA0PA,gBNnwBFx2iB,WAsDAsyhB;2BM6sBE;iD,OPplBJhC;0BMvRF,sBAKQ,IAAS1ilB,WAAT,UAASA,EAAa;0BAL9B;4BAES,UACwD,IAALA,WAAM,kBAANA;4BAA9C;gDAJau1mB;6BAIb;;gCAJaA;8CgCIzBtziB,iBhCJyBsziB;4BAIZ,gBAJ0BnijB,YAKpC;0BAHc;;2BAAZ,mCI41CHmlc;2BJ51CG;gD;0BCq2BD;;;0D;;2BADA,gBjB7TJi5D,SAvCAH;0BiBoWI,eALgB5xjB;4BACT,uBAAkCmF,MAElB,UAHPnF,KACyBmF,KAG7B,EAJInF,EAIF;0BACd,sBANa,IAAOmF,cAAP,OAAOA,IAA6C;0BAD1D,sB,ORlmBP00kB;0BQqlBE,iB7Bn1BN/yC;0B6Bm1BM;4BAMW;iDACgBt9c,cAAhBrkF;iDAAgBqkF;4BAGrB,+BAAuD;0BAX/D;;;;gCAEa;;sCACuBA,cAANrkF,gCAAMqkF;gCAG5B,QAAM;;;2BANd;2BAFA,gB9CpxBF+5a,SAgBAG;2B8CmwBE;sCAAgB;;;6B9CnwBlBA;;;;+B8CmwBE;;;iCApGJ2nG;;iCA7FEX;;;;;;mCAmwBFgL;;mCA3PEvB;+CAsUiD;uBAkBjD4B;;0BAx4CiC;2BAq5C9BrG;2BADAzI;2BADA0I;2BADAC;2BADAC;2BADAE;2BADAC;2BADAlxB;2BADA3zB;2BADAhiB;2BAFAt4d;2BACAsqe;2BAFAx5C;2BAz4C8B,oBAq5C9B+tG;2BAt+CiC1L;2BAAXC;2BAAXC;;mCACVlhmB,EAAEhD,GAAI,OAAJA,QegtCF44f,QfhtCyC;0BAI3C;0CALkCorG;2BAIT,WAJFC;;;6BAGvB,uBACO,EAJKC;;;;6BA6ciC,YRrfjDxpD,cQqfiD,WAwhC5CusD;;2BAeD;;uCACG,cAjBF0I;;2BAeD;yCAAoC,cAhBnCC;2BAvgB2BxC,YAsgB3ByC;2BAtgBkBh0G,QAsgBlBg0G;2BAtgBS7mjB,QAsgBT6mjB;oCF9LoB,YArsCrB9a,cE63B4BqY;2BAG5B,qBAHmBvxG;;;6BAEnB,0BAFU7yc,gB3Ej/BZm8X;;2B2EsgDE,kBAhBC4qL;2BAeD,oBP1+CFxwB,YO09CGywB;2BAeD,oBPz+CF9wB,YOy9CGJ;2BAeD,mBAAoC,cAhBnC3zB;2BAeD,kCAhBChiB;2BAeD,qBAjBCt4d;2BAgBD,0BAfCsqe;0BAcD,gCAhBCx5C,mB3E/+CHx8E;uB8E2PI6wL;iCHoxCIJ,MAAOrymB;0BAE4B,qBhD18C7C+2f,agD08CyD,YAFxC/2f;0BAEJ,wCAFHqymB,eAE6D;uBAc1D;;uBAGA;uBACC;;;;;;;;;;;;;;;2BAMVlG;2BADAzI;2BADA0I;2BADAC;2BADAC;2BADAE;2BADAC;2BADAlxB;2BADA3zB;2BADAhiB;2BADAt4d;2BADAsqe;2BADIx5C;;;kCACJw5C;kCACAtqe;kCACAs4d;kCACAgiB;kCACA2zB;kCACAkxB;kCACAD;kCACAF;kCACAD;kCACAD;kCACA1I;kCACAyI;;sDA6BA9J,eACAP;2DAFA5yc;;2DAFAy7c;;2DAhCAiI;2DADAD;2DAmCAzjd;;2DAtCAwjd;;2DN/rCJhgd;uBMqzCQmgd;uBAxFK;;uBAGA;;gDe1VPx9G;uBf2VQ;;gDe3VRA;uBf2VQ;;;;;;;;;;;;;;2BAMV82G;2BADAzI;2BADA0I;2BADAC;2BADAC;2BADAE;2BADAC;2BADAlxB;2BADA3zB;2BADAhiB;2BADAt4d;2BADAsqe;2BADIx5C;;;kCACJw5C;kCACAtqe;kCACAs4d;kCACAgiB;kCACA2zB;kCACAkxB;kCACAD;kCACAF;kCACAD;kCACAD;kCACA1I;kCACAyI;;sDADA9J,eACAP;2DAFA5yc;;2DAFAy7c;;2DAFAqI;2DADAD;2DAKA7jd;;2DARA4jd;;2DN7tCJpgd;uBM0zCQugd;uBA5DJ;;;;;;;;;uCA7hBKlH;0CpBhlCJztD;;uBoB6mDD;uBAI8D;wC,UAJ9D40D;;uCAAKC;sB+RpiDO;uB/RoiDZ;;;;oCAI8D;uBAJ9D,iDAI8D;uBAJ9D,yBAEI90mB,cAAa;uBAFjB,cACIA,cAAI;uBADR,eAEIA,sBAAa;uBAFjB;;;yCAEI,QAAa;;;yBAAbk1mB;;uBAFJ,eACIl1mB,sBAAI;uBADR;iDACI,QAAI,cAAJ2tH;uBADJ;iCAUQ7mH;0BACV;mCACIw2D;4B;;;;8DAZF03iB;0BAee;sDpBlhDnB5zD;2BoBihDU,kBAphBNkuD;2BAsgBK,0BACD1hf,OASI9mH;2BAVH;;;yDAEDqumB,gBAFCpzE;;;;;;;;;4DAAC;6BAADC;;yDAALizE,2BAgB+C;uBAO/C;;;;;;;;;uCA1fK/D;0CpB1oCJjxD;;uBoBooDD;uBAI8D;wC,UAJ9Dw1D;;uCAAKC;sB+R3jDO;uB/R0kDd;;;;;;;;;uCA9eKrE;0CpBrqCFpxD;;uBoBmpDH;uBAE8D;wC,UAF9D21D;uBAE8D;;0BAF9D;;;2BA9eA,IA8eAj+d;2BA9eA,IA8eAA;2BA9eA,IA8eAA;2BA9eA,GA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA;;;4D+kBpqCFwqa,c/kBoqCEl6F;2BAxgBA,KAwgBAS;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BA8eA;2BAt/BA;;;;;;8BgdnpBAwzH;gD,OxdsEA3D,4BQ6kBA7pc;;;iDR7kBA6pc,cJjCcv4E,mBY8mBdz8H;;0DR7kBAg1M,oBQ6kBA3wH;;;iDR7kBA2wH,cTwSFxrB,ciBqSE3jG;;0DR7kBAmvH,oBQ6kBApvH;;0DR7kBAovH,oBQ6kBArvH;;;iDR7kBAqvH,cQ6aEktB,cAgKF0Q;2BAwgBA;;;;;2CAxgBAjnQ,QR7kBAqpO,cF1DA3hF,cUuoBA5tC;2BvC9pBF,GuCsqCEV;2BvCtqCF;2BuCsqCE;0DvCtqCF;2BuCsqCE;;;;;;2BA3LA,KA2LA56G;2BA3LA,KA2LAA;2BA3LA,KA2LAA;2BA3LA;;;;mCF7FS0oQ;4B,OAvvBT9iB;0BAsvBE;gCE8FFzkd;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE;oDN5rBFirc,cF1LAljF,cQs3BEvmX;;;;yDAtvBFijd,oBAsvBEtrI;;0DAtvBFsrI,oBAsvBEvrI;;;2BE8FF;;;;8BF9FE;2BA1cF,GEwiBA9uC;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,KEwiBAA;2BFxiBA;oDA5SAq6K,6BA4SApkd;;yDA5SAokd,0BA4SAjoiB;;;gDNlPAyuhB,cF1LAljF,cQ4aAvuL;;;gDNlPAyxQ,cJjKc95E,mBUmZdjyJ;;;;;;8BkdxbAmuO;gD,OxdsMApC,4BMkPAhsO;;;gDNlPAgsO,mCMkPAjsO;+DNlPAisO,mBMkPAlsO;2BEwiBA;;;;oDFxiBAQ,ONlPA0rO,mBMkPAnsO;2BEmuBA;;;;;2CA3LAm7G,QFp1BAwqI,0BEo1BA5rI;2BA2LA;;;0BAppCA,UAopCAp6G;;;2BAppCA;iCAopCAA;;6BAppCA,mCVKAspJ,cULApmX;0BF23BE;2BEuwBFi6U;;uEA9eAH;0BpBrqCF,UoBmpDEzC;;;2BpBnpDF,SoBmpDEA;4BpBnpDF;kCoBmpDEA;;8BpBnpDF;;;kCoBmpDEA;mCpBnpDF;uDoBmpDE4C,cAE8D;;iC1CrpDhErxc,I0CmpDEklC;;;;2BA9eA,IA8eAq5F;2BA9eA,IA8eAA;2BA9eA,IA8eAA;2BA9eA,IA8eAA;2BA9eA,GA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,uB1CrqCFv+H,I0CmpDEklC,OA9eAk5F;4C+kBpqCF4qa,eznBDAhpiB,I0CqqCE2jC;2BAxgBA,KAwgBA2ra;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA;;4BgdnpBAyzH;;gC,OxdsEA3D;8BlChFFp/jB;8B0C6pBE0jC;;kCR7kBA07hB,eJjCcv4E,iB9B/ChB7mf,I0C6pBEqnC;kCR7kBA+3hB,qBlChFFp/jB,I0C6pBE6oC;kCR7kBAu2hB,eTwSFxrB,ezBxXA5ziB,I0C6pBE+oC;kCR7kBAq2hB,qBlChFFp/jB,I0C6pBE8oC;kCR7kBAs2hB,qBlChFFp/jB,I0C6pBEkqC;kCR7kBAk1hB,eQ6aEktB,e1C7fJtslB,I0C6pBEiqC;2BAwgBAF,ORrlCAq1hB,eF1DA3hF,ehCtBFz9e,I0C6pBEgqC;2BvC9pBF,GuCsqCEkla;2BvCtqCF,GuCsqCEA;2BvCtqCF,8BHCAlvc,I0CqqCE+pC,OvCtqCFiI;2BHCA;4BGDAC;8BHCA;;2B0CqqCE,uB1CrqCFjyC,I0CqqCEi6B;iD1CrqCFj6B,I0CqqCEyjC;iD1CrqCFzjC,I0CqqCEwjC;kE1CrqCFxjC,I0CqqCEujC;2BA3LA,KA2LA+wT;2BA3LA,KA2LAA;2BA3LA,KA2LAA;2BF7OA;;;mCA3CS4oQ;4B,OAvvBT/iB;0BAsvBE;gCE8FF1kd;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE/vF,ON5rBFi7hB,eF1LAljF,ehCtBFz9e,I0C0+BEokC,OF9FE6yF;8CxC54BJj3H,IwC44BI0lC;8CxC54BJ1lC,IwC44BIqgC;kCAtvBF85iB,qBxCtJFn6kB,IwC44BIugC;kCAtvBF45iB,qBxCtJFn6kB,IwC44BIglC;kDxC54BJhlC,IwC44BI2lC;kDxC54BJ3lC,IwC44BI2gC;2BA1cF,GEwiBAkua;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,KEwiBAA;2BFxiBA,KEwiBAA;2BFxiBAppa,OA5SA00iB,8BxCtJFn6kB,I0C0+BEsjC,MFxiBAwyF;kCA5SAqkd,2BxCtJFn6kB,IwCkcEylC;kCNlPAk7hB,eF1LAljF,ehCtBFz9e,IwCkcEwlC;kCNlPAm7hB,eJjKc95E,iB9B/ChB7mf,IwCkcEulC;;;4BkdxbAw9hB;;gC,OxdsMApC;8BlChNF3gkB;8BwCkcE2nC;;kCNlPAg5hB,oClChNF3gkB,IwCkcE0nC;kCNlPAi5hB,oBlChNF3gkB,IwCkcEynC;2BEwiBAF,OR1xBAo5hB,oBlChNF3gkB,IwCkcEwnC;2BEmuBAF,OF/gCA6yiB,2BxCtJFn6kB,I0C0+BEunC;2BA2LA,uB1CrqCFvnC,I0CqqCEsnC;kD1CrqCFtnC,I0CqqCEwkC;0BApiCA,OAoiCA2vT;8CApiCA,mB1CjIFn0V,I0CiIEukC;uCAoiCAQ,OApiCA,mB1CjIF/kC,I0CiIEukC;wCAoiCAQ,OApiCA,mB1CjIF/kC,I0CiIEukC;0BAhHA,UAopCA2vT;2BAppCA;4BAkoDAjvT;6BA9eAivT;+BAppCA,mB1CjBFl0V,I0CqqCE+kC;+BAppCA,mB1CjBF/kC,I0CqqCE+kC;;2BAppCA;iCAopCAmvT;4BAppCA,yB1CjBFl0V,I0CqqCE+kC;4BA8eAE,OAloDA,WVKAw4c,ehCtBFz9e,I0CiBEqjC;0BpBjBF,UoBmpDEkra;2BpBnpDF,0BtBAAvuc,I0CmpDEilC;;4BpBnpDF,SoBmpDEspa;8BpBnpDF,SoBmpDEA,QpBnpDF,yBtBAAvuc,I0CmpDEilC;8BpBnpDF,oCtBAAjlC,IsBAAk8B;qCoBmpDEqya,QpBnpDF,yBtBAAvuc,I0CmpDEilC;4BpBnpDF,sBtBAAjlC,IsBAAs+B,YoBqpDgE;;iC1CrpDhEt+B;0B0CsqCM;sD1CtqCNA;2B0CuqCM,sB+kBtqCNipiB,eznBDAjpiB;2B0C6pBE;2BACI2nc;4BgdppBJq7H;;gC,OxdsEA3D;8BlChFFr/jB;;2B0CgqBMo9lB,aRhlBJ/9B,eJjCcr4E,c9B/ChBhnf;2B0CiqBMunkB,mBRjlBJlI,qBlChFFr/jB;2B0CmqBMitkB,cRnlBJ5N,eTwSFxrB,ezBxXA7ziB;2B0CoqBM4nkB,YRplBJvI,qBlChFFr/jB;2B0CqqBMsskB,eRrlBJjN,qBlChFFr/jB;2B0CuqBM2skB,SRvlBJtN,eQ6aEktB,e1C7fJvslB;2B0CwqBM0skB,aRxlBJrN,eFzDE3hF,ehCvBJ19e;2B0CwqCM44lB;;6BA1gBAjxJ;6BAEAy1J;6BACA71B;6BAEA0F;6BACArF;6BACA0E;6BAEAK;6BACAD;2BvCvqBF,sCHDJ1skB;;;;;;2B0CyqCM24lB,oBvCxqCFz2F,YAAwBD;2BuC0qCtB,kC1C3qCNjigB;2B0C4qCM,wB1C5qCNA;2B0C6qCM,yB1C7qCNA;2B0C8qCM,4C1C9qCNA;2BwCw7BE;;;mCA3CSq2hB;4B,OAvvBT+jD;0BAwwBM;2BADAkL;4BN7sBN1kB,eFzLEljF,ehCvBJ19e;2BwC85BQ,8BxC95BRA;2BwC06BQ,+BxC16BRA;2BwC26BQozkB,iBArxBNgH,qBxCtJFp6kB;2BwC46BQsvb;4BAtxBN8qJ,qBxCtJFp6kB;2BwC66BQ,mCxC76BRA;2BwC86BQ,gCxC96BRA;2BwC86BQ;;6BAjBAsllB;6BACA/1J;6BAYA81J;6BACAjS;6BACA9jJ;6BACA81J;6BACAD;2BA3eF5Y,UA7SJ6N,8BxCtJFp6kB;2BwCocM8ojB,QA9SJsxB,2BxCtJFp6kB;2BwCqcMwskB;4BNrPJ5L,eFzLEljF,ehCvBJ19e;2BwCscMyskB,WNtPJ7L,eJjKc55E,c9B/ChBhnf;;2BwCucMs1Y;4Bkd7bJ0tL;;gC,OxdsMApC;8BlChNF5gkB;;2BwCwcMynkB;4BNxPJ7G,oClChNF5gkB;2BwCycM2nkB,eNzPJ/G,oBlChNF5gkB;2BwC0cMq9kB,SN1PJzc,oBlChNF5gkB;2B0C4+BM84lB;;6BFziBAvsB;6BACAzjB;6BACA0jB;6BACAC;6BACAn3L;6BACAmyL;6BACAE;6BACA0V;2BEmiBAwb,cFv1BJze,2BxCtJFp6kB;2B0C+qCMu4lB,mBApMAppS,UACA2pS,UACAD;2BAmMA,sC1ChrCN74lB;2B0CirCM,+C1CjrCNA;2B0CiIE,0B1CjIFA;0B0CiIE;+BAijCIo4lB,gBAjjCJ,uB1CjIFj1d;;;wC0CkrCMi1d;;;0BFpRE,YE74BN,kB1CjBFp4lB;0B0CiBE;+BAkqCIm4lB,qBAlqCJ,uB1CjBFh1d;;;wC0CmrCMg1d;;8BAlqCJ;kDVMEz6G,ehCvBJ19e;+B0CmrCMm4lB,wBAlqCJjnG;;yCAkqCIinG;0BFrRE;2BEsvBFtpC;;6B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gO,egmBjEA+C,exlB8oBAzjO;kCR7kBA0gO,eTwSFhpB,eiBqSEz3M;kCR7kBAygO,ekBvDE18d,cVooBFk8P;kCR7kBAwgO,ekBvDE18d,cVooBFm8P;kCR7kBAugO,eQ6aEitB,eAgKF75N;2BAwgBAE,ORrlCA0sM,qBQ6kBA3sM;;2B1C7pBF3oR,+B0CqqCE4oR;;;8B1CrqCsC,2BAAxC5oR;8BAAoC,2BAApCA;2B0CqqCEuoR;kCApGEkhO,eAoGFlhO;kCApGEkhO,eAoGFjhO;2BF5OIH,wCE4OJI;;;mCFzREqsO,iBA8CE90f;4B,OApyBJwwe,4BAoyBIxwe;;2BA9CFy0P,ON5rBFoiO,qBMyuBIxuM;2BA7CFl0B;2BAgDEC,OAhDF0gQ;2BA+CEvgQ,OAryBJi8O,+BAsyBIp8O;2BAhDFI,OAtvBFg8O,4BAqyBIj8O;2BA/CFF;2BE8FFC,OF9FEoiP;;2BA1cF/iP,MA5SA68O,+BEo1BAl8O;2BFxiBAV,MA5SA48O,4BA4SA78O;iCNlPAkjO,qBMkPAjjO;iCNlPAijO,eEoBAp5E,eI8NA5pJ;;;;8BkdxbAhb;uCld6bY74O;gC,ONvPZ62d,qCMuPY72d;8BALZ8zP;;iCNlPA+iO,qCMkPA9iO;iCNlPA8iO,6BMkPA7iO;2BEwiBAE,OR1xBA2iO,6BMkPA5iO;2BEmuBA40B,OF/gCA2nN,4BEo1BAt8O;2BA2LAsgH;2BApiCAG,gCAoiCAH;;;wCAniCE,2BADFG;;iCAoiCAC,OA/hCE,2BALFD;wCAoiCAC,OA1hCE,2BAVFD;;;2BA5GE;4BA8nDFK;;+BA9nDE,2BAgpCFJ;+BAlpCE,2BAkpCFA;;2BAjpCE;;8DAipCFA;4BA8eAI,OA/nDE,WsiByGJi+B,etiBzGIv+I;oCA+nDF3zW;;2BpBhpDA,kCoBgpDAi0d;;;8BpBlpDA,iDoBkpDAA;8BpBlpDA;4BACA;;8DoBipDAA;4BpBjpDA;uBoBmpD8D;iCAF9Dn6d;0B,IAAAmlH,I6Ev+CAzH;;mC1E8JAs8f,yBHy0CA70f,OAE8D;uBAF9D;uCAAKsyf;sB+R1kDS;uB/R0kDd;;;;;;;;;;;4B;4BAAA;;;;;;;;;;sCkB1oCE;wClB0oCF;;;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AuB8hC,M6BY/Bq0H,YAkDFtuJ,I7B9DUC,IAAuB+xC;qC6BY/Bs8G,YAkDFtuJ,I7B9DiCi6B;;6BAAvBs0D,O6B8DVhnG;6B7B9DU20C,MsDyXZ8mG,sBzB3TEhjI;mCAlDEsuJ,YAkDFtuJ,I7B9DUk8B,a6B+DqC;8BAD/CszH;gDAA4BxvJ;4B,O7B9D9B+9hB,e6BYIrvY,aAkD0B1uJ;mCAA5B0vJ;4B,O7B9DFsuY,e6BYItvY,aAkDF1uJ,YAC+C;;2BAD/C2vJ;sCAAKvB,cAALoB;;;4B,gB7B9DF/0D;;gE6BYIu6D,U7BZJv6D;;;;;oDAC+C;qC6B6D7ClyG;;4B7B9DF,c6B8DEhB;;+B7B9DUI,G6B8DVJ;+B7B9DiCyqD,GAAvBrqD;+BAAuB4iD,KAAvB5iD;+BAAuB8vI,K6BY/B3uB,U7BZ+Bv+D;oC6BY/Bu+D,U7BZ+B92D;;gCAAvB0lF,K6B8DVnwI;kDAlDEuhH,U7BZQ4uB;mC6B8DV7oC;4BAA4B,S7B9D9B8qC,M6B8DWK,wCAAkB;4B7B9D7B,G6B8DEg5e,gB7B9DF;0C6B8DEA;;gC7B9DiC;iCAAnCx/c,U6B8DEz5B;iC7B9DF05B,S6B8DEu/c;iC7B9DiCh6M,MAAnCvlQ;iCAAmCwlQ,MAAnCxlQ;iCAAmCylQ,MAAnC1lQ;iCAAmC2lQ,MAAnC3lQ;iCAAmC;+CAAK,MAALwlQ;;uC6B8DjCj/R;mC7B9DF+kW,U6B8DE/kW,S7B9DFglW,S6B8DEi0I;sC7B9DFr5e;gD6B8DEq5e,YAAkD;mCAAlD70gB;4BAA4B,S7B9D9Bw7B,M6B8DW4+c,sCAAkB;4B7B9D7B,G6B8DEC,gB7B9DF;0C6B8DEA;;gC7B9DiC;iCAAnCl5G,U6B8DEplW;iC7B9DFqlW,S6B8DEi5G;iC7B9DiC18c,MAAnCyjW;iCAAmC5jW,MAAnC4jW;iCAAmC74G,MAAnC44G;iCAAmCzjW,MAAnCyjW;iCAAmC;6CAAnC3lW,MAAmCmC;;uC6B8DjC5B;mC7B9DFglW,U6B8DEhlW,S7B9DFilW,S6B8DEq5G;sC7B9DF7+c;8C6B8DE6+c,YAAkD;mCAAlDj7X;4B,cAAAryN;;+B7B9DF3D,E6B8DE2D;+B7B9DFi/G,+B6B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BAy+c,0BA6BAzhM;mCiDwgBEv5J;4BjDxgBF;gCiDwgBEnuK;6BjDxgBF,GiDwgBEA;6BjDxgBF,GiDwgBEA;;;;6BjDxgBF20C;8B/G8HNonI;yC+G7HoBtjK;;mCAACiyC;;0DAADjyC,QAACgyC;oDiDqEb4uH,ejDrEY5gK,IAACi6B;gCiDugBbj6B;;gCjDxgBFgyC;4CiDsEE4uH,eAkcA5gK,IjDxgBFk8B;mCA7BA20d,2BiDqiBE7wf,IjDxgBFC,OiD6gB8B;8BAL5Bo+mB;iDAIEr+mB;4BjD5gBJ,sCiD4gBImjI;mCAJFm7e;;;;;6BjDvgBErrH;8B/G6HV1vV;yC+G7HUvjK;;mCAAWgyC,oBAAXhyC;mCAAWiyC,ciDqEb4uH,cjDrEE7gK;4CAAWgyC;gCiDugBbhyC;;6BjDtgBE,mBiDoEF6gK,cAkcA7gK;6BjDrgBE+yf,OAhCJ/B,2BiDqiBEhxf;sCjDvgBEizf,UACAD,QACAD,OiD0gB0B;;2BAL5BwrH;uCAAKH,eAALC;;;;;;;;4BjDxgBF,SiDwgBE91nB,KjDxgBF,2CiDwgBEA;4BjDxgBF;yCiDwgBEA;6BjDxgBF;;;;;;;;;;;;;;;;sC2D0eE;wC3D1eF;;;;;;;;;2FiDwgBEA,EjDngBuB;mDALzBsuI;;;;;;;2CAGI;qEAHJF;;6CAGI;;gEAhCJ06X,0BAgCIt7U;;;0CAFA;oEADJp/C;;4CACI;;;8C8DscJl7B;yD9DtcehB;kDAAD,SAACA;;;;;;;;;;;kFADf1rD,aACe0rD,KAAgB;gDAA3Bu7E;;;yCACA;mEAFJr/C;;2CAEI;;;;wCAFJ;;;;uFiDwgBEpuI;8BjDxgBF;8EiDwgBEA;8BjDxgBF;qCACIkqgB;+BADJ,MAEIC;+BAFJ,MAGIC;;;;iCADAE;iCADAC;wDACAD,YACAD;8BAHJ;;uCiDwgBErqgB;;iDjDvgBEkqgB;;kDACAC;qDACAC;mCiDqgBF+rH;4BjDxgBF;oCiDwgBEn3nB;6BjDxgBF,QiDwgBEA;6BjDxgBF,UiDwgBEA;;6BjDrgBE2D;8BAhCJomgB;mFAgCIyB;;6BADA,iBiDoEFn8Y,ajDpEEo8Y;iEACAl7X;6BAFAngD;8B8D4cJ+hB;;;mC9D5c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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 caml_named_value, caml_global_data, caml_string_of_jsstring\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 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//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 globalThis.Error(str);\n // otherwise, just throw an unhelpful error\n console.dir(err, { depth: 10 });\n throw globalThis.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","/* global plonk_wasm, caml_jsstring_of_string, 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: tsBindings\nvar tsBindings = globalThis.__snarkyTsBindings;\n\n// Provides: tsRustConversion\n// Requires: tsBindings, plonk_wasm\nvar tsRustConversion = tsBindings.rustConversion(plonk_wasm);\n\n// Provides: tsSrs\n// Requires: tsBindings, plonk_wasm\nvar tsSrs = tsBindings.srs(plonk_wasm);\n\n// Provides: getTsBindings\n// Requires: tsBindings\nfunction getTsBindings() {\n return tsBindings;\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 globalThis.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_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: free_finalization_registry\nvar free_finalization_registry = new globalThis.FinalizationRegistry(function (\n instance_representative\n) {\n instance_representative.free();\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.__wbg_ptr);\n free_finalization_registry.register(x, instance_representative, x);\n return x;\n};\n\n// srs\n\n// Provides: caml_fp_srs_create\n// Requires: tsSrs\nvar caml_fp_srs_create = tsSrs.fp.create;\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: tsSrs\nvar caml_fp_srs_lagrange_commitment = tsSrs.fp.lagrangeCommitment;\n\n// Provides: caml_fp_srs_commit_evaluations\n// Requires: plonk_wasm, tsRustConversion\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 tsRustConversion.fp.vectorToRust(fps)\n );\n return tsRustConversion.fp.polyCommFromRust(res);\n};\n\n// Provides: caml_fp_srs_b_poly_commitment\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fp_srs_b_poly_commitment = function (srs, chals) {\n var res = plonk_wasm.caml_fp_srs_b_poly_commitment(\n srs,\n tsRustConversion.fieldsToRustFlat(chals)\n );\n return tsRustConversion.fp.polyCommFromRust(res);\n};\n\n// Provides: caml_fp_srs_batch_accumulator_check\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fp_srs_batch_accumulator_check = function (srs, comms, chals) {\n var rust_comms = tsRustConversion.fp.pointsToRust(comms);\n var rust_chals = tsRustConversion.fp.vectorToRust(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, tsRustConversion\nvar caml_fp_srs_batch_accumulator_generate = function (srs, n_comms, chals) {\n var rust_chals = tsRustConversion.fp.vectorToRust(chals);\n var rust_comms = plonk_wasm.caml_fp_srs_batch_accumulator_generate(\n srs,\n n_comms,\n rust_chals\n );\n return tsRustConversion.fp.pointsFromRust(rust_comms);\n};\n\n// Provides: caml_fp_srs_h\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fp_srs_h = function (t) {\n return tsRustConversion.fp.pointFromRust(plonk_wasm.caml_fp_srs_h(t));\n};\n\n// Provides: caml_fp_srs_add_lagrange_basis\n// Requires: tsSrs\nvar caml_fp_srs_add_lagrange_basis = tsSrs.fp.addLagrangeBasis;\n\n// Provides: caml_fq_srs_create\n// Requires: tsSrs\nvar caml_fq_srs_create = tsSrs.fq.create;\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: tsSrs\nvar caml_fq_srs_lagrange_commitment = tsSrs.fq.lagrangeCommitment;\n\n// Provides: caml_fq_srs_commit_evaluations\n// Requires: plonk_wasm, tsRustConversion\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 tsRustConversion.fq.vectorToRust(fqs)\n );\n return tsRustConversion.fq.polyCommFromRust(res);\n};\n\n// Provides: caml_fq_srs_b_poly_commitment\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fq_srs_b_poly_commitment = function (srs, chals) {\n var res = plonk_wasm.caml_fq_srs_b_poly_commitment(\n srs,\n tsRustConversion.fieldsToRustFlat(chals)\n );\n return tsRustConversion.fq.polyCommFromRust(res);\n};\n\n// Provides: caml_fq_srs_batch_accumulator_check\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fq_srs_batch_accumulator_check = function (srs, comms, chals) {\n var rust_comms = tsRustConversion.fq.pointsToRust(comms);\n var rust_chals = tsRustConversion.fq.vectorToRust(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, tsRustConversion\nvar caml_fq_srs_batch_accumulator_generate = function (srs, comms, chals) {\n var rust_chals = tsRustConversion.fq.vectorToRust(chals);\n var rust_comms = plonk_wasm.caml_fq_srs_batch_accumulator_generate(\n srs,\n comms,\n rust_chals\n );\n return tsRustConversion.fq.pointsFromRust(rust_comms);\n};\n\n// Provides: caml_fq_srs_h\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fq_srs_h = function (t) {\n return tsRustConversion.fq.pointFromRust(plonk_wasm.caml_fq_srs_h(t));\n};\n\n// Provides: caml_fq_srs_add_lagrange_basis\n// Requires: tsSrs\nvar caml_fq_srs_add_lagrange_basis = tsSrs.fq.addLagrangeBasis;\n\n// gate vector\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, tsRustConversion\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 tsRustConversion.fp.gateToRust(x)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_get\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_gate_vector_get = function (v, i) {\n return tsRustConversion.fp.gateFromRust(\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, tsRustConversion\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 tsRustConversion.wireToRust(x),\n tsRustConversion.wireToRust(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// prover index\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, tsRustConversion\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 tsRustConversion.fq.gateToRust(x)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_get\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fq_plonk_gate_vector_get = function (v, i) {\n return tsRustConversion.fq.gateFromRust(\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, tsRustConversion\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 tsRustConversion.wireToRust(x),\n tsRustConversion.wireToRust(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_pasta_fp_plonk_index_create\n// Requires: plonk_wasm, free_on_finalize, tsRustConversion\nvar caml_pasta_fp_plonk_index_create = function (\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n var wasm_lookup_tables =\n tsRustConversion.fp.lookupTablesToRust(caml_lookup_tables);\n var wasm_runtime_table_cfgs = tsRustConversion.fp.runtimeTableCfgsToRust(\n caml_runtime_table_cfgs\n );\n\n var t = plonk_wasm.caml_pasta_fp_plonk_index_create(\n gates,\n public_inputs,\n wasm_lookup_tables,\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_create_bytecode\n// Requires: caml_pasta_fp_plonk_index_create\nvar caml_pasta_fp_plonk_index_create_bytecode = function (\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n return caml_pasta_fp_plonk_index_create(\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n );\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_pasta_fq_plonk_index_create\n// Requires: plonk_wasm, free_on_finalize, tsRustConversion\nvar caml_pasta_fq_plonk_index_create = function (\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n var wasm_lookup_tables =\n tsRustConversion.fq.lookupTablesToRust(caml_lookup_tables);\n var wasm_runtime_table_cfgs = tsRustConversion.fq.runtimeTableCfgsToRust(\n caml_runtime_table_cfgs\n );\n\n return free_on_finalize(\n plonk_wasm.caml_pasta_fq_plonk_index_create(\n gates,\n public_inputs,\n wasm_lookup_tables,\n wasm_runtime_table_cfgs,\n prev_challenges,\n urs\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_index_create_bytecode\n// Requires: caml_pasta_fq_plonk_index_create\nvar caml_pasta_fq_plonk_index_create_bytecode = function (\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n return caml_pasta_fq_plonk_index_create(\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\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// verifier index\n\n// Provides: caml_opt_of_rust\nvar caml_opt_of_rust = function (value, value_of_rust) {\n if (value === undefined) {\n return 0;\n } else {\n return [0, value_of_rust(value)];\n }\n};\n\n// Provides: caml_opt_to_rust\nvar caml_opt_to_rust = function (caml_optional_value, to_rust) {\n // to_rust expects the parameters of the variant. A `Some vx` is represented\n // as [0, vx]\n if (caml_optional_value === 0) {\n return undefined;\n } else {\n return to_rust(caml_optional_value[1]);\n }\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_create\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_verifier_index_create = function (x) {\n var vk = plonk_wasm.caml_pasta_fp_plonk_verifier_index_create(x);\n return tsRustConversion.fp.verifierIndexFromRust(vk);\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_read\n// Requires: plonk_wasm, caml_jsstring_of_string, tsRustConversion\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 tsRustConversion.fp.verifierIndexFromRust(\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, tsRustConversion\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 tsRustConversion.fp.verifierIndexToRust(t),\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_shifts\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_verifier_index_shifts = function (log2_size) {\n return tsRustConversion.fp.shiftsFromRust(\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, tsRustConversion\nvar caml_pasta_fp_plonk_verifier_index_dummy = function () {\n var res = plonk_wasm.caml_pasta_fp_plonk_verifier_index_dummy();\n return tsRustConversion.fp.verifierIndexFromRust(res);\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_deep_copy\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_verifier_index_deep_copy = function (x) {\n return tsRustConversion.fp.verifierIndexFromRust(\n plonk_wasm.caml_pasta_fp_plonk_verifier_index_deep_copy(\n tsRustConversion.fp.verifierIndexToRust(x)\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_create\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fq_plonk_verifier_index_create = function (x) {\n return tsRustConversion.fq.verifierIndexFromRust(\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, tsRustConversion\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 tsRustConversion.fq.verifierIndexFromRust(\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, tsRustConversion\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 tsRustConversion.fq.verifierIndexToRust(t),\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_shifts\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fq_plonk_verifier_index_shifts = function (log2_size) {\n return tsRustConversion.fq.shiftsFromRust(\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, tsRustConversion\nvar caml_pasta_fq_plonk_verifier_index_dummy = function () {\n return tsRustConversion.fq.verifierIndexFromRust(\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, tsRustConversion, tsRustConversion\nvar caml_pasta_fq_plonk_verifier_index_deep_copy = function (x) {\n return tsRustConversion.fq.verifierIndexFromRust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_deep_copy(\n tsRustConversion.fq.verifierIndexToRust(x)\n )\n );\n};\n\n// proof\n\n// Provides: caml_pasta_fp_plonk_proof_create\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_proof_create = function (\n index,\n witness_cols,\n caml_runtime_tables,\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(tsRustConversion.fp.vectorToRust(witness_cols[i]));\n }\n witness_cols = w;\n prev_challenges = tsRustConversion.fp.vectorToRust(prev_challenges);\n var wasm_runtime_tables =\n tsRustConversion.fp.runtimeTablesToRust(caml_runtime_tables);\n prev_sgs = tsRustConversion.fp.pointsToRust(prev_sgs);\n var proof = plonk_wasm.caml_pasta_fp_plonk_proof_create(\n index,\n witness_cols,\n wasm_runtime_tables,\n prev_challenges,\n prev_sgs\n );\n return tsRustConversion.fp.proofFromRust(proof);\n};\n\n// Provides: caml_pasta_fp_plonk_proof_verify\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_proof_verify = function (index, proof) {\n index = tsRustConversion.fp.verifierIndexToRust(index);\n proof = tsRustConversion.fp.proofToRust(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, tsRustConversion\nvar caml_pasta_fp_plonk_proof_batch_verify = function (indexes, proofs) {\n indexes = tsRustConversion.mapMlArrayToRustVector(\n indexes,\n tsRustConversion.fp.verifierIndexToRust\n );\n proofs = tsRustConversion.mapMlArrayToRustVector(\n proofs,\n tsRustConversion.fp.proofToRust\n );\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, tsRustConversion\nvar caml_pasta_fp_plonk_proof_dummy = function () {\n return tsRustConversion.fp.proofFromRust(\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, tsRustConversion\nvar caml_pasta_fp_plonk_proof_deep_copy = function (proof) {\n return tsRustConversion.fp.proofFromRust(\n plonk_wasm.caml_pasta_fp_plonk_proof_deep_copy(\n tsRustConversion.fp.proofToRust(proof)\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_proof_create\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fq_plonk_proof_create = function (\n index,\n witness_cols,\n caml_runtime_tables,\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(tsRustConversion.fq.vectorToRust(witness_cols[i]));\n }\n witness_cols = w;\n prev_challenges = tsRustConversion.fq.vectorToRust(prev_challenges);\n var wasm_runtime_tables =\n tsRustConversion.fq.runtimeTablesToRust(caml_runtime_tables);\n prev_sgs = tsRustConversion.fq.pointsToRust(prev_sgs);\n var proof = plonk_wasm.caml_pasta_fq_plonk_proof_create(\n index,\n witness_cols,\n wasm_runtime_tables,\n prev_challenges,\n prev_sgs\n );\n return tsRustConversion.fq.proofFromRust(proof);\n};\n\n// Provides: caml_pasta_fq_plonk_proof_verify\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fq_plonk_proof_verify = function (index, proof) {\n index = tsRustConversion.fq.verifierIndexToRust(index);\n proof = tsRustConversion.fq.proofToRust(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, tsRustConversion\nvar caml_pasta_fq_plonk_proof_batch_verify = function (indexes, proofs) {\n indexes = tsRustConversion.mapMlArrayToRustVector(\n indexes,\n tsRustConversion.fq.verifierIndexToRust\n );\n proofs = tsRustConversion.mapMlArrayToRustVector(\n proofs,\n tsRustConversion.fq.proofToRust\n );\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, tsRustConversion\nvar caml_pasta_fq_plonk_proof_dummy = function () {\n return tsRustConversion.fq.proofFromRust(\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, tsRustConversion\nvar caml_pasta_fq_plonk_proof_deep_copy = function (proof) {\n return tsRustConversion.fq.proofFromRust(\n plonk_wasm.caml_pasta_fq_plonk_proof_deep_copy(\n tsRustConversion.fq.proofToRust(proof)\n )\n );\n};\n\n// oracles\n\n// Provides: fp_oracles_create\n// Requires: plonk_wasm, tsRustConversion\nvar fp_oracles_create = function (lgr_comm, verifier_index, proof) {\n return tsRustConversion.fp.oraclesFromRust(\n plonk_wasm.fp_oracles_create(\n tsRustConversion.fp.polyCommsToRust(lgr_comm),\n tsRustConversion.fp.verifierIndexToRust(verifier_index),\n tsRustConversion.fp.proofToRust(proof)\n )\n );\n};\n\n// Provides: fp_oracles_create_no_public\n// Requires: fp_oracles_create\nvar fp_oracles_create_no_public = function (lgr_comm, verifier_index, proof) {\n return fp_oracles_create(lgr_comm, verifier_index, [0, 0, proof]);\n};\n\n// Provides: fp_oracles_dummy\n// Requires: plonk_wasm, tsRustConversion\nvar fp_oracles_dummy = function () {\n return tsRustConversion.fp.oraclesFromRust(plonk_wasm.fp_oracles_dummy());\n};\n\n// Provides: fp_oracles_deep_copy\n// Requires: plonk_wasm, tsRustConversion\nvar fp_oracles_deep_copy = function (x) {\n return tsRustConversion.fp.oraclesFromRust(\n plonk_wasm.fp_oracles_deep_copy(tsRustConversion.fp.oraclesToRust(x))\n );\n};\n\n// Provides: fq_oracles_create\n// Requires: plonk_wasm, tsRustConversion\nvar fq_oracles_create = function (lgr_comm, verifier_index, proof) {\n return tsRustConversion.fq.oraclesFromRust(\n plonk_wasm.fq_oracles_create(\n tsRustConversion.fq.polyCommsToRust(lgr_comm),\n tsRustConversion.fq.verifierIndexToRust(verifier_index),\n tsRustConversion.fq.proofToRust(proof)\n )\n );\n};\n\n// Provides: fq_oracles_create_no_public\n// Requires: fq_oracles_create\nvar fq_oracles_create_no_public = function (lgr_comm, verifier_index, proof) {\n return fq_oracles_create(lgr_comm, verifier_index, [0, 0, proof]);\n};\n\n// Provides: fq_oracles_dummy\n// Requires: plonk_wasm, tsRustConversion\nvar fq_oracles_dummy = function () {\n return tsRustConversion.fq.oraclesFromRust(plonk_wasm.fq_oracles_dummy());\n};\n\n// Provides: fq_oracles_deep_copy\n// Requires: plonk_wasm, tsRustConversion\nvar fq_oracles_deep_copy = function (x) {\n return tsRustConversion.fq.oraclesFromRust(\n plonk_wasm.fq_oracles_deep_copy(tsRustConversion.fq.oraclesToRust(x))\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, tsRustConversion, tsRustConversion\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 tsRustConversion.fp.vectorToRust(fp_vector)\n );\n var new_fp_vector = tsRustConversion.fp.vectorFromRust(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, tsRustConversion, tsRustConversion\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 tsRustConversion.fq.vectorToRust(fq_vector)\n );\n var new_fq_vector = tsRustConversion.fq.vectorFromRust(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","/* global tsBindings\n*/\n\n// Provides: caml_bigint_256_of_numeral\n// Requires: tsBindings\nvar caml_bigint_256_of_numeral = tsBindings.caml_bigint_256_of_numeral;\n\n// Provides: caml_bigint_256_of_decimal_string\n// Requires: tsBindings\nvar caml_bigint_256_of_decimal_string = tsBindings.caml_bigint_256_of_decimal_string;\n\n// Provides: caml_bigint_256_num_limbs\n// Requires: tsBindings\nvar caml_bigint_256_num_limbs = tsBindings.caml_bigint_256_num_limbs;\n\n// Provides: caml_bigint_256_bytes_per_limb\n// Requires: tsBindings\nvar caml_bigint_256_bytes_per_limb = tsBindings.caml_bigint_256_bytes_per_limb;\n\n// Provides: caml_bigint_256_div\n// Requires: tsBindings\nvar caml_bigint_256_div = tsBindings.caml_bigint_256_div;\n\n// Provides: caml_bigint_256_compare\n// Requires: tsBindings\nvar caml_bigint_256_compare = tsBindings.caml_bigint_256_compare;\n\n// Provides: caml_bigint_256_print\n// Requires: tsBindings\nvar caml_bigint_256_print = tsBindings.caml_bigint_256_print;\n\n// Provides: caml_bigint_256_to_string\n// Requires: tsBindings\nvar caml_bigint_256_to_string = tsBindings.caml_bigint_256_to_string;\n\n// Provides: caml_bigint_256_test_bit\n// Requires: tsBindings\nvar caml_bigint_256_test_bit = tsBindings.caml_bigint_256_test_bit;\n\n// Provides: caml_bigint_256_to_bytes\n// Requires: tsBindings\nvar caml_bigint_256_to_bytes = tsBindings.caml_bigint_256_to_bytes;\n\n// Provides: caml_bigint_256_of_bytes\n// Requires: tsBindings\nvar caml_bigint_256_of_bytes = tsBindings.caml_bigint_256_of_bytes;\n\n// Provides: caml_bigint_256_deep_copy\n// Requires: tsBindings\nvar caml_bigint_256_deep_copy = tsBindings.caml_bigint_256_deep_copy\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","// Provides: plonk_wasm\nvar plonk_wasm = require('./plonk_wasm.js');\n","/* global tsBindings */\n\n// fp\n\n// Provides: caml_fp_vector_create\n// Requires: tsBindings\nvar caml_fp_vector_create = tsBindings.caml_fp_vector_create;\n\n// Provides: caml_fp_vector_length\n// Requires: tsBindings\nvar caml_fp_vector_length = tsBindings.caml_fp_vector_length;\n\n// Provides: caml_fp_vector_emplace_back\n// Requires: tsBindings\nvar caml_fp_vector_emplace_back = tsBindings.caml_fp_vector_emplace_back;\n\n// Provides: caml_fp_vector_get\n// Requires: tsBindings\nvar caml_fp_vector_get = tsBindings.caml_fp_vector_get;\n\n// Provides: caml_fp_vector_set\n// Requires: tsBindings\nvar caml_fp_vector_set = tsBindings.caml_fp_vector_set;\n\n// fq\n\n// Provides: caml_fq_vector_create\n// Requires: tsBindings\nvar caml_fq_vector_create = tsBindings.caml_fq_vector_create;\n\n// Provides: caml_fq_vector_length\n// Requires: tsBindings\nvar caml_fq_vector_length = tsBindings.caml_fq_vector_length;\n\n// Provides: caml_fq_vector_emplace_back\n// Requires: tsBindings\nvar caml_fq_vector_emplace_back = tsBindings.caml_fq_vector_emplace_back;\n\n// Provides: caml_fq_vector_get\n// Requires: tsBindings\nvar caml_fq_vector_get = tsBindings.caml_fq_vector_get;\n\n// Provides: caml_fq_vector_set\n// Requires: tsBindings\nvar caml_fq_vector_set = tsBindings.caml_fq_vector_set;\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","/* global tsBindings\n*/\n\n// pallas\n\n// Provides: caml_pallas_one\n// Requires: tsBindings\nvar caml_pallas_one = tsBindings.caml_pallas_one;\n\n// Provides: caml_pallas_add\n// Requires: tsBindings\nvar caml_pallas_add = tsBindings.caml_pallas_add;\n\n// Provides: caml_pallas_sub\n// Requires: tsBindings\nvar caml_pallas_sub = tsBindings.caml_pallas_sub;\n\n// Provides: caml_pallas_negate\n// Requires: tsBindings\nvar caml_pallas_negate = tsBindings.caml_pallas_negate;\n\n// Provides: caml_pallas_double\n// Requires: tsBindings\nvar caml_pallas_double = tsBindings.caml_pallas_double;\n\n// Provides: caml_pallas_scale\n// Requires: tsBindings\nvar caml_pallas_scale = tsBindings.caml_pallas_scale;\n\n// Provides: caml_pallas_random\n// Requires: tsBindings\nvar caml_pallas_random = tsBindings.caml_pallas_random;\n\n// Provides: caml_pallas_rng\n// Requires: tsBindings\nvar caml_pallas_rng = tsBindings.caml_pallas_rng;\n\n// Provides: caml_pallas_endo_base\n// Requires: tsBindings\nvar caml_pallas_endo_base = tsBindings.caml_pallas_endo_base;\n\n// Provides: caml_pallas_endo_scalar\n// Requires: tsBindings\nvar caml_pallas_endo_scalar = tsBindings.caml_pallas_endo_scalar;\n\n// Provides: caml_pallas_to_affine\n// Requires: tsBindings\nvar caml_pallas_to_affine = tsBindings.caml_pallas_to_affine;\n\n// Provides: caml_pallas_of_affine\n// Requires: tsBindings\nvar caml_pallas_of_affine = tsBindings.caml_pallas_of_affine;\n\n// Provides: caml_pallas_of_affine_coordinates\n// Requires: tsBindings\nvar caml_pallas_of_affine_coordinates = tsBindings.caml_pallas_of_affine_coordinates;\n\n// Provides: caml_pallas_affine_deep_copy\n// Requires: tsBindings\nvar caml_pallas_affine_deep_copy = tsBindings.caml_pallas_affine_deep_copy;\n\n// vesta\n\n// Provides: caml_vesta_one\n// Requires: tsBindings\nvar caml_vesta_one = tsBindings.caml_vesta_one;\n\n// Provides: caml_vesta_add\n// Requires: tsBindings\nvar caml_vesta_add = tsBindings.caml_vesta_add;\n\n// Provides: caml_vesta_sub\n// Requires: tsBindings\nvar caml_vesta_sub = tsBindings.caml_vesta_sub;\n\n// Provides: caml_vesta_negate\n// Requires: tsBindings\nvar caml_vesta_negate = tsBindings.caml_vesta_negate;\n\n// Provides: caml_vesta_double\n// Requires: tsBindings\nvar caml_vesta_double = tsBindings.caml_vesta_double;\n\n// Provides: caml_vesta_scale\n// Requires: tsBindings\nvar caml_vesta_scale = tsBindings.caml_vesta_scale;\n\n// Provides: caml_vesta_random\n// Requires: tsBindings\nvar caml_vesta_random = tsBindings.caml_vesta_random;\n\n// Provides: caml_vesta_rng\n// Requires: tsBindings\nvar caml_vesta_rng = tsBindings.caml_vesta_rng;\n\n// Provides: caml_vesta_endo_base\n// Requires: tsBindings\nvar caml_vesta_endo_base = tsBindings.caml_vesta_endo_base;\n\n// Provides: caml_vesta_endo_scalar\n// Requires: tsBindings\nvar caml_vesta_endo_scalar = tsBindings.caml_vesta_endo_scalar;\n\n// Provides: caml_vesta_to_affine\n// Requires: tsBindings\nvar caml_vesta_to_affine = tsBindings.caml_vesta_to_affine;\n\n// Provides: caml_vesta_of_affine\n// Requires: tsBindings\nvar caml_vesta_of_affine = tsBindings.caml_vesta_of_affine;\n\n// Provides: caml_vesta_of_affine_coordinates\n// Requires: tsBindings\nvar caml_vesta_of_affine_coordinates = tsBindings.caml_vesta_of_affine_coordinates;\n\n// Provides: caml_vesta_affine_deep_copy\n// Requires: tsBindings\nvar caml_vesta_affine_deep_copy = tsBindings.caml_vesta_affine_deep_copy;\n","/* global tsBindings\n*/\n\n// Provides: caml_pasta_fp_copy\n// Requires: tsBindings\nvar caml_pasta_fp_copy = tsBindings.caml_pasta_fp_copy;\n\n// Provides: caml_pasta_fp_size_in_bits\n// Requires: tsBindings\nvar caml_pasta_fp_size_in_bits = tsBindings.caml_pasta_fp_size_in_bits;\n\n// Provides: caml_pasta_fp_size\n// Requires: tsBindings\nvar caml_pasta_fp_size = tsBindings.caml_pasta_fp_size;\n\n// Provides: caml_pasta_fp_add\n// Requires: tsBindings\nvar caml_pasta_fp_add = tsBindings.caml_pasta_fp_add;\n\n// Provides: caml_pasta_fp_sub\n// Requires: tsBindings\nvar caml_pasta_fp_sub = tsBindings.caml_pasta_fp_sub;\n\n// Provides: caml_pasta_fp_negate\n// Requires: tsBindings\nvar caml_pasta_fp_negate = tsBindings.caml_pasta_fp_negate;\n\n// Provides: caml_pasta_fp_mul\n// Requires: tsBindings\nvar caml_pasta_fp_mul = tsBindings.caml_pasta_fp_mul;\n\n// Provides: caml_pasta_fp_div\n// Requires: tsBindings\nvar caml_pasta_fp_div = tsBindings.caml_pasta_fp_div;\n\n// Provides: caml_pasta_fp_inv\n// Requires: tsBindings\nvar caml_pasta_fp_inv = tsBindings.caml_pasta_fp_inv;\n\n// Provides: caml_pasta_fp_square\n// Requires: tsBindings\nvar caml_pasta_fp_square = tsBindings.caml_pasta_fp_square\n\n// Provides: caml_pasta_fp_is_square\n// Requires: tsBindings\nvar caml_pasta_fp_is_square = tsBindings.caml_pasta_fp_is_square;\n\n// Provides: caml_pasta_fp_sqrt\n// Requires: tsBindings\nvar caml_pasta_fp_sqrt = tsBindings.caml_pasta_fp_sqrt;\n\n// Provides: caml_pasta_fp_of_int\n// Requires: tsBindings\nvar caml_pasta_fp_of_int = tsBindings.caml_pasta_fp_of_int\n\n// Provides: caml_pasta_fp_to_string\n// Requires: tsBindings\nvar caml_pasta_fp_to_string = tsBindings.caml_pasta_fp_to_string;\n\n// Provides: caml_pasta_fp_of_string\n// Requires: tsBindings\nvar caml_pasta_fp_of_string = tsBindings.caml_pasta_fp_of_string;\n\n// Provides: caml_pasta_fp_print\n// Requires: tsBindings\nvar caml_pasta_fp_print = tsBindings.caml_pasta_fp_print;\n\n// Provides: caml_pasta_fp_mut_add\n// Requires: tsBindings\nvar caml_pasta_fp_mut_add = tsBindings.caml_pasta_fp_mut_add;\n\n// Provides: caml_pasta_fp_mut_sub\n// Requires: tsBindings\nvar caml_pasta_fp_mut_sub = tsBindings.caml_pasta_fp_mut_sub;\n\n// Provides: caml_pasta_fp_mut_mul\n// Requires: tsBindings\nvar caml_pasta_fp_mut_mul = tsBindings.caml_pasta_fp_mut_mul;\n\n// Provides: caml_pasta_fp_mut_square\n// Requires: tsBindings\nvar caml_pasta_fp_mut_square = tsBindings.caml_pasta_fp_mut_square;\n\n// Provides: caml_pasta_fp_compare\n// Requires: tsBindings\nvar caml_pasta_fp_compare = tsBindings.caml_pasta_fp_compare;\n\n// Provides: caml_pasta_fp_equal\n// Requires: tsBindings\nvar caml_pasta_fp_equal = tsBindings.caml_pasta_fp_equal;\n\n// Provides: caml_pasta_fp_random\n// Requires: tsBindings\nvar caml_pasta_fp_random = tsBindings.caml_pasta_fp_random;\n\n// Provides: caml_pasta_fp_rng\n// Requires: tsBindings\nvar caml_pasta_fp_rng = tsBindings.caml_pasta_fp_rng;\n\n// Provides: caml_pasta_fp_to_bigint\n// Requires: tsBindings\nvar caml_pasta_fp_to_bigint = tsBindings.caml_pasta_fp_to_bigint;\n\n// Provides: caml_pasta_fp_of_bigint\n// Requires: tsBindings\nvar caml_pasta_fp_of_bigint = tsBindings.caml_pasta_fp_of_bigint;\n\n// Provides: caml_pasta_fp_two_adic_root_of_unity\n// Requires: tsBindings\nvar caml_pasta_fp_two_adic_root_of_unity = tsBindings.caml_pasta_fp_two_adic_root_of_unity;\n\n// Provides: caml_pasta_fp_domain_generator\n// Requires: tsBindings\nvar caml_pasta_fp_domain_generator = tsBindings.caml_pasta_fp_domain_generator;\n\n// Provides: caml_pasta_fp_to_bytes\n// Requires: tsBindings\nvar caml_pasta_fp_to_bytes = tsBindings.caml_pasta_fp_to_bytes;\n\n// Provides: caml_pasta_fp_of_bytes\n// Requires: tsBindings\nvar caml_pasta_fp_of_bytes = tsBindings.caml_pasta_fp_of_bytes;\n\n// Provides: caml_pasta_fp_deep_copy\n// Requires: tsBindings\nvar caml_pasta_fp_deep_copy = tsBindings.caml_pasta_fp_deep_copy;\n\n\n\n\n// Provides: caml_pasta_fq_copy\n// Requires: tsBindings\nvar caml_pasta_fq_copy = tsBindings.caml_pasta_fq_copy;\n\n// Provides: caml_pasta_fq_size_in_bits\n// Requires: tsBindings\nvar caml_pasta_fq_size_in_bits = tsBindings.caml_pasta_fq_size_in_bits;\n\n// Provides: caml_pasta_fq_size\n// Requires: tsBindings\nvar caml_pasta_fq_size = tsBindings.caml_pasta_fq_size;\n\n// Provides: caml_pasta_fq_add\n// Requires: tsBindings\nvar caml_pasta_fq_add = tsBindings.caml_pasta_fq_add;\n\n// Provides: caml_pasta_fq_sub\n// Requires: tsBindings\nvar caml_pasta_fq_sub = tsBindings.caml_pasta_fq_sub;\n\n// Provides: caml_pasta_fq_negate\n// Requires: tsBindings\nvar caml_pasta_fq_negate = tsBindings.caml_pasta_fq_negate;\n\n// Provides: caml_pasta_fq_mul\n// Requires: tsBindings\nvar caml_pasta_fq_mul = tsBindings.caml_pasta_fq_mul;\n\n// Provides: caml_pasta_fq_div\n// Requires: tsBindings\nvar caml_pasta_fq_div = tsBindings.caml_pasta_fq_div;\n\n// Provides: caml_pasta_fq_inv\n// Requires: tsBindings\nvar caml_pasta_fq_inv = tsBindings.caml_pasta_fq_inv; \n\n// Provides: caml_pasta_fq_square\n// Requires: tsBindings\nvar caml_pasta_fq_square = tsBindings.caml_pasta_fq_square\n\n// Provides: caml_pasta_fq_is_square\n// Requires: tsBindings\nvar caml_pasta_fq_is_square = tsBindings.caml_pasta_fq_is_square;\n\n// Provides: caml_pasta_fq_sqrt\n// Requires: tsBindings\nvar caml_pasta_fq_sqrt = tsBindings.caml_pasta_fq_sqrt;\n\n// Provides: caml_pasta_fq_of_int\n// Requires: tsBindings\nvar caml_pasta_fq_of_int = tsBindings.caml_pasta_fq_of_int;\n\n// Provides: caml_pasta_fq_to_string\n// Requires: tsBindings\nvar caml_pasta_fq_to_string = tsBindings.caml_pasta_fq_to_string;\n\n// Provides: caml_pasta_fq_of_string\n// Requires: tsBindings\nvar caml_pasta_fq_of_string = tsBindings.caml_pasta_fq_of_string;\n\n// Provides: caml_pasta_fq_print\n// Requires: tsBindings\nvar caml_pasta_fq_print = tsBindings.caml_pasta_fq_print;\n\n// Provides: caml_pasta_fq_mut_add\n// Requires: tsBindings\nvar caml_pasta_fq_mut_add = tsBindings.caml_pasta_fq_mut_add;\n\n// Provides: caml_pasta_fq_mut_sub\n// Requires: tsBindings\nvar caml_pasta_fq_mut_sub = tsBindings.caml_pasta_fq_mut_sub;\n\n// Provides: caml_pasta_fq_mut_mul\n// Requires: tsBindings\nvar caml_pasta_fq_mut_mul = tsBindings.caml_pasta_fq_mut_mul;\n\n// Provides: caml_pasta_fq_mut_square\n// Requires: tsBindings\nvar caml_pasta_fq_mut_square = tsBindings.caml_pasta_fq_mut_square;\n\n// Provides: caml_pasta_fq_compare\n// Requires: tsBindings\nvar caml_pasta_fq_compare = tsBindings.caml_pasta_fq_compare;\n\n// Provides: caml_pasta_fq_equal\n// Requires: tsBindings\nvar caml_pasta_fq_equal = tsBindings.caml_pasta_fq_equal;\n\n// Provides: caml_pasta_fq_random\n// Requires: tsBindings\nvar caml_pasta_fq_random = tsBindings.caml_pasta_fq_random;\n\n// Provides: caml_pasta_fq_rng\n// Requires: tsBindings\nvar caml_pasta_fq_rng = tsBindings.caml_pasta_fq_rng;\n\n// Provides: caml_pasta_fq_to_bigint\n// Requires: tsBindings\nvar caml_pasta_fq_to_bigint = tsBindings.caml_pasta_fq_to_bigint;\n\n// Provides: caml_pasta_fq_of_bigint\n// Requires: tsBindings\nvar caml_pasta_fq_of_bigint = tsBindings.caml_pasta_fq_of_bigint;\n\n// Provides: caml_pasta_fq_two_adic_root_of_unity\n// Requires: tsBindings\nvar caml_pasta_fq_two_adic_root_of_unity = tsBindings.caml_pasta_fq_two_adic_root_of_unity;\n\n// Provides: caml_pasta_fq_domain_generator\n// Requires: tsBindings\nvar caml_pasta_fq_domain_generator = tsBindings.caml_pasta_fq_domain_generator;\n\n// Provides: caml_pasta_fq_to_bytes\n// Requires: tsBindings\nvar caml_pasta_fq_to_bytes = tsBindings.caml_pasta_fq_to_bytes;\n\n// Provides: caml_pasta_fq_of_bytes\n// Requires: tsBindings\nvar caml_pasta_fq_of_bytes = tsBindings.caml_pasta_fq_of_bytes;\n\n// Provides: caml_pasta_fq_deep_copy\n// Requires: tsBindings\nvar caml_pasta_fq_deep_copy = tsBindings.caml_pasta_fq_deep_copy;\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\n// Requires: deferred_of_promise\nfunction deferred_run(func) {\n if (func.length > 1) {\n // we add this restriction to be able to use .then(func) below,\n // which allows us to implement external functions that are synchronous\n // in native Rust with async functions in JS\n throw Error(\n 'deferred_run cannot be called with a function that takes more than 1 argument.'\n );\n }\n return deferred_of_promise(\n // the ocaml types don't know this, but func can actually be async or sync\n globalThis.Promise.resolve().then(func)\n );\n}\n\n// Provides: deferred_map\n// Requires: deferred_of_promise\nfunction deferred_map(deferred, func) {\n return deferred_of_promise(\n deferred.promise.then(function (value) {\n // we might be given a `func` with multiple arguments,\n // have to match ocaml call semantics\n if (func.length === 1) return func(value);\n return function () {\n return func.apply(null, [value].concat(Array.from(arguments)));\n };\n })\n );\n}\n\n// Provides: deferred_bind\n// Requires: deferred_of_promise\nfunction deferred_bind(deferred, func) {\n return deferred_of_promise(\n deferred.promise.then(function (input) {\n var anotherDeferred = func(input);\n return anotherDeferred.promise;\n })\n );\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: globalThis.Promise.resolve(value),\n value: value,\n isError: false,\n isDetermined: true,\n };\n}\n\n// Provides: deferred_create\n// Requires: deferred_of_promise\nfunction deferred_create(promise_creator) {\n return deferred_of_promise(\n new globalThis.Promise(function (resolve) {\n promise_creator(resolve);\n })\n );\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 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 : Pickles_types.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","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","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","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 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 (* it would be better to use `with_all_version_tags` on just\n the module where we need a version tag, but that doesn't\n (yet) work with %%versioned_binable\n *)\n [@@@with_top_version_tag]\n\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 Bounded_types.String.Of_stringable (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","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","(**************************************************************************)\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\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 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","(* protocol_version.ml *)\n\n(* see RFC 0049 for details *)\n\nopen Core_kernel\nmodule Wire_types = Mina_wire_types.Protocol_version\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Protocol_version_intf.Full with type Stable.V2.t = A.V2.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = A.V2.t = { transaction : int; network : int; patch : int }\n [@@deriving compare, equal, sexp, yojson, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n include Comparable.Make (Stable.V2)\n\n let create = Fields.create\n\n let of_string_exn s =\n let is_digit_string s = String.for_all s ~f:Char.is_digit in\n match String.split s ~on:'.' with\n | [ transaction; network; patch ] ->\n if\n not\n ( is_digit_string transaction\n && is_digit_string network && is_digit_string patch )\n then failwith \"Unexpected nondigits in input\" ;\n { transaction = Int.of_string transaction\n ; network = Int.of_string network\n ; patch = Int.of_string patch\n }\n | _ ->\n failwith\n \"Protocol_version.of_string_exn: expected string of form nn.nn.nn\"\n\n let of_string_opt s = try Some (of_string_exn s) with _ -> None\n\n let to_string t = sprintf \"%u.%u.%u\" t.transaction t.network t.patch\n\n let current_transaction = Node_config_version.protocol_version_transaction\n\n let current_network = Node_config_version.protocol_version_network\n\n let current_patch = Node_config_version.protocol_version_patch\n\n let current =\n { transaction = current_transaction\n ; network = current_network\n ; patch = current_patch\n }\n\n let (proposed_protocol_version_opt : t option ref) = ref None\n\n let set_proposed_opt t_opt = proposed_protocol_version_opt := t_opt\n\n let get_proposed_opt () = !proposed_protocol_version_opt\n\n let compatible_with_daemon (t : t) =\n (* patch not considered for compatibility *)\n Int.equal t.transaction current.transaction\n && Int.equal t.network current.network\n\n (* when an external transition is deserialized, might contain\n negative numbers\n *)\n let is_valid t = Int.(t.transaction >= 1 && t.network >= 0 && t.patch >= 0)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\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 rec go = function\n | Constant c, Some scale ->\n c * scale\n | Constant c, None ->\n c\n | Var v, Some scale ->\n context v * scale\n | Var v, None ->\n context v\n | Scale (s, t), Some scale ->\n go (t, Some (scale * s))\n | Scale (s, t), None ->\n go (t, Some s)\n | Add (t1, t2), Some scale ->\n (go (t1, None) + go (t2, None)) * scale\n | Add (t1, t2), None ->\n go (t1, None) + go (t2, None)\n in\n go (t0, None)\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 option\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 = List.find_map_exn !cases ~f:(fun m -> try f m with _ -> None)\n\n let sexp_of_t f1 f2 t =\n case (fun (module M) -> M.of_basic t |> Option.map ~f:(M.sexp_of_t f1 f2))\n\n let t_of_sexp f1 f2 s =\n case (fun (module M) -> Some (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.of_basic t |> Option.map ~f:(M.eval fm f))\n\n let map t ~f =\n case (fun (module M) ->\n M.of_basic t |> Option.map ~f:(fun t -> M.to_basic (M.map 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 -> Some x | _ -> None\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 t = Some t\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%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 match\n As_prover.Provider.run p (get_value s) (Run_state.handler s)\n with\n | Some x ->\n x\n | None ->\n failwith\n ( \"Unhandled request: \"\n ^ Core_kernel.String.concat ~sep:\"\\n\" (Run_state.stack 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 lazy\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 (Lazy.force 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 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 type ('input_var, 'return_var, 'result) manual_callbacks =\n { run_circuit : 'a. ('input_var -> unit -> 'a) -> 'a\n ; finish_computation : 'return_var -> 'result\n }\n\n let constraint_system_manual ~input_typ ~return_typ =\n let builder =\n Run.Constraint_system_builder.build ~input_typ ~return_typ\n in\n (* FIXME: This behaves badly with exceptions. *)\n let cached_state = ref None in\n let cached_active_counters = ref None in\n let run_circuit circuit =\n (* Check the status. *)\n if\n Option.is_some !cached_state || Option.is_some !cached_active_counters\n then failwith \"Already generating constraint system\" ;\n (* Partial [finalize_is_running]. *)\n cached_state := Some !state ;\n builder.run_computation (fun input state' ->\n (* Partial [as_stateful]. *)\n state := state' ;\n (* Partial [mark_active]. *)\n let counters = !active_counters in\n cached_active_counters := Some counters ;\n active_counters := this_functor_id :: counters ;\n (* Start the circuit. *)\n circuit input () )\n in\n let finish_computation return_var =\n (* Check the status. *)\n if\n Option.is_none !cached_state || Option.is_none !cached_active_counters\n then failwith \"Constraint system not in a finalizable state\" ;\n (* Partial [mark_active]. *)\n active_counters := Option.value_exn !cached_active_counters ;\n (* Create an invalid state, to avoid re-runs. *)\n cached_active_counters := None ;\n (* Partial [as_stateful]. *)\n let state' = !state in\n let res = builder.finish_computation (state', return_var) in\n (* Partial [finalize_is_running]. *)\n state := Option.value_exn !cached_state ;\n res\n in\n { run_circuit; finish_computation }\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 generate_witness_manual ?handlers ~input_typ ~return_typ input =\n let builder =\n Run.Witness_builder.auxiliary_input ?handlers ~input_typ ~return_typ\n input\n in\n (* FIXME: This behaves badly with exceptions. *)\n let cached_state = ref None in\n let cached_active_counters = ref None in\n let run_circuit circuit =\n (* Check the status. *)\n if\n Option.is_some !cached_state || Option.is_some !cached_active_counters\n then failwith \"Already generating constraint system\" ;\n (* Partial [finalize_is_running]. *)\n cached_state := Some !state ;\n builder.run_computation (fun input state' ->\n (* Partial [as_stateful]. *)\n state := state' ;\n (* Partial [mark_active]. *)\n let counters = !active_counters in\n cached_active_counters := Some counters ;\n active_counters := this_functor_id :: counters ;\n (* Start the circuit. *)\n circuit input () )\n in\n let finish_computation return_var =\n (* Check the status. *)\n if\n Option.is_none !cached_state || Option.is_none !cached_active_counters\n then failwith \"Constraint system not in a finalizable state\" ;\n (* Partial [mark_active]. *)\n active_counters := Option.value_exn !cached_active_counters ;\n (* Create an invalid state, to avoid re-runs. *)\n cached_active_counters := None ;\n (* Partial [as_stateful]. *)\n let state' = !state in\n let res = builder.finish_witness_generation (state', return_var) in\n (* Partial [finalize_is_running]. *)\n state := Option.value_exn !cached_state ;\n res\n in\n { run_circuit; finish_computation }\n\n (* start an as_prover / exists block and return a function to finish it and witness a given list of fields *)\n let as_prover_manual (size_to_witness : int) :\n (field array option -> Field.t array) Staged.t =\n let s = !state in\n let old_as_prover = Run_state.as_prover s in\n (* enter the as_prover block *)\n Run_state.set_as_prover s true ;\n\n let finish_computation (values_to_witness : field array option) =\n (* leave the as_prover block *)\n Run_state.set_as_prover s old_as_prover ;\n\n (* return variables *)\n match (Run_state.has_witness s, values_to_witness) with\n (* in compile mode, we return empty vars *)\n | false, None ->\n Core_kernel.Array.init size_to_witness ~f:(fun _ ->\n Run_state.alloc_var s () )\n (* in prover mode, we expect values to turn into vars *)\n | true, Some values_to_witness ->\n let store_value =\n (* If we're nested in a prover block, create constants instead of\n storing. *)\n if old_as_prover then Field.constant\n else Run_state.store_field_elt s\n in\n Core_kernel.Array.map values_to_witness ~f:store_value\n (* the other cases are invalid *)\n | false, Some _ ->\n failwith \"Did not expect values to witness\"\n | true, None ->\n failwith \"Expected values to witness\"\n in\n Staged.stage finish_computation\n\n let request_manual (req : unit -> 'a Request.t) () : 'a =\n Request.Handler.run (Run_state.handler !state) (req ())\n |> Option.value_exn ~message:\"Unhandled request\"\n\n module Async_generic (Promise : Base.Monad.S) = struct\n let run_prover ~(else_ : unit -> 'a) (f : unit -> 'a Promise.t) :\n 'a Promise.t =\n if Run_state.has_witness !state then (\n let old = Run_state.as_prover !state in\n Run_state.set_as_prover !state true ;\n let%map.Promise result = f () in\n Run_state.set_as_prover !state old ;\n result )\n else Promise.return (else_ ())\n\n let as_prover (f : unit -> unit Promise.t) : unit Promise.t =\n run_prover ~else_:(fun () -> ()) f\n\n let unit_request req = as_prover (request_manual req)\n end\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","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 = 'f Mina_wire_types.Pickles_types.Shifted_value.Type1.V1.t =\n | 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_minus_1 = Nat.N4\nmodule Lookup_sorted_minus_1_vec = Vector.Vector_4\nmodule Lookup_sorted = Nat.N5\nmodule Lookup_sorted_vec = Vector.Vector_5\n\nmodule Features = struct\n module Full = 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 ; uses_lookups : 'bool\n ; table_width_at_least_1 : 'bool\n ; table_width_at_least_2 : 'bool\n ; table_width_3 : 'bool\n ; lookups_per_row_3 : 'bool\n ; lookups_per_row_4 : 'bool\n ; lookup_pattern_xor : 'bool\n ; lookup_pattern_range_check : 'bool\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n\n let get_feature_flag (feature_flags : _ t)\n (feature : Kimchi_types.feature_flag) =\n match feature with\n | RangeCheck0 ->\n Some feature_flags.range_check0\n | RangeCheck1 ->\n Some feature_flags.range_check1\n | ForeignFieldAdd ->\n Some feature_flags.foreign_field_add\n | ForeignFieldMul ->\n Some feature_flags.foreign_field_mul\n | Xor ->\n Some feature_flags.xor\n | Rot ->\n Some feature_flags.rot\n | LookupTables ->\n Some feature_flags.uses_lookups\n | RuntimeLookupTables ->\n Some feature_flags.runtime_tables\n | TableWidth 3 ->\n Some feature_flags.table_width_3\n | TableWidth 2 ->\n Some feature_flags.table_width_at_least_2\n | TableWidth i when i <= 1 ->\n Some feature_flags.table_width_at_least_1\n | TableWidth _ ->\n None\n | LookupsPerRow 4 ->\n Some feature_flags.lookups_per_row_4\n | LookupsPerRow i when i <= 3 ->\n Some feature_flags.lookups_per_row_3\n | LookupsPerRow _ ->\n None\n | LookupPattern Lookup ->\n Some feature_flags.lookup\n | LookupPattern Xor ->\n Some feature_flags.lookup_pattern_xor\n | LookupPattern RangeCheck ->\n Some feature_flags.lookup_pattern_range_check\n | LookupPattern ForeignFieldMul ->\n Some feature_flags.foreign_field_mul\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 ; uses_lookups\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 } ~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 ; uses_lookups = f uses_lookups\n ; table_width_at_least_1 = f table_width_at_least_1\n ; table_width_at_least_2 = f table_width_at_least_2\n ; table_width_3 = f table_width_3\n ; lookups_per_row_3 = f lookups_per_row_3\n ; lookups_per_row_4 = f lookups_per_row_4\n ; lookup_pattern_xor = f lookup_pattern_xor\n ; lookup_pattern_range_check = f lookup_pattern_range_check\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 ; uses_lookups = f x1.uses_lookups x2.uses_lookups\n ; table_width_at_least_1 =\n f x1.table_width_at_least_1 x2.table_width_at_least_1\n ; table_width_at_least_2 =\n f x1.table_width_at_least_2 x2.table_width_at_least_2\n ; table_width_3 = f x1.table_width_3 x2.table_width_3\n ; lookups_per_row_3 = f x1.lookups_per_row_3 x2.lookups_per_row_3\n ; lookups_per_row_4 = f x1.lookups_per_row_4 x2.lookups_per_row_4\n ; lookup_pattern_xor = f x1.lookup_pattern_xor x2.lookup_pattern_xor\n ; lookup_pattern_range_check =\n f x1.lookup_pattern_range_check x2.lookup_pattern_range_check\n }\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 ; uses_lookups = Opt.Flag.No\n ; table_width_at_least_1 = Opt.Flag.No\n ; table_width_at_least_2 = Opt.Flag.No\n ; table_width_3 = Opt.Flag.No\n ; lookups_per_row_3 = Opt.Flag.No\n ; lookups_per_row_4 = Opt.Flag.No\n ; lookup_pattern_xor = Opt.Flag.No\n ; lookup_pattern_range_check = Opt.Flag.No\n }\n\n let maybe =\n { range_check0 = Opt.Flag.Maybe\n ; range_check1 = Opt.Flag.Maybe\n ; foreign_field_add = Opt.Flag.Maybe\n ; foreign_field_mul = Opt.Flag.Maybe\n ; xor = Opt.Flag.Maybe\n ; rot = Opt.Flag.Maybe\n ; lookup = Opt.Flag.Maybe\n ; runtime_tables = Opt.Flag.Maybe\n ; uses_lookups = Opt.Flag.Maybe\n ; table_width_at_least_1 = Opt.Flag.Maybe\n ; table_width_at_least_2 = Opt.Flag.Maybe\n ; table_width_3 = Opt.Flag.Maybe\n ; lookups_per_row_3 = Opt.Flag.Maybe\n ; lookups_per_row_4 = Opt.Flag.Maybe\n ; lookup_pattern_xor = Opt.Flag.Maybe\n ; lookup_pattern_range_check = Opt.Flag.Maybe\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 ; uses_lookups = false\n ; table_width_at_least_1 = false\n ; table_width_at_least_2 = false\n ; table_width_3 = false\n ; lookups_per_row_3 = false\n ; lookups_per_row_4 = false\n ; lookup_pattern_xor = false\n ; lookup_pattern_range_check = false\n }\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'bool t =\n 'bool Mina_wire_types.Pickles_types.Plonk_types.Features.V1.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 let of_full\n ({ range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n ; uses_lookups = _\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 } :\n 'bool Full.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 to_full ~or_:( ||| ) ?(any = List.reduce_exn ~f:( ||| ))\n { range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n } : _ Full.t =\n let lookup_pattern_range_check =\n (* RangeCheck, Rot gates use RangeCheck lookup pattern *)\n range_check0 ||| range_check1 ||| rot\n in\n let lookup_pattern_xor =\n (* Xor lookup pattern *)\n 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 table_width_3 ||| lookup\n in\n let table_width_at_least_1 =\n (* RangeCheck, ForeignFieldMul have max_joint_size = 1 *)\n any\n [ table_width_at_least_2\n ; 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 any [ lookup_pattern_xor; lookup_pattern_range_check; foreign_field_mul ]\n in\n let lookups_per_row_3 =\n (* Lookup has max_lookups_per_row = 3 *)\n lookups_per_row_4 ||| lookup\n in\n { uses_lookups = 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 ; 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 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 maybe =\n { range_check0 = Opt.Flag.Maybe\n ; range_check1 = Opt.Flag.Maybe\n ; foreign_field_add = Opt.Flag.Maybe\n ; foreign_field_mul = Opt.Flag.Maybe\n ; xor = Opt.Flag.Maybe\n ; rot = Opt.Flag.Maybe\n ; lookup = Opt.Flag.Maybe\n ; runtime_tables = Opt.Flag.Maybe\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 = 'a Mina_wire_types.Pickles_types.Plonk_types.Evals.V2.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 (* NB: Equivalent checks are run in-circuit below. *)\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 =\n f.xor || range_check_lookup || f.foreign_field_mul\n in\n let lookups_per_row_3 = lookups_per_row_4 || f.lookup in\n let lookups_per_row_2 = lookups_per_row_3 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 always_present =\n List.map ~f:Opt.just\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\n List.map ~f:Opt.just 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\n (* NB: Equivalent checks are done out-of-circuit above. *)\n let validate_feature_flags ~true_ ~false_ ~or_:( ||| ) ~assert_equal\n ~feature_flags:(f : 'boolean 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 opt_flag = function\n | Opt.Just _ ->\n true_\n | Opt.Maybe (b, _) ->\n b\n | Opt.Nothing ->\n false_\n in\n let enable_if x flag = assert_equal (opt_flag x) flag in\n let range_check_lookup = f.range_check0 ||| f.range_check1 ||| f.rot in\n let lookups_per_row_4 =\n f.xor ||| range_check_lookup ||| f.foreign_field_mul\n in\n let lookups_per_row_3 = lookups_per_row_4 ||| f.lookup in\n let lookups_per_row_2 = lookups_per_row_3 in\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.iteri lookup_sorted ~f:(fun i 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 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 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\n ({ uses_lookups; lookups_per_row_3; lookups_per_row_4; _ } as\n feature_flags :\n _ Features.Full.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 lookup_sorted =\n let lookups_per_row_3 = opt lookups_per_row_3 in\n let lookups_per_row_4 = opt lookups_per_row_4 in\n Vector.typ'\n [ lookups_per_row_3\n ; lookups_per_row_3\n ; lookups_per_row_3\n ; lookups_per_row_3\n ; lookups_per_row_4\n ]\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_lookups\n ; opt uses_lookups\n ; lookup_sorted\n ; opt feature_flags.runtime_tables\n ; opt feature_flags.runtime_tables\n ; opt feature_flags.lookup_pattern_xor\n ; opt feature_flags.lookup\n ; opt feature_flags.lookup_pattern_range_check\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 ( 'f\n , 'f_multi )\n Mina_wire_types.Pickles_types.Plonk_types.All_evals\n .With_public_input\n .V1\n .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 [@@@no_toplevel_latest_type]\n\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 type ('f, 'f_multi) t =\n ('f, 'f_multi) Mina_wire_types.Pickles_types.Plonk_types.All_evals.V1.t =\n { evals : ('f_multi * 'f_multi, 'f_multi * 'f_multi) With_public_input.t\n ; ft_eval1 : 'f\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n\n module In_circuit = struct\n type ('f, 'f_multi, 'bool) t =\n { evals :\n ( 'f_multi * 'f_multi\n , 'f_multi * 'f_multi\n , 'bool )\n 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:f2)\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 ~num_chunks feature_flags =\n let open Impl.Typ in\n let single = array ~length:num_chunks field in\n let dummy = Array.init num_chunks ~f:(fun _ -> Impl.Field.Constant.zero) in\n let evals =\n With_public_input.typ\n (module Impl)\n feature_flags (tuple2 single single) (tuple2 single single)\n ~dummy:(dummy, dummy)\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 ( 'g\n , 'fq )\n Mina_wire_types.Pickles_types.Plonk_types.Openings.Bulletproof.V1\n .t =\n { lr : ('g * 'g) Bounded_types.ArrayN16.Stable.V1.t\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 ( 'g\n , 'fq\n , 'fqv )\n Mina_wire_types.Pickles_types.Plonk_types.Openings.V2.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 =\n { unshifted : 'g_opt Bounded_types.ArrayN16.Stable.V1.t\n ; shifted : 'g_opt\n }\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 Bounded_types.ArrayN16.Stable.V1.t\n [@@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 [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'g t =\n 'g Mina_wire_types.Pickles_types.Plonk_types.Messages.Lookup.V1.t =\n { sorted : 'g Bounded_types.ArrayN16.Stable.V1.t\n ; aggreg : 'g\n ; runtime : 'g option\n }\n [@@deriving fields, sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n type 'g t =\n { sorted : 'g Lookup_sorted_minus_1_vec.t\n ; sorted_5th_column : 'g option\n ; aggreg : 'g\n ; runtime : 'g option\n }\n [@@deriving fields, sexp, compare, yojson, hash, equal, hlist]\n\n module In_circuit = struct\n type ('g, 'bool) t =\n { sorted : 'g Lookup_sorted_minus_1_vec.t\n ; sorted_5th_column : ('g, 'bool) Opt.t\n ; aggreg : 'g\n ; runtime : ('g, 'bool) Opt.t\n }\n [@@deriving hlist]\n end\n\n let dummy z =\n { aggreg = z\n ; sorted = Vector.init Lookup_sorted_minus_1.n ~f:(fun _ -> z)\n ; sorted_5th_column = None\n ; runtime = None\n }\n\n let typ bool_typ e ~lookups_per_row_4 ~runtime_tables ~dummy =\n Snarky_backendless.Typ.of_hlistable\n [ Vector.typ e Lookup_sorted_minus_1.n\n ; Opt.typ bool_typ lookups_per_row_4 e ~dummy\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 ~(uses_lookup : Opt.Flag.t)\n ~(lookups_per_row_4 : Opt.Flag.t) ~(runtime_tables : Opt.Flag.t)\n ~dummy:z elt =\n Opt.typ bool_typ uses_lookup ~dummy:(dummy z)\n (typ bool_typ ~lookups_per_row_4 ~runtime_tables ~dummy:z elt)\n end\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type 'g t = 'g Mina_wire_types.Pickles_types.Plonk_types.Messages.V2.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 type 'g 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 : 'g Without_degree_bound.t Lookup.t option\n }\n [@@deriving sexp, compare, yojson, fields, hash, equal, hlist]\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 ({ runtime_tables; uses_lookups; lookups_per_row_4; _ } :\n Opt.Flag.t Features.Full.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 ~uses_lookup:uses_lookups\n ~lookups_per_row_4 ~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 [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type ('g, 'fq, 'fqv) t =\n ('g, 'fq, 'fqv) Mina_wire_types.Pickles_types.Plonk_types.Proof.V2.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]\n\n type ('g, 'fq, 'fqv) t =\n { messages : 'g Messages.t; openings : ('g, 'fq, 'fqv) Openings.t }\n [@@deriving sexp, compare, yojson, hash, equal]\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 Bounded_types.ArrayN16.Stable.V1.t\n [@@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 module Proof_cache = Proof_cache\n module Cache = Cache\n module Storables = Compile.Storables\n module Ro = Ro\n\n type chunking_data = Verify.Instance.chunking_data =\n { num_chunks : int; domain_size : int; zk_rows : int }\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 a1, ..., an can be seen as previous statements, i.e.\n\n prev_statement_1 ∈ A1, ..., prev_statement_n ∈ An\n f [ prev_statement_1; ...; prev_statement_n ] new_statement = true\n -------------------------------------------------------------------\n new_statement ∈ A\n\n In the case of a blockchain, the description of the sets A1, ..., An, A can\n be blockchain state, and f would be a function updating the state:\n\n prev_blockchain_state ∈ A\n update_blockchain_state [prev_blockchain_state] new_blockchain_state = true\n ---------------------------------------------------------------------------\n new_blockchain_state ∈ A\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 elements 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 ; length = 0\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_promise tag : t Promise.t =\n let d = Types_map.lookup_compiled tag.Tag.id in\n let%bind.Promise wrap_key = Lazy.force d.wrap_key in\n let%map.Promise wrap_vk = Lazy.force d.wrap_vk in\n let actual_wrap_domain_size =\n Common.actual_wrap_domain_size\n ~log_2_domain_size:wrap_vk.domain.log_size_of_group\n in\n ( { wrap_vk = Some wrap_vk\n ; wrap_index =\n Plonk_verification_key_evals.map wrap_key ~f:(fun x -> x.(0))\n ; max_proofs_verified =\n Pickles_base.Proofs_verified.of_nat_exn\n (Nat.Add.n d.max_proofs_verified)\n ; actual_wrap_domain_size\n }\n : t )\n\n let of_compiled tag = of_compiled_promise tag |> Promise.to_deferred\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 Plonk_types.(Features.to_full ~or_:Opt.Flag.( ||| ) feature_flags)\n ; num_chunks = 1\n ; zk_rows = 3\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, None, 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 ?storables ?proof_cache ?disk_keys\n ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ?constraint_constants ~choices () =\n compile_with_wrap_main_override_promise ?self ?cache ?storables ?proof_cache\n ?disk_keys ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ\n ~branches ~max_proofs_verified ~name ?constraint_constants ~choices ()\n\n let compile ?self ?cache ?storables ?proof_cache ?disk_keys\n ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ?constraint_constants ~choices () =\n let choices ~self =\n let choices = choices ~self in\n let rec go :\n type a b c d e f g h i j.\n (a, b, c, d, e, f, g, h, i, j) H4_6.T(Inductive_rule).t\n -> (a, b, c, d, e, f, g, h, i, j) H4_6.T(Inductive_rule.Promise).t =\n function\n | [] ->\n []\n | { identifier; prevs; main; feature_flags } :: rest ->\n { identifier\n ; prevs\n ; main = (fun x -> Promise.return (main x))\n ; feature_flags\n }\n :: go rest\n in\n go choices\n in\n let self, cache_handle, proof_module, provers =\n compile_promise ?self ?cache ?storables ?proof_cache ?disk_keys\n ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ?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 let compile_async ?self ?cache ?storables ?proof_cache ?disk_keys\n ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ?constraint_constants ~choices () =\n let choices ~self =\n let choices = choices ~self in\n let rec go :\n type a b c d e f g h i j.\n (a, b, c, d, e, f, g, h, i, j) H4_6.T(Inductive_rule.Deferred).t\n -> (a, b, c, d, e, f, g, h, i, j) H4_6.T(Inductive_rule.Promise).t =\n function\n | [] ->\n []\n | { identifier; prevs; main; feature_flags } :: rest ->\n { identifier\n ; prevs\n ; main =\n (fun x ->\n Promise.create (fun callback ->\n Deferred.don't_wait_for\n (let%map res = main x in\n callback res ) ) )\n ; feature_flags\n }\n :: go rest\n in\n go choices\n in\n let self, cache_handle, proof_module, provers =\n compile_promise ?self ?cache ?storables ?proof_cache ?disk_keys\n ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ?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 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 ~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 Promise.return\n { Inductive_rule.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 ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun _ ->\n dummy_constraints () ;\n Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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.Promise.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 Promise.return\n { Inductive_rule.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 =\n Inductive_rule.Promise.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.Proving_key.t * Dirty.t) Promise.t Lazy.t\n * (Kimchi_bindings.Protocol.VerifierIndex.Fp.t * Dirty.t) Promise.t\n 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 ; length = (* This is a dummy, it gets filled in on read/write. *) 0\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.Full.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 ~num_chunks:1\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 ~num_chunks:1\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 ~chain_to:(Promise.return ())\n (* TODO? *)\n in\n let step_domains = Vector.singleton inner_step_data.domains in\n let all_step_domains =\n let%map.Promise () =\n (* Wait for promises to resolve. *)\n Vector.fold ~init:(Promise.return ()) step_domains\n ~f:(fun acc step_domain ->\n let%bind.Promise _ = step_domain in\n acc )\n in\n Vector.map\n ~f:(fun x -> Option.value_exn @@ Promise.peek x)\n step_domains\n in\n\n let step_keypair =\n let etyp =\n Impls.Step.input ~proofs_verified:Max_proofs_verified.n\n in\n let open Impls.Step in\n let k_p =\n lazy\n (let (T (typ, _conv, conv_inv)) = etyp in\n let%bind.Promise main =\n inner_step_data.main ~step_domains:all_step_domains\n in\n let main () () =\n let%map.Promise res = main () in\n Impls.Step.with_label \"conv_inv\" (fun () -> conv_inv res)\n in\n let constraint_builder =\n Impl.constraint_system_manual ~input_typ:Typ.unit\n ~return_typ:typ\n in\n let%map.Promise res = constraint_builder.run_circuit main in\n let cs = constraint_builder.finish_computation res 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%map.Promise 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 in\n let step_vks =\n lazy\n (let _, lazy_step_vk = step_keypair in\n let%map.Promise step_vk, _ = Lazy.force lazy_step_vk in\n Vector.singleton @@ Tick.Keypair.vk_commitments step_vk )\n in\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 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 ~feature_flags () 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 (Lazy.map ~f:Promise.return disk_key_prover)\n (Lazy.map ~f:Promise.return disk_key_verifier) )\n in\n (r, disk_key_verifier)\n in\n let wrap_vk = Lazy.map wrap_vk ~f:(Promise.map ~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%bind.Promise step_pk = Lazy.force step_pk in\n let%bind.Promise 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) ~proof_cache:None\n ~maxes:(module Maxes)\n ~auxiliary_typ:Impls.Step.Typ.unit\n ~step_domains:all_step_domains\n ~self_dlog_plonk_index:\n ((* TODO *) Plonk_verification_key_evals.map\n ~f:(fun x -> [| x |])\n wrap_vk.commitments )\n () (fst step_pk) wrap_vk.index\n in\n let%bind.Promise pairing_vk, _ = Lazy.force step_vk in\n let wrap =\n let wrap_vk = Lazy.force wrap_vk in\n let%bind.Promise proof, (), (), _ = step () 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 : _ Impls.Step.statement =\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 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_with_public_evals 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%bind.Promise 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.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 ~zk_rows:3\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.proof.openings.evals\n ; public_input =\n (let x1, x2 = x_hat in\n ([| x1 |], [| x2 |]) )\n }\n ~r ~xi ~zeta ~zetaw\n ~old_bulletproof_challenges:prev_challenges\n ~env:tick_env ~domain:tick_domain\n ~ft_eval1:proof.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 ; joint_combiner = Opt.nothing\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)) =\n Impls.Wrap.input ~feature_flags ()\n 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 joint_combiner = None\n }\n }\n }\n } )\n in\n ( { proof = Wrap_wire_proof.of_kimchi_proof next_proof.proof\n ; statement =\n Types.Wrap.Statement.to_minimal\n ~to_option:Opt.to_option next_statement\n ; prev_evals =\n { Plonk_types.All_evals.evals =\n { public_input =\n (let x1, x2 = x_hat in\n ([| x1 |], [| x2 |]) )\n ; evals = proof.proof.openings.evals\n }\n ; ft_eval1 = proof.proof.openings.ft_eval1\n }\n }\n : _ P.Base.Wrap.t )\n in\n let%bind.Promise wrap_pk = Lazy.force wrap_pk in\n let%bind.Promise wrap_vk = wrap_vk in\n wrap ~max_proofs_verified:Max_proofs_verified.n\n full_signature.maxes\n ~dlog_plonk_index:\n ((* TODO *) Plonk_verification_key_evals.map\n ~f:(fun x -> [| x |])\n 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 (fst wrap_pk) 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 =\n Lazy.map wrap_vk\n ~f:\n (Promise.map ~f:(fun x ->\n (* TODO *)\n Plonk_verification_key_evals.map\n ~f:(fun x -> [| x |])\n (Verification_key.commitments x) ) )\n ; wrap_vk =\n Lazy.map wrap_vk ~f:(Promise.map ~f:Verification_key.index)\n ; wrap_domains\n ; step_domains\n ; num_chunks = 1\n ; zk_rows = 3\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 let%bind.Promise verification_key = Lazy.force verification_key in\n verify_promise\n (module Max_proofs_verified)\n (module A_value)\n verification_key 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\"\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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n No_recursion.tag\n in\n step\n ~handler:\n (handler No_recursion.example_input\n (Side_loaded.Proof.of_proof\n No_recursion.example_proof )\n vk )\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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n Fake_1_recursion.tag\n in\n step\n ~handler:\n (handler Fake_1_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_1_recursion.example_proof )\n vk )\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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n Fake_2_recursion.tag\n in\n step\n ~handler:\n (handler Fake_2_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_2_recursion.example_proof )\n vk )\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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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.(map none ~f:(fun _ -> 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 ~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 Promise.return\n { Inductive_rule.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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n No_recursion.tag\n in\n step\n ~handler:\n (handler No_recursion.example_input\n (Side_loaded.Proof.of_proof\n No_recursion.example_proof )\n vk )\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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n Fake_1_recursion.tag\n in\n step\n ~handler:\n (handler Fake_1_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_1_recursion.example_proof )\n vk )\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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n Fake_2_recursion.tag\n in\n step\n ~handler:\n (handler Fake_2_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_2_recursion.example_proof )\n vk )\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 'comm Mina_wire_types.Pickles_types.Plonk_verification_key_evals.V2.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\nmodule Step = struct\n type ('comm, 'opt_comm) t =\n { sigma_comm : 'comm Plonk_types.Permuts_vec.t\n ; coefficients_comm : 'comm Plonk_types.Columns_vec.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 ; xor_comm : 'opt_comm\n ; range_check0_comm : 'opt_comm\n ; range_check1_comm : 'opt_comm\n ; foreign_field_add_comm : 'opt_comm\n ; foreign_field_mul_comm : 'opt_comm\n ; rot_comm : 'opt_comm\n ; lookup_table_comm : 'opt_comm Plonk_types.Lookup_sorted_minus_1_vec.t\n ; lookup_table_ids : 'opt_comm\n ; runtime_tables_selector : 'opt_comm\n ; lookup_selector_lookup : 'opt_comm\n ; lookup_selector_xor : 'opt_comm\n ; lookup_selector_range_check : 'opt_comm\n ; lookup_selector_ffmul : 'opt_comm\n }\n [@@deriving sexp, equal, compare, hash, yojson, hlist, fields]\n\n let 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 ; xor_comm\n ; range_check0_comm\n ; range_check1_comm\n ; foreign_field_add_comm\n ; foreign_field_mul_comm\n ; rot_comm\n ; lookup_table_comm\n ; lookup_table_ids\n ; runtime_tables_selector\n ; lookup_selector_lookup\n ; lookup_selector_xor\n ; lookup_selector_range_check\n ; lookup_selector_ffmul\n } ~f ~f_opt =\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 ; xor_comm = f_opt xor_comm\n ; range_check0_comm = f_opt range_check0_comm\n ; range_check1_comm = f_opt range_check1_comm\n ; foreign_field_add_comm = f_opt foreign_field_add_comm\n ; foreign_field_mul_comm = f_opt foreign_field_mul_comm\n ; rot_comm = f_opt rot_comm\n ; lookup_table_comm = Vector.map ~f:f_opt lookup_table_comm\n ; lookup_table_ids = f_opt lookup_table_ids\n ; runtime_tables_selector = f_opt runtime_tables_selector\n ; lookup_selector_lookup = f_opt lookup_selector_lookup\n ; lookup_selector_xor = f_opt lookup_selector_xor\n ; lookup_selector_range_check = f_opt lookup_selector_range_check\n ; lookup_selector_ffmul = f_opt lookup_selector_ffmul\n }\n\n let map2 t1 t2 ~f ~f_opt =\n { sigma_comm = Vector.map2 ~f t1.sigma_comm t2.sigma_comm\n ; coefficients_comm =\n 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 ; xor_comm = f_opt t1.xor_comm t2.xor_comm\n ; range_check0_comm = f_opt t1.range_check0_comm t2.range_check0_comm\n ; range_check1_comm = f_opt t1.range_check1_comm t2.range_check1_comm\n ; foreign_field_add_comm =\n f_opt t1.foreign_field_add_comm t2.foreign_field_add_comm\n ; foreign_field_mul_comm =\n f_opt t1.foreign_field_mul_comm t2.foreign_field_mul_comm\n ; rot_comm = f_opt t1.rot_comm t2.rot_comm\n ; lookup_table_comm =\n Vector.map2 ~f:f_opt t1.lookup_table_comm t2.lookup_table_comm\n ; lookup_table_ids = f_opt t1.lookup_table_ids t2.lookup_table_ids\n ; runtime_tables_selector =\n f_opt t1.runtime_tables_selector t2.runtime_tables_selector\n ; lookup_selector_lookup =\n f_opt t1.lookup_selector_lookup t2.lookup_selector_lookup\n ; lookup_selector_xor = f_opt t1.lookup_selector_xor t2.lookup_selector_xor\n ; lookup_selector_range_check =\n f_opt t1.lookup_selector_range_check t2.lookup_selector_range_check\n ; lookup_selector_ffmul =\n f_opt t1.lookup_selector_ffmul t2.lookup_selector_ffmul\n }\n\n let typ g g_opt =\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 ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\n ; Vector.typ g_opt Plonk_types.Lookup_sorted_minus_1.n\n ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\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 forget_optional_commitments\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 ; xor_comm = _\n ; range_check0_comm = _\n ; range_check1_comm = _\n ; foreign_field_add_comm = _\n ; foreign_field_mul_comm = _\n ; rot_comm = _\n ; lookup_table_comm = _\n ; lookup_table_ids = _\n ; runtime_tables_selector = _\n ; lookup_selector_lookup = _\n ; lookup_selector_xor = _\n ; lookup_selector_range_check = _\n ; lookup_selector_ffmul = _\n } : _ Stable.Latest.t =\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 }\nend\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","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 (* to prevent giving a reference to the internal state *)\n let copy x = (P.copy [| x |]).(0) in\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 copy t.state.(0) )\n else (\n t.sponge_state <- Squeezed (n + 1) ;\n copy t.state.(n) )\n | Absorbed _ ->\n t.state <- block_cipher t.params t.state ;\n t.sponge_state <- Squeezed 1 ;\n copy 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\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\ntype '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\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, hash, equal]\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 with_public_evals =\n (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.proof_with_public\n\n type t = (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.prover_proof\n\n val create :\n Index.t\n -> primary:Scalar_field.Vector.t\n -> auxiliary:Scalar_field.Vector.t\n -> prev_chals:Scalar_field.t array\n -> prev_comms:Curve.Affine.Backend.t array\n -> with_public_evals\n\n val create_async :\n Index.t\n -> primary:Scalar_field.Vector.t\n -> auxiliary:Scalar_field.Vector.t\n -> prev_chals:Scalar_field.t array\n -> prev_comms:Curve.Affine.Backend.t array\n -> with_public_evals Promise.t\n\n val verify : Verifier_index.t -> with_public_evals -> bool\n\n val batch_verify :\n Verifier_index.t array -> with_public_evals 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 =\n { challenges : 'fq Bounded_types.ArrayN16.Stable.V1.t; 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 Bounded_types.ArrayN16.Stable.V1.t )\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 Bounded_types.ArrayN16.Stable.V1.t )\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.Stable.Latest 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 module T = struct\n type t = (G.Affine.t, Fq.t, Fq.t array) Pickles_types.Plonk_types.Proof.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.t\n -> openings:\n (G.Affine.t, Fq.t, Fq.t array) Pickles_types.Plonk_types.Openings.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 struct\n include Allocation_functor.Make.Basic (T)\n include Allocation_functor.Make.Partial.Sexp (T)\n include Allocation_functor.Make.Partial.Yojson (T)\n end :\n sig\n include\n Allocation_functor.Intf.Output.Basic_intf\n with type t := t\n and type 'a creator := 'a creator\n\n include\n Allocation_functor.Intf.Output.Sexp_intf\n with type t := t\n and type 'a creator := 'a creator\n\n include\n Allocation_functor.Intf.Output.Yojson_intf\n with type t := t\n and type 'a creator := 'a creator\n end )\n\n type with_public_evals =\n { proof : t\n ; public_evals : (Scalar_field.t array * Scalar_field.t array) option\n }\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\n 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 evals_to_tuple ({ zeta; zeta_omega } : _ Kimchi_types.point_evaluations) =\n (zeta, zeta_omega)\n\n let of_backend (t : Backend.t) : t =\n let proof = opening_proof_of_backend_exn t.proof in\n let evals =\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 =\n Vector.init\n Pickles_types.Plonk_types.Lookup_sorted_minus_1.n\n ~f:(fun i -> wo l.sorted.(i))\n ; sorted_5th_column =\n (* TODO: This is ugly and error-prone *)\n Option.try_with (fun () ->\n wo\n l.sorted.(Nat.to_int\n Pickles_types.Plonk_types\n .Lookup_sorted_minus_1\n .n) )\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 of_backend_with_public_evals (t : Backend.with_public_evals) :\n with_public_evals =\n { proof = of_backend t.proof\n ; public_evals = Option.map ~f:evals_to_tuple t.public_evals\n }\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 evals_of_tuple (zeta, zeta_omega) : _ Kimchi_types.point_evaluations =\n { zeta; zeta_omega }\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 { 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 =\n Array.map ~f:pcwo\n (Array.append (Vector.to_array t.sorted)\n (Option.to_array t.sorted_5th_column) )\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 to_backend_with_public_evals' (chal_polys : Challenge_polynomial.t list)\n primary_input ({ proof; public_evals } : with_public_evals) :\n Backend.with_public_evals =\n { proof = to_backend' chal_polys primary_input proof\n ; public_evals = Option.map ~f:evals_of_tuple public_evals\n }\n\n let to_backend_with_public_evals chal_polys primary_input t =\n to_backend_with_public_evals' chal_polys (List.to_array primary_input) t\n\n (* Extract challenges and commitments from the (optional) message *)\n let extract_challenges_and_commitments ~message =\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 (challenges, commitments)\n\n let create ?message pk ~primary ~auxiliary =\n let prev_chals, prev_comms = extract_challenges_and_commitments ~message in\n let res = Backend.create pk ~primary ~auxiliary ~prev_chals ~prev_comms in\n of_backend_with_public_evals res\n\n let create_async ?message pk ~primary ~auxiliary =\n let prev_chals, prev_comms = extract_challenges_and_commitments ~message in\n let%map.Promise res =\n Backend.create_async pk ~primary ~auxiliary ~prev_chals ~prev_comms\n in\n of_backend_with_public_evals res\n\n let batch_verify' (conv : 'a -> Fq.t array)\n (ts : (Verifier_index.t * with_public_evals * 'a * message option) list) =\n let logger = 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 =\n to_backend_with_public_evals'\n (Option.value ~default:[] m)\n (conv xs) t\n 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_with_public_evals'\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 compare : t -> t -> int\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 let zero = of_int 0 in\n let one = of_int 1 in\n fun n ->\n if equal n zero then Bignum_bigint.zero\n else if equal n one then Bignum_bigint.one\n else\n Bytes.unsafe_to_string\n ~no_mutation_while_string_reachable:(to_bytes n)\n |> Z.of_bits |> Bignum_bigint.of_zarith_bigint\n\n let hash_fold_t s x = Bignum_bigint.hash_fold_t s (to_bignum_bigint x)\n\n let hash = Hash.of_fold hash_fold_t\n\n let compare = compare\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 | AddFixedLookupTable of { id : int32; data : 'f array array }\n | AddRuntimeTableCfg of { id : int32; first_column : 'f array }\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 | AddFixedLookupTable { id; data } ->\n (* TODO: see a possible better API -\n https://github.com/MinaProtocol/mina/issues/13984 *)\n AddFixedLookupTable { id; data }\n | AddRuntimeTableCfg { id; first_column } ->\n AddRuntimeTableCfg { id; first_column }\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 equal zero res\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\ntype 'f fixed_lookup_tables =\n | Unfinalized_fixed_lookup_tables_rev of 'f Kimchi_types.lookup_table list\n | Compiled_fixed_lookup_tables of 'f Kimchi_types.lookup_table array\n\ntype 'f runtime_tables_cfg =\n | Unfinalized_runtime_tables_cfg_rev of 'f Kimchi_types.runtime_table_cfg list\n | Compiled_runtime_tables_cfg of 'f Kimchi_types.runtime_table_cfg array\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 (* Witnesses values corresponding to each runtime lookups *)\n ; mutable runtime_lookups_rev : (V.t * (V.t * V.t)) list\n (* The user-provided lookup tables associated with this circuit. *)\n ; mutable fixed_lookup_tables : 'f fixed_lookup_tables\n (* The user-provided runtime table configurations associated with this\n circuit. *)\n ; mutable runtime_tables_cfg : 'f runtime_tables_cfg\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\nlet get_concatenated_fixed_lookup_table_size sys =\n match sys.fixed_lookup_tables with\n | Unfinalized_fixed_lookup_tables_rev _ ->\n failwith\n \"Cannot get the fixed lookup tables before finalizing the constraint \\\n system\"\n | Compiled_fixed_lookup_tables flts ->\n let get_table_size (flt : _ Kimchi_types.lookup_table) =\n if Array.length flt.data = 0 then 0\n else Array.length (Array.get flt.data 0)\n in\n Array.fold_left (fun acc flt -> acc + get_table_size flt) 0 flts\n\nlet get_concatenated_runtime_lookup_table_size sys =\n match sys.runtime_tables_cfg with\n | Unfinalized_runtime_tables_cfg_rev _ ->\n failwith\n \"Cannot get the runtime table configurations before finalizing the \\\n constraint system\"\n | Compiled_runtime_tables_cfg rt_cfgs ->\n Array.fold_left\n (fun acc (rt_cfg : _ Kimchi_types.runtime_table_cfg) ->\n acc + Array.length rt_cfg.first_column )\n 0 rt_cfgs\n\nlet finalize_fixed_lookup_tables sys =\n match sys.fixed_lookup_tables with\n | Unfinalized_fixed_lookup_tables_rev fixed_lt_rev ->\n sys.fixed_lookup_tables <-\n Compiled_fixed_lookup_tables\n (Core_kernel.Array.of_list_rev fixed_lt_rev)\n | Compiled_fixed_lookup_tables _ ->\n failwith \"Fixed lookup tables have already been finalized\"\n\nlet finalize_runtime_lookup_tables sys =\n match sys.runtime_tables_cfg with\n | Unfinalized_runtime_tables_cfg_rev rt_cfgs_rev ->\n sys.runtime_tables_cfg <-\n Compiled_runtime_tables_cfg (Core_kernel.Array.of_list_rev rt_cfgs_rev)\n | Compiled_runtime_tables_cfg _ ->\n failwith \"Runtime table configurations have already been finalized\"\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 get_concatenated_fixed_lookup_table_size : t -> int\n\n val get_concatenated_runtime_lookup_table_size : t -> int\n\n (** Finalize the fixed lookup tables. The function can not be called twice *)\n val finalize_fixed_lookup_tables : t -> unit\n\n (** Finalize the runtime lookup table configurations. The function can not be\n called twice. *)\n val finalize_runtime_lookup_tables : t -> unit\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 :\n t\n -> (int -> Fp.t)\n -> Fp.t array array * Fp.t Kimchi_types.runtime_table array\n\n val finalize : t -> unit\n\n val finalize_and_get_gates :\n t\n -> Gates.t\n * Fp.t Kimchi_types.lookup_table array\n * Fp.t Kimchi_types.runtime_table_cfg array\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 (* Used by compute_witness to build the runtime tables from the Lookup\n constraint *)\n module MapRuntimeTable = struct\n module T = struct\n type t = int32 * Fp.t [@@deriving hash, sexp, compare]\n end\n\n include T\n include Core_kernel.Hashable.Make (T)\n end\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 * Fp.t Kimchi_types.runtime_table 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\n let map_runtime_tables = MapRuntimeTable.Table.create () in\n let runtime_tables : Fp.t Kimchi_types.runtime_table array =\n match sys.runtime_tables_cfg with\n | Unfinalized_runtime_tables_cfg_rev _ ->\n failwith\n \"Attempted to generate a witness for an unfinalized constraint \\\n system\"\n | Compiled_runtime_tables_cfg cfgs ->\n Array.mapi cfgs ~f:(fun rt_idx { Kimchi_types.id; first_column } ->\n let data =\n Array.mapi first_column ~f:(fun i v ->\n ignore\n (* `add` leaves the value unchanged if the index has been\n already used. Therefore, it keeps the first value.\n This handles the case that the first column has\n duplicated index values.\n *)\n @@ MapRuntimeTable.Table.add map_runtime_tables ~key:(id, v)\n ~data:(i, rt_idx) ;\n (* default padding value for lookup *)\n Fp.zero )\n in\n let rt : Fp.t Kimchi_types.runtime_table = { id; data } in\n rt )\n in\n\n (* Fill in the used entries of the runtime lookup tables. *)\n List.iter (List.rev sys.runtime_lookups_rev) ~f:(fun (id, (idx, v)) ->\n let compute_value x = compute ([ (Fp.one, x) ], None) in\n let vid = compute_value id in\n let vidx = compute_value idx in\n let vv = compute_value v in\n (* FIXME: we should have a int32 here. We are not sure the ID will be a\n int32. We should enforce that.\n See https://github.com/MinaProtocol/mina/issues/13955\n *)\n let id_int32 = Int32.of_string @@ Fp.to_string vid in\n (* Using find allows to handle fixed lookup tables\n As the map has been built from the runtime table configurations,\n except in the case that a runtime table and a fixed table shares the\n same ID, the lookups in fixed lookup tables will return None.\n See https://github.com/MinaProtocol/mina/issues/14016\n *)\n let v =\n MapRuntimeTable.Table.find map_runtime_tables (id_int32, vidx)\n in\n if Option.is_some v then\n let i, rt_idx = Option.value_exn v in\n let rt = runtime_tables.(rt_idx) in\n (* Important note: we do not check if the value has been set before.\n Therefore, it will always use the latest value *)\n rt.data.(i) <- vv ) ;\n (* Return the witness. *)\n (res, runtime_tables)\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 ; runtime_lookups_rev = []\n ; fixed_lookup_tables = Unfinalized_fixed_lookup_tables_rev []\n ; runtime_tables_cfg = Unfinalized_runtime_tables_cfg_rev []\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 let get_concatenated_fixed_lookup_table_size (sys : t) =\n get_concatenated_fixed_lookup_table_size sys\n\n let get_concatenated_runtime_lookup_table_size (sys : t) =\n get_concatenated_runtime_lookup_table_size sys\n\n let finalize_fixed_lookup_tables = finalize_fixed_lookup_tables\n\n let finalize_runtime_lookup_tables = finalize_runtime_lookup_tables\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 ; fixed_lookup_tables = Compiled_fixed_lookup_tables fixed_lookup_tables\n ; runtime_tables_cfg = Compiled_runtime_tables_cfg runtime_tables_cfg\n ; _\n } ->\n (gates, fixed_lookup_tables, runtime_tables_cfg)\n (* Finalizing lookup tables and runtime table cfgs first *)\n | { fixed_lookup_tables = Unfinalized_fixed_lookup_tables_rev _; _ } ->\n finalize_fixed_lookup_tables sys ;\n finalize_and_get_gates sys\n | { runtime_tables_cfg = Unfinalized_runtime_tables_cfg_rev _; _ } ->\n finalize_runtime_lookup_tables sys ;\n finalize_and_get_gates sys\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 ; fixed_lookup_tables = Compiled_fixed_lookup_tables fixed_lookup_tables\n ; runtime_tables_cfg = Compiled_runtime_tables_cfg runtime_tables_cfg\n ; _\n } ->\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, fixed_lookup_tables, runtime_tables_cfg)\n\n (** Calls [finalize_and_get_gates] and ignores the result. *)\n let finalize t =\n ignore\n ( finalize_and_get_gates t\n : Gates.t\n * Fp.t Kimchi_types.lookup_table array\n * Fp.t Kimchi_types.runtime_table_cfg array )\n\n let num_constraints sys =\n let gates, _, _ = finalize_and_get_gates sys in\n Gates.len gates\n\n let to_json (sys : t) : string =\n (* TODO: add lookup tables and runtime table cfgs *)\n (* https://github.com/MinaProtocol/mina/issues/13886 *)\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 ~equal\n ~one)\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 (* -s*x + s^2*x*x = 0 *)\n add_generic_constraint ~l:x ~r:x\n [| Fp.negate s; Fp.zero; Fp.zero; Fp.square s; 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 (* table ID *)\n let red_w0 = reduce_to_v w0 in\n (* idx1 *)\n let red_w1 = reduce_to_v w1 in\n (* v1 *)\n let red_w2 = reduce_to_v w2 in\n (* idx2 *)\n let red_w3 = reduce_to_v w3 in\n (* v2 *)\n let red_w4 = reduce_to_v w4 in\n (* idx3 *)\n let red_w5 = reduce_to_v w5 in\n (* v3 *)\n let red_w6 = reduce_to_v w6 in\n let vars =\n [| Some red_w0\n ; Some red_w1\n ; Some red_w2\n ; Some red_w3\n ; Some red_w4\n ; Some red_w5\n ; Some red_w6\n |]\n in\n let lookup1 = (red_w0, (red_w1, red_w2)) in\n let lookup2 = (red_w0, (red_w3, red_w4)) in\n let lookup3 = (red_w0, (red_w5, red_w6)) in\n (* We populate with the first lookup. In the case the user uses the same\n index multiple times, the last value will be used *)\n sys.runtime_lookups_rev <-\n lookup3 :: lookup2 :: lookup1 :: sys.runtime_lookups_rev ;\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 (AddFixedLookupTable { id; data }) -> (\n match sys.fixed_lookup_tables with\n | Unfinalized_fixed_lookup_tables_rev fixed_lookup_tables ->\n let lt : Fp.t Kimchi_types.lookup_table list =\n { id; data } :: fixed_lookup_tables\n in\n sys.fixed_lookup_tables <- Unfinalized_fixed_lookup_tables_rev lt\n | Compiled_fixed_lookup_tables _ ->\n failwith\n \"Trying to add a fixed lookup tables when it has been already \\\n finalized\" )\n | Plonk_constraint.T (AddRuntimeTableCfg { id; first_column }) -> (\n match sys.runtime_tables_cfg with\n | Unfinalized_runtime_tables_cfg_rev runtime_tables_cfg ->\n let rt_cfg : Fp.t Kimchi_types.runtime_table_cfg list =\n { id; first_column } :: runtime_tables_cfg\n in\n sys.runtime_tables_cfg <- Unfinalized_runtime_tables_cfg_rev rt_cfg\n | Compiled_runtime_tables_cfg _ ->\n failwith\n \"Trying to add a runtime table configuration it has been \\\n already finalized\" )\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 type with_public_evals =\n ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.proof_with_public\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:backend_create (pk : Keypair.t) primary auxiliary\n prev_chals 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, runtime_tables =\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 backend_create pk.index witness_cols runtime_tables prev_chals prev_comms\n\n let create_async (pk : Keypair.t) ~primary ~auxiliary ~prev_chals\n ~prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms\n ~f:(fun index witness runtime_tables prev_chals prev_sgs ->\n Promise.run_in_thread (fun () ->\n Kimchi_bindings.Protocol.Proof.Fp.create index witness\n runtime_tables prev_chals 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\n ~f:Kimchi_bindings.Protocol.Proof.Fp.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\n let create_with_public_evals = with_lagrange create_with_public_evals\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 type with_public_evals =\n ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.proof_with_public\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:backend_create (pk : Keypair.t) ~primary ~auxiliary\n ~prev_chals ~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, runtime_tables =\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 backend_create pk.index witness_cols runtime_tables prev_chals prev_comms\n\n let create_async (pk : Keypair.t) ~primary ~auxiliary ~prev_chals\n ~prev_comms =\n create_aux pk ~primary ~auxiliary ~prev_chals ~prev_comms\n ~f:(fun index witness runtime_tables prev_chals prev_sgs ->\n Promise.run_in_thread (fun () ->\n Kimchi_bindings.Protocol.Proof.Fq.create index witness\n runtime_tables prev_chals 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\n ~f:Kimchi_bindings.Protocol.Proof.Fq.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\n let create_with_public_evals = with_lagrange create_with_public_evals\n end\nend)\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_exn (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 raise\n (Invalid_argument\n (Printf.sprintf \"Proofs_verified.of_nat: got %d\" (to_int n)) )\n\nlet of_int_exn (n : int) : t =\n match n with\n | 0 ->\n N0\n | 1 ->\n N1\n | 2 ->\n N2\n | _ ->\n raise\n (Invalid_argument (Printf.sprintf \"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\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 = 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\n module In_circuit = 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, 'bool) Opt.t\n ; feature_flags : 'bool Plonk_types.Features.t\n }\n end\n end\n\n open Pickles_types\n\n module In_circuit = struct\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 , 'scalar_challenge_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 ; joint_combiner : 'scalar_challenge_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 ; joint_combiner = Opt.map ~f:scalar t.joint_combiner\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)\n (module Impl : Snarky_backendless.Snark_intf.Run\n with type field = f ) ~dummy_scalar_challenge ~challenge\n ~scalar_challenge ~bool\n ~feature_flags:\n ({ Plonk_types.Features.Full.uses_lookups; _ } as 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 ; Plonk_types.Features.typ\n ~feature_flags:(Plonk_types.Features.of_full feature_flags)\n bool\n ; Opt.typ Impl.Boolean.typ uses_lookups\n ~dummy:dummy_scalar_challenge\n (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 ) ~(to_option : lookup_opt -> scalar_challenge 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 = to_option t.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_challenge ~challenge ~scalar_challenge ~feature_flags\n (fp : (fp, _, f) Snarky_backendless.Typ.t) index =\n Snarky_backendless.Typ.of_hlistable\n [ Plonk.In_circuit.typ impl ~dummy_scalar_challenge ~challenge\n ~scalar_challenge ~bool:Impl.Boolean.typ ~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_challenge ~challenge ~scalar_challenge ~feature_flags\n (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_challenge\n ~challenge ~scalar_challenge ~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 | Opt.Flag.Yes ->\n constant true\n | Opt.Flag.No ->\n constant false\n | 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 ; joint_combiner\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 =\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 joint_combiner ~f:(fun x -> Hlist.HlistId.[ x ])\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 ; joint_combiner\n ] ~option_map : _ 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 ; joint_combiner =\n option_map joint_combiner ~f:(fun Hlist.HlistId.[ x ] ->\n x )\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 ; joint_combiner = 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 ; joint_combiner\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 joint_combiner ;\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) _ ~challenge ~scalar_challenge\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 =\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 ) ~assert_16_bits\n (proofs_verified : (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 _ = Per_proof.typ impl fq ~assert_16_bits 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_zk_rows : 'a\n ; zeta_to_n_minus_1 : 'a\n ; zeta_to_srs_length : 'a Lazy.t\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_zero_knowledge_and_previous_rows : 'a\n ; joint_combiner : 'a\n ; beta : 'a\n ; gamma : 'a\n ; unnormalized_lagrange_basis : bool * 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_zk_rows = _\n ; zeta_to_n_minus_1 = _\n ; zeta_to_srs_length = _\n ; srs_length_log2 = _\n ; vanishes_on_zero_knowledge_and_previous_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_zero_knowledge_and_previous_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 (false, 0)\n * ( cell (var (LookupAggreg, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n + alpha_pow 26\n * ( unnormalized_lagrange_basis (true, -1)\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 (true, -1)\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 (false, 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 (true, -1)\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 (false, 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_zk_rows = _\n ; zeta_to_n_minus_1 = _\n ; zeta_to_srs_length = _\n ; srs_length_log2 = _\n ; vanishes_on_zero_knowledge_and_previous_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","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 { state_hash : string\n ; blockchain_length : int\n ; global_slot_since_genesis : 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\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 ; length : int\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 ; length = 4096\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 assocs\n | json ->\n `Assoc [ (\"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\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 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 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)\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 = Kimchi_pasta_basic.poseidon_params_fp\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\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\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\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)) =\n Impls.Wrap.input ~feature_flags:Plonk_types.Features.Full.maybe ()\n 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 ; xor_comm = None\n ; range_check0_comm = None\n ; range_check1_comm = None\n ; foreign_field_add_comm = None\n ; foreign_field_mul_comm = None\n ; rot_comm = None\n } )\n ; shifts = Common.tock_shifts ~log2_size\n ; lookup_index = None\n ; zk_rows = 3\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 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.with_public_evals\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 { 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 Bounded_types.ArrayN16.Stable.V1.t )\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 (* NB: This should be on the *serialized type*. However, the actual\n serialized type [Repr.t] is hidden by this module, so this alias is\n effectively junk anyway..\n *)\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 ( 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.default ~num_chunks:1 (* TODO *) 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 (let evals = Lazy.force Dummy.evals in\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 = evals.evals.evals\n ; ft_eval1 = evals.ft_eval1\n } )\n }\n ; prev_evals =\n (let e =\n Plonk_types.Evals.map Evaluation_lengths.default ~f:(fun n ->\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.Stable.V2.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 { statement; prev_evals; proof }) : Repr.t =\n let lte =\n Nat.lte_exn\n (Vector.length\n statement.messages_for_next_step_proof\n .challenge_polynomial_commitments )\n W.n\n in\n let statement =\n { statement with\n messages_for_next_step_proof =\n { statement.messages_for_next_step_proof with\n challenge_polynomial_commitments =\n At_most.of_vector\n statement.messages_for_next_step_proof\n .challenge_polynomial_commitments lte\n ; old_bulletproof_challenges =\n At_most.of_vector\n statement.messages_for_next_step_proof\n .old_bulletproof_challenges lte\n }\n }\n in\n let prev_evals : _ Plonk_types.All_evals.Stable.V1.t =\n { evals =\n { prev_evals.evals with\n public_input =\n (let x1, x2 = prev_evals.evals.public_input in\n (x1.(0), x2.(0)) )\n }\n ; ft_eval1 = prev_evals.ft_eval1\n }\n in\n { statement; prev_evals; proof }\n\n let of_repr ({ statement; prev_evals; proof } : Repr.t) : t =\n let (Vector.T challenge_polynomial_commitments) =\n At_most.to_vector\n statement.messages_for_next_step_proof.challenge_polynomial_commitments\n in\n let (Vector.T old_bulletproof_challenges) =\n At_most.to_vector\n 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 let statement =\n { statement with\n messages_for_next_step_proof =\n { statement.messages_for_next_step_proof with\n challenge_polynomial_commitments\n ; old_bulletproof_challenges\n }\n }\n in\n let prev_evals : _ Plonk_types.All_evals.t =\n { evals =\n { public_input =\n (let x1, x2 = prev_evals.evals.public_input in\n ([| x1 |], [| x2 |]) )\n ; evals = prev_evals.evals.evals\n }\n ; ft_eval1 = prev_evals.ft_eval1\n }\n in\n T { statement; prev_evals; proof }\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 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 x = to_repr x\n\n let of_binable x = of_repr x\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 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 x = to_repr x\n\n let of_binable x = of_repr x\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 = Kimchi_pasta_basic.poseidon_params_fq\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 (* 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 ('comm, 'comm_opt) index' =\n ('comm, 'comm_opt) Plonk_verification_key_evals.Step.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 array, (Inner_curve.t array, Boolean.var) Opt.t) index'\n , n )\n Vector.t\n -> (Inner_curve.t array, (Inner_curve.t array, Boolean.var) Opt.t) index'\n =\n let open Tuple_lib 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 ->\n Plonk_verification_key_evals.Step.map key\n ~f:(Array.map ~f:(fun g -> Double.map g ~f:(( * ) (b :> t))))\n ~f_opt:(function\n (* Here, we split the 3 variants into 3 separate accumulators. This\n allows us to only compute the 'maybe' flag when we need to, and\n allows us to fall back to the basically-free `Nothing` when a\n feature is entirely unused, or to the less expensive `Just` if\n it is used for every circuit.\n In particular, it is important that we generate exactly\n `Nothing` when none of the optional gates are used, otherwise\n we will change the serialization of the protocol circuits.\n *)\n | Opt.Nothing ->\n ([], [], [ b ])\n | Opt.Maybe (b_x, x) ->\n ([], [ (b, b_x, x) ], [])\n | Opt.Just x ->\n ([ (b, x) ], [], []) ) )\n |> Vector.reduce_exn\n ~f:\n (Plonk_verification_key_evals.Step.map2\n ~f:(Array.map2_exn ~f:(Double.map2 ~f:( + )))\n ~f_opt:(fun (yes_1, maybe_1, no_1) (yes_2, maybe_2, no_2) ->\n (yes_1 @ yes_2, maybe_1 @ maybe_2, no_1 @ no_2) ) )\n |> Plonk_verification_key_evals.Step.map ~f:Fn.id ~f_opt:(function\n | [], [], _nones ->\n (* We only have `Nothing`s, so we can emit exactly `Nothing`\n without further computation.\n *)\n Opt.Nothing\n | justs, [], [] ->\n (* Special case: we don't need to compute the 'maybe' bool\n because we know statically that all entries are `Just`.\n *)\n let sum =\n justs\n |> List.map ~f:(fun ((b : Boolean.var), g) ->\n Array.map g ~f:(Double.map ~f:(( * ) (b :> t))) )\n |> List.reduce_exn\n ~f:(Array.map2_exn ~f:(Double.map2 ~f:( + )))\n in\n Opt.just sum\n | justs, maybes, nones ->\n let is_none =\n List.reduce nones\n ~f:(fun (b1 : Boolean.var) (b2 : Boolean.var) ->\n Boolean.Unsafe.of_cvar Field.(add (b1 :> t) (b2 :> t)) )\n in\n let none_sum =\n let num_chunks = (* TODO *) 1 in\n Option.map is_none ~f:(fun (b : Boolean.var) ->\n Array.init num_chunks ~f:(fun _ ->\n Double.map Inner_curve.one ~f:(( * ) (b :> t)) ) )\n in\n let just_is_yes, just_sum =\n justs\n |> List.map ~f:(fun ((b : Boolean.var), g) ->\n (b, Array.map g ~f:(Double.map ~f:(( * ) (b :> t)))) )\n |> List.reduce\n ~f:(fun ((b1 : Boolean.var), g1) ((b2 : Boolean.var), g2)\n ->\n ( Boolean.Unsafe.of_cvar Field.(add (b1 :> t) (b2 :> t))\n , Array.map2_exn ~f:(Double.map2 ~f:( + )) g1 g2 ) )\n |> fun x -> (Option.map ~f:fst x, Option.map ~f:snd x)\n in\n let maybe_is_yes, maybe_sum =\n maybes\n |> List.map\n ~f:(fun ((b : Boolean.var), (b_g : Boolean.var), g) ->\n ( Boolean.Unsafe.of_cvar Field.(mul (b :> t) (b_g :> t))\n , Array.map g ~f:(Double.map ~f:(( * ) (b :> t))) ) )\n |> List.reduce\n ~f:(fun ((b1 : Boolean.var), g1) ((b2 : Boolean.var), g2)\n ->\n ( Boolean.Unsafe.of_cvar Field.(add (b1 :> t) (b2 :> t))\n , Array.map2_exn ~f:(Double.map2 ~f:( + )) g1 g2 ) )\n |> fun x -> (Option.map ~f:fst x, Option.map ~f:snd x)\n in\n let is_yes =\n [| just_is_yes; maybe_is_yes |]\n |> Array.filter_map ~f:Fn.id\n |> Array.reduce_exn\n ~f:(fun (b1 : Boolean.var) (b2 : Boolean.var) ->\n Boolean.Unsafe.of_cvar ((b1 :> t) + (b2 :> t)) )\n in\n let sum =\n [| none_sum; maybe_sum; just_sum |]\n |> Array.filter_map ~f:Fn.id\n |> Array.reduce_exn\n ~f:(Array.map2_exn ~f:(Double.map2 ~f:( + )))\n in\n Opt.Maybe (is_yes, sum) )\n |> Plonk_verification_key_evals.Step.map\n ~f:(fun g -> Array.map ~f:(Double.map ~f:(Util.seal (module Impl))) g)\n ~f_opt:(function\n | Opt.Nothing ->\n Opt.Nothing\n | Opt.Maybe (b, x) ->\n Opt.Maybe\n ( Boolean.Unsafe.of_cvar (Util.seal (module Impl) (b :> t))\n , Array.map ~f:(Double.map ~f:(Util.seal (module Impl))) x )\n | Opt.Just x ->\n Opt.Just\n (Array.map ~f:(Double.map ~f:(Util.seal (module Impl))) x) )\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 let chunks =\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n in\n Array.map chunks ~f:(function\n | Finite g ->\n let g = Inner_curve.Constant.of_affine g in\n Inner_curve.constant g\n | Infinity ->\n (* Point at infinity should be impossible in the SRS *)\n assert false ) )\n |> Vector.map2\n (which_branch :> (Boolean.var, n) Vector.t)\n ~f:(fun b pts ->\n Array.map pts ~f:(fun (x, y) -> Field.((b :> t) * x, (b :> t) * y))\n )\n |> Vector.reduce_exn ~f:(Array.map2_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 let chunks =\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n in\n Array.map chunks ~f:(function\n | Finite g ->\n let g = Inner_curve.Constant.of_affine g in\n Inner_curve.Constant.scale g c |> Inner_curve.constant\n | Infinity ->\n (* Point at infinity should be impossible in the SRS *)\n assert false ) )\n |> Vector.map2\n (which_branch :> (Boolean.var, n) Vector.t)\n ~f:(fun b pts ->\n Array.map pts ~f:(fun (x, y) -> Field.((b :> t) * x, (b :> t) * y))\n )\n |> Vector.reduce_exn ~f:(Array.map2_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 :\n Inner_curve.t Double.t array =\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 (* computes 2^i *)\n let rec field2pow f i =\n if i = 1 then f\n else\n let j = i - 1 in\n Inner_curve.Constant.Scalar.(f * field2pow f j)\n in\n (* computes 2^actual_shift *)\n let two_to_actual_shift =\n field2pow (Inner_curve.Constant.Scalar.of_int 2) actual_shift\n in\n (* computes [2^actual_shift] G *)\n let field_to_two_to_shift g =\n Inner_curve.Constant.scale g two_to_actual_shift\n in\n let base_and_correction (h : Domain.t) =\n let d = Int.pow 2 (Domain.log2_size h) in\n let chunks =\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n in\n Array.map chunks ~f:(function\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 (field_to_two_to_shift g)) )\n | Infinity ->\n (* Point at infinity should be impossible in the SRS *)\n assert false )\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 Array.map pr\n ~f:\n (Double.map ~f:(fun (x, y) ->\n Field.((b :> t) * x, (b :> t) * y) ) ) )\n |> Vector.reduce_exn\n ~f:\n (Array.map2_exn\n ~f:(Double.map2 ~f:(Double.map2 ~f:Field.( + ))) )\n |> Array.map\n ~f:(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 assert_finite : t -> unit = function\n | `Finite _ ->\n ()\n | `Maybe_finite _ ->\n failwith \"Not finite\"\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 reduce_point p =\n let point = ref (Point.underlying p.(Array.length p - 1)) in\n for i = Array.length p - 2 downto 0 do\n point := Point.add p.(i) (Scalar_challenge.endo !point xi)\n done ;\n !point\n in\n let { Curve_opt.non_zero; point } =\n Pcs_batch.combine_split_commitments batch\n ~reduce_with_degree_bound:(fun _ -> assert false)\n ~reduce_without_degree_bound:(fun x -> [ x ])\n ~scale_and_add:(fun ~(acc : Curve_opt.t) ~xi\n (p : (Point.t array, Boolean.var) Opt.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 keep p =\n let base_point =\n let p = p.(Array.length p - 1) in\n Inner_curve.(\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 in\n let point = ref base_point in\n for i = Array.length p - 2 downto 0 do\n point := Point.add p.(i) (Scalar_challenge.endo !point xi)\n done ;\n let point =\n Inner_curve.(if_ keep ~then_:!point ~else_:acc.point)\n in\n Array.iter ~f:Point.assert_finite p ;\n let non_zero = Boolean.(keep &&& true_ ||| acc.non_zero) in\n { Curve_opt.non_zero; point }\n in\n match p with\n | Opt.Nothing ->\n acc\n | Opt.Maybe (keep, p) ->\n point keep p\n | Opt.Just p ->\n point Boolean.true_ p )\n ~xi\n ~init:(function\n | Opt.Nothing ->\n None\n | Opt.Maybe (keep, p) ->\n Array.iter ~f:Point.assert_finite p ;\n Some\n { non_zero = Boolean.(keep &&& true_)\n ; point = reduce_point p\n }\n | Opt.Just p ->\n Array.iter ~f:Point.assert_finite p ;\n Some\n { non_zero = Boolean.(true_ &&& true_)\n ; point = reduce_point 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.In_circuit.alpha = alpha_0\n ; beta = beta_0\n ; gamma = gamma_0\n ; zeta = zeta_0\n ; joint_combiner = joint_combiner_0\n ; feature_flags = _\n }\n { Plonk.Minimal.In_circuit.alpha = alpha_1\n ; beta = beta_1\n ; gamma = gamma_1\n ; zeta = zeta_1\n ; joint_combiner = joint_combiner_1\n ; feature_flags = _\n } =\n with_label __LOC__ (fun () ->\n match[@warning \"-4\"] (joint_combiner_0, joint_combiner_1) with\n | Nothing, Nothing ->\n ()\n | Maybe (b0, j0), Maybe (b1, j1) ->\n Boolean.Assert.(b0 = b1) ;\n let (Typ { var_to_fields; _ }) = Scalar_challenge.typ in\n Array.iter2_exn ~f:Field.Assert.equal\n (fst @@ var_to_fields j0)\n (fst @@ var_to_fields j1)\n | Just j0, Just j1 ->\n let (Typ { var_to_fields; _ }) = Scalar_challenge.typ in\n Array.iter2_exn ~f:Field.Assert.equal\n (fst @@ var_to_fields j0)\n (fst @@ var_to_fields j1)\n | ( ((Pickles_types.Opt.Just _ | Maybe _ | Nothing) as j0)\n , ((Pickles_types.Opt.Just _ | Maybe _ | Nothing) as j1) ) ->\n let sexp_of t =\n Sexp.to_string\n @@ Types.Opt.sexp_of_t\n (fun _ -> Sexp.Atom \"\")\n (fun _ -> Sexp.Atom \"\")\n t\n in\n failwithf\n \"incompatible optional states for joint_combiners: %s vs %s\"\n (sexp_of j0) (sexp_of j1) () ) ;\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.In_circuit.t)\n (m2 : (_, Scalar_challenge.t, _) Plonk.Minimal.In_circuit.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 index_to_field_elements ~g (m : _ Plonk_verification_key_evals.Step.t) =\n let { Plonk_verification_key_evals.Step.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 ; range_check0_comm\n ; range_check1_comm\n ; foreign_field_mul_comm\n ; foreign_field_add_comm\n ; xor_comm\n ; rot_comm\n ; lookup_table_comm\n ; lookup_table_ids\n ; runtime_tables_selector\n ; lookup_selector_xor\n ; lookup_selector_lookup\n ; lookup_selector_range_check\n ; lookup_selector_ffmul\n } =\n m\n in\n let open Pickles_types in\n let g_opt = Opt.map ~f:g 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:(fun x -> Opt.just (g x))\n @ [ g_opt range_check0_comm\n ; g_opt range_check1_comm\n ; g_opt foreign_field_mul_comm\n ; g_opt foreign_field_add_comm\n ; g_opt xor_comm\n ; g_opt rot_comm\n ]\n @ List.map ~f:g_opt (Vector.to_list lookup_table_comm)\n @ [ g_opt lookup_table_ids\n ; g_opt runtime_tables_selector\n ; g_opt lookup_selector_xor\n ; g_opt lookup_selector_lookup\n ; g_opt lookup_selector_range_check\n ; g_opt lookup_selector_ffmul\n ]\n\n (** Simulate an [Opt_sponge.t] locally in a block, but without running the\n expensive optional logic that is otherwise required.\n\n Invariant: This requires that the sponge 'state' (i.e. the state after\n absorbing or squeezing) is consistent between the initial state and the\n final state when using the sponge.\n *)\n let simulate_optional_sponge_with_alignment (sponge : Sponge.t) ~f = function\n | Pickles_types.Opt.Nothing ->\n Pickles_types.Opt.Nothing\n | Pickles_types.Opt.Maybe (b, x) ->\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 (* Use the sponge *)\n let res = f sponge x in\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 Pickles_types.Opt.Maybe (b, res)\n | Pickles_types.Opt.Just x ->\n Pickles_types.Opt.Just (f sponge x)\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 : (_ array, _) Plonk_verification_key_evals.Step.t)\n ~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 List.iter\n (index_to_field_elements\n ~g:\n (Array.concat_map ~f:(fun (z : Inputs.Inner_curve.t) ->\n List.to_array (Inner_curve.to_field_elements z) ) )\n m )\n ~f:(fun x ->\n let (_ : (unit, _) Pickles_types.Opt.t) =\n simulate_optional_sponge_with_alignment index_sponge x\n ~f:(fun sponge x ->\n Array.iter ~f:(Sponge.absorb sponge) x )\n in\n () ) ;\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:(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 (_, chunks) ->\n Some (Array.map ~f:snd chunks) ) )\n ~f:(Array.map2_exn ~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:(Array.map2_exn ~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 Array.map2_exn acc g ~f:(fun acc g ->\n Inner_curve.if_ b ~then_:(Ops.add_fast g acc)\n ~else_:acc ) )\n | `Add_with_correction ((x, num_bits), chunks) ->\n Array.map2_exn acc chunks ~f:(fun acc (g, _) ->\n Ops.add_fast acc\n (Ops.scale_fast2'\n (module Other_field.With_top_bit0)\n g x ~num_bits ) ) ) ) )\n |> Array.map ~f:Inner_curve.negate\n in\n let x_hat =\n with_label \"x_hat blinding\" (fun () ->\n Array.map x_hat ~f:(fun x_hat ->\n Ops.add_fast x_hat\n (Inner_curve.constant (Lazy.force Generators.h)) ) )\n in\n Array.iter x_hat ~f:(fun x_hat ->\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 runtime_comm =\n match messages.lookup with\n | Nothing\n | Maybe (_, { runtime = Nothing; _ })\n | Just { runtime = Nothing; _ } ->\n Pickles_types.Opt.Nothing\n | Maybe (b_lookup, { runtime = Maybe (b_runtime, runtime); _ }) ->\n let b = Boolean.( &&& ) b_lookup b_runtime in\n Pickles_types.Opt.Maybe (b, runtime)\n | Maybe (b, { runtime = Just runtime; _ })\n | Just { runtime = Maybe (b, runtime); _ } ->\n Pickles_types.Opt.Maybe (b, runtime)\n | Just { runtime = Just runtime; _ } ->\n Pickles_types.Opt.Just runtime\n in\n let absorb_runtime_tables () =\n match runtime_comm with\n | Nothing ->\n ()\n | Maybe (b, runtime) ->\n let z = Array.map runtime ~f:(fun z -> (b, z)) in\n absorb sponge Without_degree_bound z\n | Just runtime ->\n let z = Array.map runtime ~f:(fun z -> (Boolean.true_, z)) in\n absorb sponge Without_degree_bound z\n in\n absorb_runtime_tables () ;\n let joint_combiner =\n let compute_joint_combiner (l : _ Messages.Lookup.In_circuit.t) =\n let absorb_sorted_1 sponge =\n let (first :: _) = l.sorted in\n let z = Array.map first ~f:(fun z -> (Boolean.true_, z)) in\n absorb sponge Without_degree_bound z\n in\n let absorb_sorted_2_to_4 () =\n let (_ :: rest) = l.sorted in\n Vector.iter rest ~f:(fun z ->\n let z = Array.map z ~f:(fun z -> (Boolean.true_, z)) in\n absorb sponge Without_degree_bound z )\n in\n let absorb_sorted_5 () =\n match l.sorted_5th_column with\n | Nothing ->\n ()\n | Maybe (b, z) ->\n let z = Array.map z ~f:(fun z -> (b, z)) in\n absorb sponge Without_degree_bound z\n | Just z ->\n let z = Array.map z ~f:(fun z -> (Boolean.true_, z)) in\n absorb sponge Without_degree_bound z\n in\n match[@warning \"-4\"]\n (m.lookup_table_comm, m.runtime_tables_selector)\n with\n | _ :: Just _ :: _, _ | _, Just _ ->\n let joint_combiner = sample_scalar () in\n absorb_sorted_1 sponge ;\n absorb_sorted_2_to_4 () ;\n absorb_sorted_5 () ;\n joint_combiner\n | _ :: Nothing :: _, Nothing ->\n absorb_sorted_1 sponge ;\n absorb_sorted_2_to_4 () ;\n absorb_sorted_5 () ;\n { inner = Field.zero }\n | _ :: Maybe (b1, _) :: _, Maybe (b2, _) ->\n let b = Boolean.(b1 ||| b2) in\n let sponge2 = Opt.copy sponge in\n let joint_combiner_if_true =\n let joint_combiner = sample_scalar () in\n absorb_sorted_1 sponge ; joint_combiner\n in\n let joint_combiner_if_false : Scalar_challenge.t =\n absorb_sorted_1 sponge2 ; { inner = Field.zero }\n in\n Opt.recombine b ~original_sponge:sponge2 sponge ;\n absorb_sorted_2_to_4 () ;\n absorb_sorted_5 () ;\n { inner =\n Field.if_ b ~then_:joint_combiner_if_true.inner\n ~else_:joint_combiner_if_false.inner\n }\n | _ :: Maybe (b, _) :: _, _ | _, Maybe (b, _) ->\n let sponge2 = Opt.copy sponge in\n let joint_combiner_if_true =\n let joint_combiner = sample_scalar () in\n absorb_sorted_1 sponge ; joint_combiner\n in\n let joint_combiner_if_false : Scalar_challenge.t =\n absorb_sorted_1 sponge2 ; { inner = Field.zero }\n in\n Opt.recombine b ~original_sponge:sponge2 sponge ;\n absorb_sorted_2_to_4 () ;\n absorb_sorted_5 () ;\n { inner =\n Field.if_ b ~then_:joint_combiner_if_true.inner\n ~else_:joint_combiner_if_false.inner\n }\n in\n match messages.lookup with\n | Nothing ->\n Types.Opt.Nothing\n | Maybe (b, l) ->\n Opt.consume_all_pending sponge ;\n let sponge2 = Opt.copy sponge in\n let joint_combiner = compute_joint_combiner l in\n Opt.consume_all_pending sponge ;\n Opt.recombine b ~original_sponge:sponge2 sponge ;\n (* We explicitly set this, because when we squeeze for [beta], we\n there will be no pending values *but* we don't want to add a\n dedicated permutation.\n *)\n sponge.needs_final_permute_if_empty <- false ;\n Types.Opt.Maybe (b, joint_combiner)\n | Just l ->\n Opt.consume_all_pending sponge ;\n Types.Opt.just (compute_joint_combiner l)\n in\n let lookup_table_comm =\n let compute_lookup_table_comm (l : _ Messages.Lookup.In_circuit.t)\n joint_combiner =\n let (first_column :: second_column :: rest) = m.lookup_table_comm in\n let second_column_with_runtime =\n match (second_column, l.runtime) with\n | Types.Opt.Nothing, comm | comm, Types.Opt.Nothing ->\n comm\n | ( Types.Opt.Maybe (has_second_column, second_column)\n , Types.Opt.Maybe (has_runtime, runtime) ) ->\n let second_with_runtime =\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) second_column runtime\n in\n Array.map2_exn second_column sum\n ~f:(fun second_column sum ->\n Inner_curve.if_ has_runtime ~then_:sum\n ~else_:second_column )\n in\n let res =\n Array.map2_exn second_with_runtime runtime\n ~f:(fun second_with_runtime runtime ->\n Inner_curve.if_ has_second_column\n ~then_:second_with_runtime ~else_:runtime )\n in\n let b = Boolean.(has_second_column ||| has_runtime) in\n Types.Opt.maybe b res\n | ( Types.Opt.Maybe (has_second_column, second_column)\n , Types.Opt.Just runtime ) ->\n let res =\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) second_column runtime\n in\n Array.map2_exn runtime sum ~f:(fun runtime sum ->\n Inner_curve.if_ has_second_column ~then_:sum\n ~else_:runtime )\n in\n Types.Opt.just res\n | ( Types.Opt.Just second_column\n , Types.Opt.Maybe (has_runtime, runtime) ) ->\n let res =\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) second_column runtime\n in\n Array.map2_exn second_column sum\n ~f:(fun second_column sum ->\n Inner_curve.if_ has_runtime ~then_:sum\n ~else_:second_column )\n in\n Types.Opt.just res\n | Types.Opt.Just second_column, Types.Opt.Just runtime ->\n Types.Opt.just\n (Array.map2_exn ~f:Inner_curve.( + ) second_column runtime)\n in\n let rest_rev =\n Vector.rev (first_column :: second_column_with_runtime :: rest)\n in\n Vector.fold ~init:m.lookup_table_ids rest_rev ~f:(fun acc comm ->\n match acc with\n | Types.Opt.Nothing ->\n comm\n | Types.Opt.Maybe (has_acc, acc) -> (\n match comm with\n | Types.Opt.Nothing ->\n Types.Opt.maybe has_acc acc\n | Types.Opt.Maybe (has_comm, comm) ->\n let scaled_acc =\n Array.map acc ~f:(fun acc ->\n Scalar_challenge.endo acc joint_combiner )\n in\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) scaled_acc comm\n in\n let acc_with_comm =\n Array.map2_exn sum comm ~f:(fun sum comm ->\n Inner_curve.if_ has_acc ~then_:sum ~else_:comm )\n in\n let res =\n Array.map2_exn acc acc_with_comm\n ~f:(fun acc acc_with_comm ->\n Inner_curve.if_ has_comm ~then_:acc_with_comm\n ~else_:acc )\n in\n let b = Boolean.(has_acc ||| has_comm) in\n Types.Opt.maybe b res\n | Types.Opt.Just comm ->\n let scaled_acc =\n Array.map acc ~f:(fun acc ->\n Scalar_challenge.endo acc joint_combiner )\n in\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) scaled_acc comm\n in\n let res =\n Array.map2_exn sum comm ~f:(fun sum comm ->\n Inner_curve.if_ has_acc ~then_:sum ~else_:comm )\n in\n Types.Opt.just res )\n | Types.Opt.Just acc -> (\n match comm with\n | Types.Opt.Nothing ->\n Types.Opt.just acc\n | Types.Opt.Maybe (has_comm, comm) ->\n let scaled_acc =\n Array.map acc ~f:(fun acc ->\n Scalar_challenge.endo acc joint_combiner )\n in\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) scaled_acc comm\n in\n let res =\n Array.map2_exn sum acc ~f:(fun sum acc ->\n Inner_curve.if_ has_comm ~then_:sum ~else_:acc )\n in\n Types.Opt.just res\n | Types.Opt.Just comm ->\n let scaled_acc =\n Array.map acc ~f:(fun acc ->\n Scalar_challenge.endo acc joint_combiner )\n in\n Types.Opt.Just\n (Array.map2_exn ~f:Inner_curve.( + ) scaled_acc comm)\n ) )\n in\n match (messages.lookup, joint_combiner) with\n | Types.Opt.Nothing, Types.Opt.Nothing ->\n Types.Opt.Nothing\n | ( Types.Opt.Maybe (b_l, l)\n , Types.Opt.Maybe (_b_joint_combiner, joint_combiner) ) -> (\n (* NB: b_l = _b_joint_combiner by construction *)\n match compute_lookup_table_comm l joint_combiner with\n | Types.Opt.Nothing ->\n Types.Opt.Nothing\n | Types.Opt.Maybe (b_lookup_table_comm, lookup_table_comm) ->\n Types.Opt.Maybe\n (Boolean.(b_l &&& b_lookup_table_comm), lookup_table_comm)\n | Types.Opt.Just lookup_table_comm ->\n Types.Opt.Maybe (b_l, lookup_table_comm) )\n | Types.Opt.Just l, Types.Opt.Just joint_combiner ->\n compute_lookup_table_comm l joint_combiner\n | ( (Types.Opt.Nothing | Maybe _ | Just _)\n , (Types.Opt.Nothing | Maybe _ | Just _) ) ->\n assert false\n in\n let lookup_sorted =\n let lookup_sorted_minus_1 =\n Nat.to_int Plonk_types.Lookup_sorted_minus_1.n\n in\n Vector.init Plonk_types.Lookup_sorted.n ~f:(fun i ->\n match messages.lookup with\n | Types.Opt.Nothing ->\n Types.Opt.Nothing\n | Types.Opt.Maybe (b, l) ->\n if i = lookup_sorted_minus_1 then l.sorted_5th_column\n else\n Types.Opt.Maybe (b, Option.value_exn (Vector.nth l.sorted i))\n | Types.Opt.Just l ->\n if i = lookup_sorted_minus_1 then l.sorted_5th_column\n else Types.Opt.Just (Option.value_exn (Vector.nth l.sorted i)) )\n in\n let beta = sample () in\n let gamma = sample () in\n let () =\n match messages.lookup with\n | Nothing ->\n ()\n | Maybe (b, l) ->\n let aggreg = Array.map l.aggreg ~f:(fun z -> (b, z)) in\n absorb sponge Without_degree_bound aggreg\n | Just l ->\n let aggreg =\n Array.map l.aggreg ~f:(fun z -> (Boolean.true_, z))\n in\n absorb sponge Without_degree_bound aggreg\n 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 ~verification_key:\n (Plonk_verification_key_evals.Step.forget_optional_commitments\n m )\n ~plonk ~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 len_1, len_1_add = Plonk_types.(Columns.add Permuts_minus_1.n) in\n let len_2, len_2_add = Plonk_types.(Columns.add len_1) in\n let _len_3, len_3_add = Nat.N9.add len_2 in\n let _len_4, len_4_add = Nat.N6.add Plonk_types.Lookup_sorted.n in\n let len_5, len_5_add =\n (* NB: Using explicit 11 because we can't get add on len_4 *)\n Nat.N11.add Nat.N8.n\n in\n let len_6, len_6_add = Nat.N45.add len_5 in\n let num_commitments_without_degree_bound = len_6 in\n let without_degree_bound =\n let append_chain len second first =\n Vector.append first second len\n in\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.map sg_old ~f:(fun (keep, p) ->\n Pickles_types.Opt.Maybe (keep, [| p |]) )\n |> append_chain\n (snd (Max_proofs_verified.add len_6))\n ( [ x_hat\n ; [| ft_comm |]\n ; z_comm\n ; m.generic_comm\n ; m.psm_comm\n ; m.complete_add_comm\n ; m.mul_comm\n ; m.emul_comm\n ; m.endomul_scalar_comm\n ]\n |> append_chain len_3_add\n (Vector.append w_comm\n (Vector.append m.coefficients_comm sigma_comm_init\n len_1_add )\n len_2_add )\n |> Vector.map ~f:Pickles_types.Opt.just\n |> append_chain len_6_add\n ( [ m.range_check0_comm\n ; m.range_check1_comm\n ; m.foreign_field_add_comm\n ; m.foreign_field_mul_comm\n ; m.xor_comm\n ; m.rot_comm\n ]\n |> append_chain len_4_add lookup_sorted\n |> append_chain len_5_add\n [ Pickles_types.Opt.map messages.lookup ~f:(fun l ->\n l.aggreg )\n ; lookup_table_comm\n ; runtime_comm\n ; m.runtime_tables_selector\n ; m.lookup_selector_xor\n ; m.lookup_selector_lookup\n ; m.lookup_selector_range_check\n ; m.lookup_selector_ffmul\n ] ) )\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:\n (Pickles_types.Opt.map\n ~f:(Array.map ~f:(fun x -> `Finite x)) )\n , [] )\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 = plonk.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 (* computes pt^{2^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 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 Array.iter ~f:(Sponge.absorb sponge) (fst evals.public_input) ;\n Array.iter ~f:(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 | Nothing ->\n ()\n | Just (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 ~zk_rows:3\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 | Nothing ->\n [||]\n | Just a ->\n Array.map a ~f:Pickles_types.Opt.just\n | Maybe (b, a) ->\n Array.map a ~f:(Pickles_types.Opt.maybe b) )\n in\n let sg_evals =\n Vector.map sg_evals ~f:(fun x -> [| Pickles_types.Opt.just 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\n ( Array.map ~f:Pickles_types.Opt.just x_hat\n :: [| Pickles_types.Opt.just ft |]\n :: 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:Pickles_types.Opt.nothing ~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","open Core_kernel\n\n[@@@warning \"-4\"]\n\ntype ('a, 'bool) t = Just of 'a | Nothing | Maybe of 'bool * 'a\n[@@deriving sexp, compare, yojson, hash, equal]\n\nlet just a = Just a\n\nlet nothing = Nothing\n\nlet maybe b x = Maybe (b, x)\n\nlet to_option : ('a, bool) t -> 'a option = function\n | Just x ->\n Some x\n | Maybe (true, x) ->\n Some x\n | Maybe (false, _x) ->\n None\n | Nothing ->\n None\n\nlet to_option_unsafe : ('a, 'bool) t -> 'a option = function\n | Just x ->\n Some x\n | Maybe (_, x) ->\n Some x\n | Nothing ->\n None\n\nlet value_exn = function\n | Just x ->\n x\n | Maybe (_, x) ->\n x\n | Nothing ->\n invalid_arg \"Opt.value_exn\"\n\nlet of_option (t : 'a option) : ('a, 'bool) t =\n match t with None -> Nothing | Some x -> Just x\n\nlet lift ?on_maybe ~nothing f = function\n | Nothing ->\n nothing\n | Just v ->\n f v\n | Maybe (b, v) -> (\n match on_maybe with None -> f v | Some g -> g b v )\n\nmodule 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\nend\n\nlet map t ~f =\n match t with\n | Nothing ->\n Nothing\n | Just x ->\n Just (f x)\n | Maybe (b, x) ->\n Maybe (b, f x)\n\nlet iter t ~f =\n match t with Nothing -> () | Just x -> f x | Maybe (_, x) -> f x\n\nopen Snarky_backendless\n\nlet 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 | Just x ->\n x\n | Maybe _ | Nothing ->\n failwith \"Opt.some_typ: expected Just\" )\n ~back:(fun x -> Just x)\n\nlet 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 | Nothing ->\n ()\n | Maybe _ | Just _ ->\n failwith \"Opt.none_typ: expected Nothing\" )\n ~back:(fun () : _ t -> Nothing)\n\nlet 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 | Nothing | Just _ ->\n failwith \"Opt.maybe_typ: expected Maybe\" )\n ~back:(fun (b, x) -> Maybe (b, x))\n\nlet 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 | Nothing ->\n (false_, dummy_var)\n | Just x ->\n (true_, x) )\n ~back:(fun (b, x) ->\n match flag with No -> Nothing | Yes -> Just x | Maybe -> Maybe (b, x)\n )\n\nlet typ (type a a_var f) bool_typ (flag : Flag.t) (a_typ : (a_var, a, f) Typ.t)\n ~(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\nmodule 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 | Nothing :: xs ->\n go acc xs\n | Just 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\nend\n","(* q > p *)\nopen Core_kernel\nmodule SC = Scalar_challenge\nopen Import\nopen Common\nopen Util\nopen Types.Step\nopen Pickles_types\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 ~reduce_without_degree_bound:Array.to_list\n ~reduce_with_degree_bound:(fun { Plonk_types.Poly_comm\n .With_degree_bound\n .unshifted\n ; shifted\n } ->\n Array.to_list unshifted @ [ shifted ] )\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 ->\n Some (`Finite x)\n | `Maybe_finite x ->\n Some (`Maybe_finite x) )\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 ~verification_key:m ~plonk ~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 :: m.mul_comm :: m.emul_comm\n :: m.endomul_scalar_comm\n :: Vector.append w_comm\n (Vector.append m.coefficients_comm sigma_comm_init\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 = None 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 (* 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 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 ~(step_domains :\n [ `Known of (Domains.t, branches) Vector.t | `Side_loaded ] ) ~zk_rows\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 Plonk_types.Evals.In_circuit.validate_feature_flags ~true_:Boolean.true_\n ~false_:Boolean.false_ ~or_:Boolean.( ||| )\n ~assert_equal:Boolean.Assert.( = ) ~feature_flags:plonk.feature_flags\n evals.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 Array.iter\n ~f:(fun x -> Sponge.absorb sponge (`Field x))\n (fst evals.public_input) ;\n Array.iter\n ~f:(fun x -> Sponge.absorb sponge (`Field x))\n (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 | Nothing ->\n ()\n | Just (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 ~zk_rows\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) -> [| Opt.Maybe (keep, eval) |])\n in\n let a =\n Evals.In_circuit.to_list e\n |> List.map ~f:(function\n | Nothing ->\n [||]\n | Just a ->\n Array.map a ~f:Opt.just\n | Maybe (b, a) ->\n Array.map a ~f:(Opt.maybe b) )\n in\n let v =\n List.append sg_evals\n (Array.map ~f:Opt.just x_hat :: [| Opt.just 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:\n (Array.concat_map ~f:(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 : Impls.Step.unfinalized_proof_var) =\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 ~option_map:Opt.map\n statement ) )\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.nothing ~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\nmodule For_tests_only = struct\n let side_loaded_domain = side_loaded_domain\nend\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 ; xor_comm : 'polyComm option\n ; range_check0_comm : 'polyComm option\n ; range_check1_comm : 'polyComm option\n ; foreign_field_add_comm : 'polyComm option\n ; foreign_field_mul_comm : 'polyComm option\n ; rot_comm : 'polyComm option\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 ; zk_rows : int\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))\n\n let of_yojson fp fq =\n verifier_index_of_yojson fp\n (fun _ -> Ok (Backend.Tock.Keypair.load_urs ()))\n (polycomm_of_yojson (or_infinity_of_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 [@of_yojson\n Verifier_index_json.of_yojson Backend.Tock.Field.of_yojson\n Backend.Tick.Field.of_yojson] )\n ; data : Data.t\n }\n [@@deriving fields, to_yojson, of_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)) =\n Impls.Wrap.input ~feature_flags:Plonk_types.Features.Full.maybe ()\n 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 ; xor_comm = None\n ; range_check0_comm = None\n ; range_check1_comm = None\n ; foreign_field_add_comm = None\n ; foreign_field_mul_comm = None\n ; rot_comm = None\n } )\n ; shifts = Common.tock_shifts ~log2_size\n ; lookup_index = None\n ; zk_rows = 3\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 of_yojson = Stable.Latest.of_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_step_commitments g =\n let open Plonk_types in\n { Plonk_verification_key_evals.Step.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 ; xor_comm = None\n ; range_check0_comm = None\n ; range_check1_comm = None\n ; foreign_field_add_comm = None\n ; foreign_field_mul_comm = None\n ; rot_comm = None\n ; lookup_table_comm = Vector.init Lookup_sorted_minus_1.n ~f:(fun _ -> None)\n ; lookup_table_ids = None\n ; runtime_tables_selector = None\n ; lookup_selector_lookup = None\n ; lookup_selector_xor = None\n ; lookup_selector_range_check = None\n ; lookup_selector_ffmul = None\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\n\n[@@@warning \"-4-27\"]\n\nmodule Yojson_map = Map.Make (struct\n type t =\n [ `Null\n | `Bool of bool\n | `Int of int\n | `Intlit of string\n | `Float of float\n | `String of string\n | `Assoc of (string * t) list\n | `List of t list\n | `Tuple of t list\n | `Variant of string * t option ]\n [@@deriving compare, sexp]\nend)\n\n[@@@warning \"+4+27\"]\n\ntype t = Yojson.Safe.t Yojson_map.t Yojson_map.t ref\n\n(* We use a slightly more verbose format here, so that it's easy to debug.\n There are some overheads to handling this, but the amount of computation we\n save by caching the proofs is orders of magnitude higher, so it's not really\n an issue.\n*)\nlet to_yojson t =\n `List\n (Map.fold ~init:[] !t ~f:(fun ~key ~data xs ->\n let proofs =\n Map.fold ~init:[] data ~f:(fun ~key ~data xs ->\n `Assoc [ (\"public_input\", key); (\"proof\", data) ] :: xs )\n in\n `Assoc [ (\"verification_key\", key); (\"proofs\", `List proofs) ] :: xs )\n )\n\n(* This mirrors the format of [to_yojson], carefully ensuring that we can\n decode what we encode, and reporting an error when the format differs from\n what we expect.\n\n Note that, since this is a cache, it should always be possible to regenerate\n proofs for the cache by starting with the empty cache and calling\n [to_yojson] on the result.\n*)\nlet of_yojson t =\n Result.try_with (fun () ->\n match t with\n | `List xs ->\n let for_vks =\n List.map xs ~f:(function\n | `Assoc [ (\"verification_key\", key); (\"proofs\", `List proofs) ]\n ->\n let proofs =\n List.map proofs ~f:(function\n | `Assoc [ (\"public_input\", key); (\"proof\", data) ] ->\n (key, data)\n | _ ->\n failwith\n \"Expected fields `public_input`, `proof` as a \\\n record in that order; received something \\\n different\" )\n in\n (key, Yojson_map.of_alist_exn proofs)\n | _ ->\n failwith\n \"Expected fields `verification_key`, `proofs` as a record \\\n in that order, where `proofs` is a list; received \\\n something different\" )\n in\n ref (Yojson_map.of_alist_exn for_vks)\n | _ ->\n failwith \"Expected a list, got something different\" )\n |> Result.map_error ~f:Exn.to_string\n\n(* Alias types with a [deriving to_yojson] annotation, so that we don't have to\n spell out the serialization explicitly.\n*)\nmodule Json = struct\n type 'f or_infinity = 'f Kimchi_types.or_infinity =\n | Infinity\n | Finite of ('f * 'f)\n [@@deriving to_yojson]\n\n type 'caml_g poly_comm = 'caml_g Kimchi_types.poly_comm =\n { unshifted : 'caml_g array; shifted : 'caml_g option }\n [@@deriving to_yojson]\n\n type lookup_patterns = Kimchi_types.lookup_patterns =\n { xor : bool; lookup : bool; range_check : bool; foreign_field_mul : bool }\n [@@deriving to_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 to_yojson]\n\n type lookups_used = Kimchi_types.VerifierIndex.Lookup.lookups_used =\n | Single\n | Joint\n [@@deriving to_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 to_yojson]\n\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 to_yojson]\n\n type 'poly_comm lookup = 'poly_comm Kimchi_types.VerifierIndex.Lookup.t =\n { joint_lookup_used : bool\n ; lookup_table : 'poly_comm array\n ; lookup_selectors : 'poly_comm lookup_selectors\n ; table_ids : 'poly_comm option\n ; lookup_info : lookup_info\n ; runtime_tables_selector : 'poly_comm option\n }\n [@@deriving to_yojson]\n\n type 'fr domain = 'fr Kimchi_types.VerifierIndex.domain =\n { log_size_of_group : int; group_gen : 'fr }\n [@@deriving to_yojson]\n\n type 'poly_comm verification_evals =\n 'poly_comm Kimchi_types.VerifierIndex.verification_evals =\n { sigma_comm : 'poly_comm array\n ; coefficients_comm : 'poly_comm array\n ; generic_comm : 'poly_comm\n ; psm_comm : 'poly_comm\n ; complete_add_comm : 'poly_comm\n ; mul_comm : 'poly_comm\n ; emul_comm : 'poly_comm\n ; endomul_scalar_comm : 'poly_comm\n ; xor_comm : 'poly_comm option [@default None]\n ; range_check0_comm : 'poly_comm option [@default None]\n ; range_check1_comm : 'poly_comm option [@default None]\n ; foreign_field_add_comm : 'poly_comm option [@default None]\n ; foreign_field_mul_comm : 'poly_comm option [@default None]\n ; rot_comm : 'poly_comm option [@default None]\n }\n [@@deriving to_yojson]\n\n type ('fr, 'srs, 'poly_comm) verifier_index =\n ('fr, 'srs, 'poly_comm) 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 : 'poly_comm verification_evals\n ; shifts : 'fr array\n ; lookup_index : 'poly_comm lookup option\n ; zk_rows : int [@default 3]\n }\n [@@deriving to_yojson]\n\n let srs_to_yojson _ = `Null\n\n let step_verification_key_to_yojson =\n [%to_yojson:\n ( Backend.Tick.Field.t\n , srs\n , Backend.Tock.Field.t or_infinity poly_comm )\n verifier_index]\n\n let wrap_verification_key_to_yojson =\n [%to_yojson:\n ( Backend.Tock.Field.t\n , srs\n , Backend.Tick.Field.t or_infinity poly_comm )\n verifier_index]\nend\n\nlet empty () = ref Yojson_map.empty\n\nlet get_proof t ~verification_key ~public_input =\n let open Option.Let_syntax in\n let%bind for_vk = Map.find !t verification_key in\n Map.find for_vk public_input\n\nlet get_step_proof t ~keypair ~public_input =\n let open Option.Let_syntax in\n let public_input =\n let len = Kimchi_bindings.FieldVectors.Fp.length public_input in\n Array.init len ~f:(fun i ->\n Kimchi_bindings.FieldVectors.Fp.get public_input i )\n |> [%to_yojson: Backend.Tick.Field.t array]\n in\n let verification_key =\n Backend.Tick.Keypair.vk keypair |> Json.step_verification_key_to_yojson\n in\n let%bind proof_json = get_proof t ~verification_key ~public_input in\n Option.try_with (fun () ->\n Result.ok_or_failwith @@ Backend.Tick.Proof.of_yojson proof_json )\n\nlet get_wrap_proof t ~keypair ~public_input =\n let open Option.Let_syntax in\n let public_input =\n let len = Kimchi_bindings.FieldVectors.Fq.length public_input in\n Array.init len ~f:(fun i ->\n Kimchi_bindings.FieldVectors.Fq.get public_input i )\n |> [%to_yojson: Backend.Tock.Field.t array]\n in\n let verification_key =\n Backend.Tock.Keypair.vk keypair |> Json.wrap_verification_key_to_yojson\n in\n let%bind proof_json = get_proof t ~verification_key ~public_input in\n Option.try_with (fun () ->\n Result.ok_or_failwith @@ Backend.Tock.Proof.of_yojson proof_json )\n\nlet set_proof t ~verification_key ~public_input proof =\n t :=\n Map.update !t verification_key ~f:(function\n | None ->\n Yojson_map.singleton public_input proof\n | Some for_vk ->\n Map.set for_vk ~key:public_input ~data:proof )\n\nlet set_step_proof t ~keypair ~public_input proof =\n let public_input =\n let len = Kimchi_bindings.FieldVectors.Fp.length public_input in\n Array.init len ~f:(fun i ->\n Kimchi_bindings.FieldVectors.Fp.get public_input i )\n |> [%to_yojson: Backend.Tick.Field.t array]\n in\n let verification_key =\n Backend.Tick.Keypair.vk keypair |> Json.step_verification_key_to_yojson\n in\n let proof_json = Backend.Tick.Proof.to_yojson proof in\n set_proof t ~verification_key ~public_input proof_json\n\nlet set_wrap_proof t ~keypair ~public_input proof =\n let public_input =\n let len = Kimchi_bindings.FieldVectors.Fq.length public_input in\n Array.init len ~f:(fun i ->\n Kimchi_bindings.FieldVectors.Fq.get public_input i )\n |> [%to_yojson: Backend.Tock.Field.t array]\n in\n let verification_key =\n Backend.Tock.Keypair.vk keypair |> Json.wrap_verification_key_to_yojson\n in\n let proof_json = Backend.Tock.Proof.to_yojson proof in\n set_proof t ~verification_key ~public_input proof_json\n\nlet is_env_var_set_requesting_error_for_proofs () =\n match Sys.getenv_opt \"ERROR_ON_PROOF\" with\n | Some (\"true\" | \"t\" (* insert whatever value is okay here *)) ->\n true\n | None | Some _ ->\n false\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 type storable =\n (Key.Proving.t, Backend.Tick.Keypair.t) Key_cache.Sync.Disk_storable.t\n\n type vk_storable =\n ( Key.Verification.t\n , Kimchi_bindings.Protocol.VerifierIndex.Fp.t )\n Key_cache.Sync.Disk_storable.t\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 ?(s_p = storable) k_p\n ?(s_v = vk_storable) k_v =\n let open Impls.Step in\n let pk =\n lazy\n (let%map.Promise k_p = Lazy.force k_p in\n match\n Common.time \"step keypair read\" (fun () ->\n Key_cache.Sync.read cache s_p k_p )\n with\n | Ok (pk, dirty) ->\n Common.time \"step keypair create\" (fun () -> (pk, dirty))\n | Error _e ->\n let _, _, _, sys = k_p in\n let r =\n Common.time \"stepkeygen\" (fun () ->\n Keypair.generate ~prev_challenges sys )\n in\n Timer.clock __LOC__ ;\n ignore\n ( Key_cache.Sync.write cache s_p k_p (Keypair.pk r)\n : unit Or_error.t ) ;\n (Keypair.pk r, `Generated_something) )\n in\n let vk =\n lazy\n (let%bind.Promise 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 Promise.return (vk, `Cache_hit)\n | Error _e ->\n let%map.Promise pk, c = Lazy.force pk in\n let vk = Backend.Tick.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 type storable =\n (Key.Proving.t, Backend.Tock.Keypair.t) Key_cache.Sync.Disk_storable.t\n\n type vk_storable =\n (Key.Verification.t, Verification_key.t) Key_cache.Sync.Disk_storable.t\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 vk_storable =\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 Verification_key.Stable.Latest)\n (In_channel.read_all 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, _) 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\n (module Verification_key.Stable.Latest)\n t ) ) )\n header path ) )\n\n let read_or_generate ~prev_challenges cache ?(s_p = storable) k_p\n ?(s_v = vk_storable) k_v =\n let module Vk = Verification_key in\n let open Impls.Wrap in\n let pk =\n lazy\n (let%map.Promise 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 (pk, d)\n | Error _e ->\n let _, _, sys = k in\n let r =\n Common.time \"wrapkeygen\" (fun () ->\n Keypair.generate ~prev_challenges sys )\n in\n ignore\n ( Key_cache.Sync.write cache s_p k (Keypair.pk r)\n : unit Or_error.t ) ;\n (Keypair.pk r, `Generated_something) )\n in\n let vk =\n lazy\n (let%bind.Promise k_v = Lazy.force k_v in\n match Key_cache.Sync.read cache s_v k_v with\n | Ok (vk, d) ->\n Promise.return (vk, d)\n | Error _e ->\n let%map.Promise pk, _dirty = Lazy.force pk in\n let vk = Backend.Tock.Keypair.vk pk 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 to_yojson = Kimchi_pasta_basic.Fp.to_yojson\n\n let of_yojson = Kimchi_pasta_basic.Fp.of_yojson\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 Kimchi_pasta_basic.poseidon_params_fp\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","open Core_kernel\nopen Pickles.Impls.Step.Internal_Basic\n\nmodule State = struct\n include Array\n\n let map2 = map2_exn\n\n let to_array t = t\n\n let of_array t = t\nend\n\nmodule Input = Random_oracle_input\n\nlet params : Field.t Sponge.Params.t = Kimchi_pasta_basic.poseidon_params_fp\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\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\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\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\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:Kimchi_pasta_basic.Fp.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 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\nend\n","[%%import \"/src/config.mlh\"]\n\n(** This file consists of compile-time constants that are not in\n Genesis_constants.\n This file includes all of the constants defined at compile-time for both\n tests and production.\n*)\n\ninclude Node_config_version\ninclude Node_config_unconfigurable_constants\n\n[%%inject \"ledger_depth\", ledger_depth]\n\n[%%inject \"curve_size\", curve_size]\n\n[%%inject \"coinbase\", coinbase]\n\n[%%inject \"k\", k]\n\n[%%inject \"delta\", delta]\n\n[%%inject \"slots_per_epoch\", slots_per_epoch]\n\n[%%inject \"slots_per_sub_window\", slots_per_sub_window]\n\n[%%inject \"sub_windows_per_window\", sub_windows_per_window]\n\n[%%inject \"grace_period_slots\", grace_period_slots]\n\n[%%inject \"scan_state_with_tps_goal\", scan_state_with_tps_goal]\n\n[%%ifndef scan_state_transaction_capacity_log_2]\n\nlet scan_state_transaction_capacity_log_2 : int option = None\n\n[%%else]\n\n[%%inject\n\"scan_state_transaction_capacity_log_2\", scan_state_transaction_capacity_log_2]\n\nlet scan_state_transaction_capacity_log_2 =\n Some scan_state_transaction_capacity_log_2\n\n[%%endif]\n\n[%%inject \"scan_state_work_delay\", scan_state_work_delay]\n\n[%%inject \"proof_level\", proof_level]\n\n[%%inject \"pool_max_size\", pool_max_size]\n\n[%%inject \"account_creation_fee_int\", account_creation_fee_int]\n\n[%%inject \"default_transaction_fee\", default_transaction_fee]\n\n[%%inject \"default_snark_worker_fee\", default_snark_worker_fee]\n\n[%%inject \"minimum_user_command_fee\", minimum_user_command_fee]\n\n[%%inject \"supercharged_coinbase_factor\", supercharged_coinbase_factor]\n\n[%%inject \"plugins\", plugins]\n\n[%%inject \"genesis_state_timestamp\", genesis_state_timestamp]\n\n[%%inject \"block_window_duration\", block_window_duration]\n\n[%%inject \"itn_features\", itn_features]\n\n[%%ifndef compaction_interval]\n\nlet compaction_interval = None\n\n[%%else]\n\n[%%inject \"compaction_interval\", compaction_interval]\n\nlet compaction_interval = Some compaction_interval\n\n[%%endif]\n\n[%%inject \"network\", network]\n\n[%%inject \"vrf_poll_interval\", vrf_poll_interval]\n\n[%%ifndef zkapp_cmd_limit]\n\nlet zkapp_cmd_limit = None\n\n[%%else]\n\n[%%inject \"zkapp_cmd_limit\", zkapp_cmd_limit]\n\nlet zkapp_cmd_limit = Some zkapp_cmd_limit\n\n[%%endif]\n\n[%%ifndef scan_state_tps_goal_x10]\n\nlet scan_state_tps_goal_x10 : int option = None\n\n[%%else]\n\n[%%inject \"scan_state_tps_goal_x10\", scan_state_tps_goal_x10]\n\nlet scan_state_tps_goal_x10 = Some scan_state_tps_goal_x10\n\n[%%endif]\n","open Core_kernel\nopen Snark_params.Tick\n\nlet parity y = Bigint.(test_bit (of_field y) 0)\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 (* 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 *)\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 (* 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 *)\nend\n\ninclude Uncompressed\n","open 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 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 end\nend]\n\n[%%define_locally Stable.Latest.(gen)]\n\nlet create () =\n (* This calls into libsnark which uses /dev/urandom *)\n Inner_curve.Scalar.random ()\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","module 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 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\nend\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 if Random.int 1000 = 0 then (\n print_endline \"SCHNORR BACKTRACE:\" ;\n Printexc.print_backtrace stdout ) ;\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 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\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 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 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 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 end\nend\n\nmodule Legacy = Make (Tick) (Tick.Inner_curve) (Message.Legacy)\nmodule Chunked = Make (Tick) (Tick.Inner_curve) (Message.Chunked)\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","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","open 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\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","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 (** Same as [add_path], but using the hashes provided in the wide merkle path\n instead of recomputing them.\n This is unsafe: the hashes are not checked or recomputed.\n *)\n val add_wide_path_unsafe :\n t\n -> [ `Left of hash * hash | `Right of hash * hash ] list\n -> account_id\n -> account\n -> 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_impl ~replace_self tree0 path0 account =\n (* Takes height, left and right children and builds a pair of sibling nodes\n one level up *)\n let build_tail_f height (prev_l, prev_r) =\n replace_self ~f:(fun mself ->\n let self =\n match mself with\n | Some self ->\n self\n | None ->\n Hash.merge ~height (hash prev_l) (hash prev_r)\n in\n Tree.Node (self, prev_l, prev_r) )\n in\n (* Builds the tail of path, i.e. part of the path that is not present in\n the current ledger and we just add it all the way down to account\n using the path *)\n let build_tail hash_node_to_bottom_path =\n let bottom_el, bottom_to_hash_node_path =\n Mina_stdlib.Nonempty_list.(rev hash_node_to_bottom_path |> uncons)\n in\n (* Left and right branches of a node that is parent of the bottom node *)\n let init = replace_self ~f:(Fn.const (Tree.Account account)) bottom_el in\n List.foldi ~init bottom_to_hash_node_path ~f:build_tail_f\n in\n (* Traverses the tree along path, collecting nodes and untraversed sibling hashes\n Stops when encounters `Hash` or `Account` node.\n\n Returns the last visited node (`Hash` or `Account`), remainder of path and\n collected node/sibling hashes in bottom-to-top order.\n *)\n let rec traverse_through_nodes = function\n | Tree.Account _, _ :: _ ->\n failwith \"path is longer than a tree's branch\"\n | Account _, [] | Tree.Hash _, [] ->\n Tree.Account account\n | Tree.Hash h, fst_el :: rest ->\n let tail_l, tail_r =\n build_tail (Mina_stdlib.Nonempty_list.init fst_el rest)\n in\n Tree.Node (h, tail_l, tail_r)\n | Node (h, l, r), `Left _ :: rest ->\n Tree.Node (h, traverse_through_nodes (l, rest), r)\n | Node (h, l, r), `Right _ :: rest ->\n Tree.Node (h, l, traverse_through_nodes (r, rest))\n | Node _, [] ->\n failwith \"path is shorter than a tree's branch\"\n in\n traverse_through_nodes (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 let replace_self ~f = function\n | `Left h_r ->\n (f None, Tree.Hash h_r)\n | `Right h_l ->\n (Tree.Hash h_l, f None)\n in\n { t with\n tree = add_path_impl ~replace_self t.tree path account\n ; indexes = (account_id, index) :: t.indexes\n }\n\n let add_wide_path_unsafe (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 let replace_self ~f = function\n | `Left (h_l, h_r) ->\n (f (Some h_l), Tree.Hash h_r)\n | `Right (h_l, h_r) ->\n (Tree.Hash h_l, f (Some h_r))\n in\n { t with\n tree = add_path_impl ~replace_self 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}, tree_depth = %d\"\n idx expected_kind kind (depth - i) t depth ()\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 =\n { name : Bounded_types.String.Stable.V1.t; 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 *)\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","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","open Core_kernel\nopen Snark_bits\nopen Snark_params\nopen Tick\nopen Bitstring_lib\nopen Let_syntax\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 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 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 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 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 [%%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 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 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 create_preserve_zero_sign ~magnitude ~sgn = { magnitude; sgn }\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 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 end\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 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]\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 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 end\n end]\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 include Arithmetic_intf with type t := t\n\n include Codable.S with type t := t\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 (* 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 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 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 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 [%%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]\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 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 end\n\n include Make_str (struct\n type t = Unsigned_extended.UInt64.Stable.Latest.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 end\n end]\n\n include (Amount : Basic with type t := t with type var = Amount.var)\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 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 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 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 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","(** This file consists of compile-time constants that are not in Genesis_constants.\n This file includes all of the constants defined at compile-time for both\n tests and production.\n*)\n\ninclude Node_config_version\ninclude Node_config_unconfigurable_constants\n\nlet (ledger_depth : int) = (10 : int)\n\nlet (curve_size : int) = (255 : int)\n\nlet (coinbase : string) = (\"20\" : string)\n\nlet (k : int) = (24 : int)\n\nlet (delta : int) = (0 : int)\n\nlet (slots_per_epoch : int) = (576 : int)\n\nlet (slots_per_sub_window : int) = (2 : int)\n\nlet (sub_windows_per_window : int) = (3 : int)\n\nlet (grace_period_slots : int) = (180 : int)\n\nlet (scan_state_with_tps_goal : bool) = (false : bool)\n\nlet (scan_state_transaction_capacity_log_2 : int) = (3 : int)\n\nlet scan_state_transaction_capacity_log_2 =\n Some scan_state_transaction_capacity_log_2\n\nlet (scan_state_work_delay : int) = (2 : int)\n\nlet (proof_level : string) = (\"check\" : string)\n\nlet (pool_max_size : int) = (3000 : int)\n\nlet (account_creation_fee_int : string) = (\"0.001\" : string)\n\nlet (default_transaction_fee : string) = (\"5\" : string)\n\nlet (default_snark_worker_fee : string) = (\"1\" : string)\n\nlet (minimum_user_command_fee : string) = (\"2\" : string)\n\nlet (supercharged_coinbase_factor : int) = (1 : int)\n\nlet (plugins : bool) = (true : bool)\n\nlet (genesis_state_timestamp : string) = (\"2019-01-30 12:00:00-08:00\" : string)\n\nlet (block_window_duration : int) = (2000 : int)\n\nlet (itn_features : bool) = (true : bool)\n\nlet compaction_interval = None\n\nlet (network : string) = (\"testnet\" : string)\n\nlet (vrf_poll_interval : int) = (0 : int)\n\nlet zkapp_cmd_limit = None\n\nlet scan_state_tps_goal_x10 : int option = None\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","open 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 let balance_change obj' =\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 in\n needs_custom_js\n ~js_type:(js_leaf (Custom \"BalanceChange\"))\n ~name:\"BalanceChange\" balance_change obj\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\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\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 *)\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\nlet zero = dummy\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","open 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 ()\nend\n\nmodule Fork_constants = struct\n type t =\n { state_hash : Pickles.Backend.Tick.Field.Stable.Latest.t\n ; blockchain_length : Mina_numbers.Length.Stable.Latest.t\n ; global_slot_since_genesis :\n Mina_numbers.Global_slot_since_genesis.Stable.Latest.t\n }\n [@@deriving bin_io_unversioned, sexp, equal, compare, yojson]\nend\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 { blockchain_length; state_hash; global_slot_since_genesis } ->\n Some\n { blockchain_length = Unsigned.UInt32.to_int blockchain_length\n ; state_hash = Pickles.Backend.Tick.Field.to_string state_hash\n ; global_slot_since_genesis =\n Unsigned.UInt32.to_int\n (Mina_numbers.Global_slot_since_genesis.to_uint32\n global_slot_since_genesis )\n }\n | None ->\n None )\n }\nend\n\nmodule Helpers = struct\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\n let 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\n let of_time t =\n Time.to_span_since_epoch t |> Time.Span.to_ms |> Int64.of_float\n\n let to_time t =\n t |> Int64.to_float |> Time.Span.of_ms |> Time.of_span_since_epoch\n\n let 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 \\\n UTC-08:00 timezone\"\n\n let 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))\nend\n\ninclude Helpers\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 ; grace_period_slots : '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 ; (\"grace_period_slots\", `Int t.grace_period_slots)\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 ; (\"grace_period_slots\", `Int grace_period_slots)\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 ; grace_period_slots\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 ; grace_period_slots = t.grace_period_slots\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 ; zkapp_cmd_limit_hardcap : int\n ; minimum_user_command_fee : Currency.Fee.Stable.Latest.t\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\nmodule type S = sig\n module Proof_level : sig\n include module type of Proof_level with type t = Proof_level.t\n\n val t : t\n end\n\n module Fork_constants = Fork_constants\n\n module Constraint_constants : sig\n include\n module type of Constraint_constants with type t = Constraint_constants.t\n\n val t : t\n end\n\n val genesis_timestamp_of_string : string -> Time.t\n\n val of_time : Time.t -> int64\n\n val to_time : int64 -> Time.t\n\n val validate_time : string option -> (int64, string) result\n\n val genesis_timestamp_to_string : int64 -> string\n\n module Protocol = Protocol\n\n include module type of T with type t = T.t\n\n val genesis_state_timestamp_string : string\n\n val k : int\n\n val slots_per_epoch : int\n\n val slots_per_sub_window : int\n\n val grace_period_slots : int\n\n val delta : int\n\n val pool_max_size : int\n\n val t : t\nend\n\nmodule Make (Node_config : Node_config_intf.S) : S = struct\n module Proof_level = struct\n include Proof_level\n\n let t = of_string Node_config.proof_level\n end\n\n module Fork_constants = Fork_constants\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 *)\n module Constraint_constants = struct\n include Constraint_constants\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 (** 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 let transaction_capacity_log_2 =\n match\n ( Node_config.scan_state_with_tps_goal\n , Node_config.scan_state_tps_goal_x10 )\n with\n | true, Some tps_goal_x10 ->\n let max_coinbases = 2 in\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 * Node_config.block_window_duration / (1000 * 10)\n in\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 1\n + Core_kernel.Int.ceil_log2\n (max_user_commands_per_block + max_coinbases)\n | _ -> (\n match Node_config.scan_state_transaction_capacity_log_2 with\n | Some a ->\n a\n | None ->\n failwith\n \"scan_state_transaction_capacity_log_2 must be set if \\\n scan_state_with_tps_goal is false\" )\n\n let supercharged_coinbase_factor =\n Node_config.supercharged_coinbase_factor\n\n let pending_coinbase_depth =\n Core_kernel.Int.ceil_log2\n ( (transaction_capacity_log_2 + 1)\n * (Node_config.scan_state_work_delay + 1)\n + 1 )\n\n let t =\n { sub_windows_per_window = Node_config.sub_windows_per_window\n ; ledger_depth = Node_config.ledger_depth\n ; work_delay = Node_config.scan_state_work_delay\n ; block_window_duration_ms = Node_config.block_window_duration\n ; transaction_capacity_log_2\n ; pending_coinbase_depth\n ; coinbase_amount =\n Currency.Amount.of_mina_string_exn Node_config.coinbase\n ; supercharged_coinbase_factor\n ; account_creation_fee =\n Currency.Fee.of_mina_string_exn\n Node_config.account_creation_fee_int\n ; fork = None\n }\n end :\n sig\n val t : t\n end )\n end\n\n include Helpers\n module Protocol = Protocol\n include T\n\n let genesis_state_timestamp_string = Node_config.genesis_state_timestamp\n\n let k = Node_config.k\n\n let slots_per_epoch = Node_config.slots_per_epoch\n\n let slots_per_sub_window = Node_config.slots_per_sub_window\n\n let grace_period_slots = Node_config.grace_period_slots\n\n let delta = Node_config.delta\n\n let pool_max_size = Node_config.pool_max_size\n\n let t : t =\n { protocol =\n { k\n ; slots_per_epoch\n ; slots_per_sub_window\n ; grace_period_slots\n ; delta\n ; genesis_state_timestamp =\n genesis_timestamp_of_string genesis_state_timestamp_string\n |> of_time\n }\n ; txpool_max_size = pool_max_size\n ; num_accounts = None\n ; zkapp_proof_update_cost = Node_config.zkapp_proof_update_cost\n ; zkapp_signed_single_update_cost =\n Node_config.zkapp_signed_single_update_cost\n ; zkapp_signed_pair_update_cost = Node_config.zkapp_signed_pair_update_cost\n ; zkapp_transaction_cost_limit = Node_config.zkapp_transaction_cost_limit\n ; max_event_elements = Node_config.max_event_elements\n ; max_action_elements = Node_config.max_action_elements\n ; zkapp_cmd_limit_hardcap = Node_config.zkapp_cmd_limit_hardcap\n ; minimum_user_command_fee =\n Currency.Fee.of_mina_string_exn Node_config.minimum_user_command_fee\n }\nend\n\nmodule For_unit_tests = Make (Node_config_for_unit_tests)\n\nmodule Compiled : sig\n val genesis_constants : t\n\n val constraint_constants : Constraint_constants.t\n\n val proof_level : Proof_level.t\nend = struct\n include Make (Node_config)\n\n let genesis_constants = t\n\n let constraint_constants = Constraint_constants.t\n\n let proof_level = Proof_level.t\nend\n","open 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 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 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 let now offset = of_time (Time.sub (Time.now ()) (offset ()))\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 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 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","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.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 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 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 [%%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 [%%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 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 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 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\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open 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.Latest.t\n , Global_slot_span.Stable.Latest.t\n , Balance.Stable.Latest.t\n , Amount.Stable.Latest.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 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\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","open 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\ntype var = Field.Var.t * Inner_curve.Scalar.var\n\n[%%define_locally\nStable.Latest.\n (of_base58_check_exn, of_base58_check, of_yojson, to_yojson, to_base58_check)]\n","open Core_kernel\n\n(* TODO: temporary hack *)\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\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\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","(* payment_payload.ml *)\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\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\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","open Core_kernel\nopen Mina_base_util\nopen Snark_params.Tick\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 let verification_key_perm_fallback_to_signature_with_older_version = function\n | Impossible | Proof ->\n Signature\n | t ->\n t\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 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 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 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\n let verification_key_perm_fallback_to_signature_with_older_version\n ({ signature_sufficient; _ } as t : t) =\n if_\n Pickles.Impls.Step.Boolean.(not signature_sufficient)\n ~then_:(constant Signature) ~else_:t\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 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, 'txn_version) t =\n ( 'controller\n , 'txn_version )\n 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 * 'txn_version\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 txn_version 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)\n ~set_verification_key:\n (f (fun (c, v) ->\n Random_oracle.Input.Chunked.append (controller c) (txn_version v) )\n )\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 =\n ( Auth_required.Stable.V2.t\n , Mina_numbers.Txn_version.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\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 = auth_required_gen in\n let txn_version =\n Mina_numbers.Txn_version.of_int @@ Protocol_version.(transaction current)\n 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 = (set_verification_key_auth, txn_version)\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\nmodule Checked = struct\n type t =\n ( Auth_required.Checked.t\n , Mina_numbers.Txn_version.Checked.t )\n Poly.Stable.Latest.t\n\n let to_input (x : t) =\n Poly.to_input Auth_required.Checked.to_input\n Mina_numbers.Txn_version.Checked.to_input x\n\n let if_ b ~(then_ : t) ~(else_ : t) : t Snark_params.Tick.Checked.t =\n let open Snark_params.Tick in\n let edit_state =\n Auth_required.Checked.if_ b ~then_:then_.edit_state\n ~else_:else_.edit_state\n in\n let send =\n Auth_required.Checked.if_ b ~then_:then_.send ~else_:else_.send\n in\n let receive =\n Auth_required.Checked.if_ b ~then_:then_.receive ~else_:else_.receive\n in\n let set_delegate =\n Auth_required.Checked.if_ b ~then_:then_.set_delegate\n ~else_:else_.set_delegate\n in\n let set_permissions =\n Auth_required.Checked.if_ b ~then_:then_.set_permissions\n ~else_:else_.set_permissions\n in\n let set_verification_key_auth =\n Auth_required.Checked.if_ b\n ~then_:(fst then_.set_verification_key)\n ~else_:(fst else_.set_verification_key)\n in\n let%map txn_version =\n Mina_numbers.Txn_version.Checked.if_ b\n ~then_:(snd then_.set_verification_key)\n ~else_:(snd else_.set_verification_key)\n in\n let set_zkapp_uri =\n Auth_required.Checked.if_ b ~then_:then_.set_zkapp_uri\n ~else_:else_.set_zkapp_uri\n in\n let edit_action_state =\n Auth_required.Checked.if_ b ~then_:then_.edit_action_state\n ~else_:else_.edit_action_state\n in\n let set_token_symbol =\n Auth_required.Checked.if_ b ~then_:then_.set_token_symbol\n ~else_:else_.set_token_symbol\n in\n let increment_nonce =\n Auth_required.Checked.if_ b ~then_:then_.increment_nonce\n ~else_:else_.increment_nonce\n in\n let set_voting_for =\n Auth_required.Checked.if_ b ~then_:then_.set_voting_for\n ~else_:else_.set_voting_for\n in\n let set_timing =\n Auth_required.Checked.if_ b ~then_:then_.set_timing\n ~else_:else_.set_timing\n in\n let access =\n Auth_required.Checked.if_ b ~then_:then_.access ~else_:else_.access\n in\n { Poly.edit_state\n ; send\n ; receive\n ; set_delegate\n ; set_permissions\n ; set_verification_key = (set_verification_key_auth, txn_version)\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 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\n ~set_verification_key:(fun f ->\n let auth, txn_version = get f t in\n ( Auth_required.Checked.constant auth\n , Mina_numbers.Txn_version.Checked.constant txn_version ) )\n ~set_zkapp_uri:a ~edit_action_state:a ~set_token_symbol:a\n ~increment_nonce:a ~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 ; Typ.tuple2 Auth_required.typ Mina_numbers.Txn_version.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\nlet to_input (x : t) =\n Poly.to_input Auth_required.to_input Mina_numbers.Txn_version.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, Mina_numbers.Txn_version.current)\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, Mina_numbers.Txn_version.current)\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\nmodule As_record = struct\n type t = { auth : Auth_required.t; txn_version : Mina_numbers.Txn_version.t }\n [@@deriving fields, annot]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n let transaction_version =\n needs_custom_js ~js_type:uint32 ~name:\"TransactionVersion\" uint32\n in\n Fields.make_creator obj ~auth:!.auth_required\n ~txn_version:!.transaction_version\n |> finish \"VerificationKeyPermission\" ~t_toplevel_annots\nend\n\nlet to_record (auth, txn_version) = { As_record.auth; txn_version }\n\nlet of_record { As_record.auth; txn_version } = (auth, txn_version)\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\n ~set_verification_key:!.(iso_record ~to_record ~of_record As_record.deriver)\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: {\n auth: \"Signature\",\n txnVersion: \"3\"\n },\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\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 = Bounded_types.String.Tagged.Stable.V1.t\n [@@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 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 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 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 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","open 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 *)\nopen Core_kernel\nopen Snark_params.Tick\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 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)\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 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 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 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)\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\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","(* user_command_payload.ml *)\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 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 }\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 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\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","open 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 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 signature Poly.{ signature; _ } = signature\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 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)\n ?(min_fee = Genesis_constants.For_unit_tests.t.minimum_user_command_fee)\n ~fee_range create_body =\n let open Quickcheck.Generator.Let_syntax in\n let min_fee = Fee.to_nanomina_int min_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 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 ?min_fee ~fee_range () =\n gen_inner sign' ~key_gen ?nonce ?min_fee ~fee_range\n @@ fun { 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 ?min_fee ~fee_range =\n with_random_participants ~keys ~gen:(fun ~key_gen ->\n gen ?sign_type ~key_gen ?nonce ?min_amount ~max_amount ?min_fee\n ~fee_range )\n end\n\n module Stake_delegation = struct\n let gen ~key_gen ?nonce ?min_fee ~fee_range () =\n gen_inner For_tests.fake_sign ~key_gen ?nonce ?min_fee ~fee_range\n (fun { 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 ?min_fee ~fee_range =\n with_random_participants ~keys ~gen:(gen ?nonce ?min_fee ~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\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.Legacy.(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 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\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","open Core_kernel\n\nlet field_of_bool = Mina_base_util.field_of_bool\n\nopen Snark_params.Tick\nopen Signature_lib\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 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\nend\n\nmodule Flagged_data = struct\n type ('flag, 'a) t = { flag : 'flag; data : 'a } [@@deriving hlist, fields]\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 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 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 let lazy_option_typ ~default t =\n Typ.transport (typ t)\n ~there:(fun t -> of_option t ~default:(Lazy.force default))\n ~back:to_option\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 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 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 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\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 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\nend\n\nmodule F = Pickles.Backend.Tick.Field\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","open 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 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 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 =\n Hash_prefix_create.salt Inputs.salt_phrase |> Random_oracle.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 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 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 Hash_prefix_create.salt salt_phrase |> Random_oracle.digest\n\n let push_events (acc : Field.t) (events : t) : Field.t =\n push_hash acc (hash events)\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 |]\nend\n\nmodule Zkapp_uri = struct\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = Bounded_types.String.Stable.V1.t\n [@@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 (Bounded_types.String.Stable.V1)\n (struct\n type t = Bounded_types.String.Stable.V1.t\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\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.lazy_option_typ\n ~default:(lazy { 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\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%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\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 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\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 = Bounded_types.String.Stable.V1.t\n [@@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 (Bounded_types.String.Stable.V1)\n (struct\n type t = Bounded_types.String.Stable.V1.t\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 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_\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\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 : Public_key.Compressed.Stable.V1.t\n ; token_id : Token_id.Stable.V2.t\n ; token_symbol : Token_symbol.Stable.V1.t\n ; balance : Balance.Stable.V1.t\n ; nonce : Nonce.Stable.V1.t\n ; receipt_chain_hash : Receipt.Chain_hash.Stable.V1.t\n ; delegate : Public_key.Compressed.Stable.V1.t option\n ; voting_for : State_hash.Stable.V1.t\n ; timing : Timing.Stable.V2.t\n ; permissions : Permissions.Stable.V2.t\n ; zkapp : Zkapp_account.Stable.V2.t option\n }\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 { public_key : Public_key.Compressed.Stable.V1.t\n ; token_id : Token_id.Stable.V2.t\n ; token_symbol : Token_symbol.Stable.V1.t\n ; balance : Balance.Stable.V1.t\n ; nonce : Nonce.Stable.V1.t\n ; receipt_chain_hash : Receipt.Chain_hash.Stable.V1.t\n ; delegate : Public_key.Compressed.Stable.V1.t option\n ; voting_for : State_hash.Stable.V1.t\n ; timing : Timing.Stable.V2.t\n ; permissions : Permissions.Stable.V2.t\n ; zkapp : Zkapp_account.Stable.V2.t option\n }\n [@@deriving sexp, equal, hash, compare, yojson, hlist, fields]\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\nStable.Latest.(sexp_of_t, t_of_sexp, equal, to_yojson, of_yojson)]\n\nlet to_poly\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 { Poly.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\nlet of_poly\n { Poly.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 { 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\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 = t [@@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 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\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:to_hlist ~value_of_hlist: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\nlet digest = crypto_hash\n\nlet empty =\n { 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 = lazy (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 { 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 { 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\nlet initial_minimum_balance { timing; _ } =\n match timing with\n | Timing.Untimed ->\n None\n | Timed t ->\n Some t.initial_minimum_balance\n\nlet cliff_time { timing; _ } =\n match timing with Timing.Untimed -> None | Timed t -> Some t.cliff_time\n\nlet cliff_amount { 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\ntype t = Value.Stable.V1.t [@@deriving sexp, compare, equal, hash, yojson]\n\ninclude Comparable.Make (Value.Stable.V1)\n","open Core_kernel\nopen Snark_params.Tick\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 nonce (n : Account.Nonce.t) =\n let nonce : _ Numeric.t = Check { lower = n; upper = n } in\n { accept with nonce }\n\n let is_nonce (t : t) =\n match t.nonce with\n | Ignore ->\n false\n | Check { lower; upper } ->\n (* nonce is exact, all other fields are Ignore *)\n Mina_numbers.Account_nonce.equal lower upper\n && is_accept { t with nonce = Ignore }\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.For_unit_tests.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.t.protocol.slots_per_sub_window\n * Genesis_constants.For_unit_tests.Constraint_constants.t\n .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 lazy_optional_typ ~hash ~non_preimage ~dummy_value =\n Typ.transport\n Typ.(Field.typ * Internal.ref ())\n ~there:(function\n | None -> (Lazy.force non_preimage, dummy_value) | Some s -> (hash s, s)\n )\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","open Core_kernel\nopen Mina_base_util\nopen Snark_params.Tick\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 Events = Zkapp_account.Events\nmodule Actions = Zkapp_account.Actions\nmodule Zkapp_uri = Zkapp_account.Zkapp_uri\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 (Field.t[@version_asserted])\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 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 ( !. ) = ( !. ) ~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 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 module Checked = Structured.Checked\n\n let typ =\n Structured.typ |> Typ.transport ~there:to_structured ~back:of_structured_exn\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 let may_use_token =\n iso_record ~of_record:As_record.to_variant ~to_record:As_record.of_variant\n As_record.deriver\n in\n needs_custom_js\n ~js_type:\n (js_record\n [ (\"parentsOwnToken\", js_layout bool)\n ; (\"inheritFromParent\", js_layout bool)\n ] )\n ~name:\"MayUseToken\" may_use_token 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 : Zkapp_uri.Stable.V1.t 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.lazy_optional_typ ~hash:Zkapp_account.hash_zkapp_uri\n ~non_preimage:(lazy (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 Account_precondition = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Zkapp_precondition.Account.Stable.V2.t\n [@@deriving sexp, yojson, hash]\n\n let (_ :\n ( t\n , Mina_wire_types.Mina_base.Account_update.Account_precondition.V1.t\n )\n Type_equal.t ) =\n Type_equal.T\n\n let to_latest = Fn.id\n\n [%%define_locally Zkapp_precondition.Account.(equal, compare)]\n end\n end]\n\n [%%define_locally Stable.Latest.(equal, compare)]\n\n let gen : t Quickcheck.Generator.t =\n (* we used to have 3 constructors, Full, Nonce, and Accept for the type t\n nowadays, the generator creates these 3 different kinds of values, but all mapped to t\n *)\n Quickcheck.Generator.variant3 Zkapp_precondition.Account.gen\n Account.Nonce.gen Unit.quickcheck_generator\n |> Quickcheck.Generator.map ~f:(function\n | `A precondition ->\n precondition\n | `B n ->\n Zkapp_precondition.Account.nonce n\n | `C () ->\n Zkapp_precondition.Account.accept )\n\n module Tag = struct\n type t = Full | Nonce | Accept [@@deriving equal, compare, sexp, yojson]\n end\n\n let deriver obj = 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 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 Zkapp_precondition.Account.typ ()\n\n let nonce ({ nonce; _ } : t) = nonce\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 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 = Zkapp_precondition.Account.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 =\n Pickles.Backend.Tick.Field.Stable.V1.t\n Bounded_types.ArrayN16.Stable.V1.t\n 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 = Zkapp_precondition.Account.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 = Zkapp_precondition.Account.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; preconditions; balance_change; _ } = t in\n let fee =\n Currency.Fee.of_uint64\n (balance_change.magnitude |> Currency.Amount.to_uint64)\n in\n let nonce =\n if Zkapp_precondition.Account.is_nonce preconditions.account then\n match preconditions.account.nonce with\n | Check { lower; upper = _ } ->\n lower\n | Ignore ->\n failwith \"Unexpected Ignore for fee payer precondition nonce\"\n else 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 ?chain (t : t) =\n Random_oracle.Checked.(\n hash ~init:(Hash_prefix.zkapp_body ?chain) (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 ?chain (t : t) =\n Random_oracle.(\n hash ~init:(Hash_prefix.zkapp_body ?chain) (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 ?chain (t : t) = Body.digest ?chain t.body\n\n module Checked = struct\n type t = Body.Checked.t\n\n let digest ?chain (t : t) = Body.Checked.digest ?chain 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 :\n ?chain:Mina_signature_kind.t -> Account_update.Checked.t -> t\n\n val create_body :\n ?chain:Mina_signature_kind.t -> 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 : ?chain:Mina_signature_kind.t -> Account_update.t -> t\n\n val create_body :\n ?chain:Mina_signature_kind.t -> 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_types = struct\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 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 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 end\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 include Make_digest_types.Account_update\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 : ?chain:Mina_signature_kind.t -> Account_update.t -> t =\n Account_update.digest\n\n let create_body :\n ?chain:Mina_signature_kind.t -> Account_update.Body.t -> t =\n Account_update.Body.digest\n end\n\n module Forest = struct\n include Make_digest_types.Forest\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 include Make_digest_types.Tree\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 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 = 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) : (Account_id.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 (Account_update.account_id p, 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 load_vk_from_ledger :\n location_of_account:(Account_id.t -> 'loc option)\n -> get:('loc -> Account.t option)\n -> Zkapp_basic.F.t\n -> Account_id.t\n -> Verification_key_wire.t Or_error.t\n\n val load_vks_from_ledger :\n location_of_account_batch:\n (Account_id.t list -> (Account_id.t * 'loc option) list)\n -> get_batch:('loc list -> ('loc * Account.t option) list)\n -> Account_id.t list\n -> Verification_key_wire.t Account_id.Map.t\n\n val create :\n T.t\n -> failed:bool\n -> find_vk:\n (Zkapp_basic.F.t -> Account_id.t -> Verification_key_wire.t Or_error.t)\n -> t Or_error.t\n\n module type Command_wrapper_intf = sig\n type 'a t\n\n val unwrap : 'a t -> 'a\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val is_failed : 'a t -> bool\n end\n\n module type Create_all_intf = sig\n type cache\n\n module Command_wrapper : Command_wrapper_intf\n\n val create_all :\n T.t Command_wrapper.t list -> cache -> t Command_wrapper.t list Or_error.t\n end\n\n module From_unapplied_sequence :\n Create_all_intf\n with type 'a Command_wrapper.t = 'a\n and type cache =\n Verification_key_wire.t Zkapp_basic.F_map.Map.t Account_id.Map.t\n\n module From_applied_sequence :\n Create_all_intf\n with type 'a Command_wrapper.t = 'a With_status.t\n and type cache = Verification_key_wire.t Account_id.Map.t\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 load_vk_from_ledger ~location_of_account ~get expected_vk_hash account_id\n =\n match\n let open Option.Let_syntax in\n let%bind location = location_of_account account_id in\n let%bind (account : Account.t) = get 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 let load_vks_from_ledger ~location_of_account_batch ~get_batch account_ids =\n let locations =\n location_of_account_batch account_ids |> List.filter_map ~f:snd\n in\n get_batch locations\n |> List.filter_map ~f:(fun ((_, account) : _ * Account.t option) ->\n let open Option.Let_syntax in\n let account = Option.value_exn account in\n let%bind zkapp = account.zkapp in\n let%map verification_key = zkapp.verification_key in\n (Account.identifier account, verification_key) )\n |> Account_id.Map.of_alist_exn\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) ~failed ~find_vk :\n 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 (p.body.authorization_kind, failed) with\n | Proof vk_hash, false -> (\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 type Cache_intf = sig\n type t\n\n val find :\n t\n -> account_id:Account_id.t\n -> vk_hash:Zkapp_basic.F.t\n -> Verification_key_wire.t option\n\n val add : t -> account_id:Account_id.t -> vk:Verification_key_wire.t -> t\n end\n\n module type Command_wrapper_intf = sig\n type 'a t\n\n val unwrap : 'a t -> 'a\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val is_failed : 'a t -> bool\n end\n\n module type Create_all_intf = sig\n type cache\n\n module Command_wrapper : Command_wrapper_intf\n\n val create_all :\n T.t Command_wrapper.t list -> cache -> t Command_wrapper.t list Or_error.t\n end\n\n module Make_create_all\n (Cache : Cache_intf)\n (Command_wrapper : Command_wrapper_intf) :\n Create_all_intf\n with module Command_wrapper := Command_wrapper\n and type cache = Cache.t = struct\n type cache = Cache.t\n\n let create_all (wrapped_cmds : T.t Command_wrapper.t list)\n (init_cache : Cache.t) : t Command_wrapper.t list Or_error.t =\n Or_error.try_with (fun () ->\n snd (* remove the helper cache we folded with *)\n (List.fold_map wrapped_cmds ~init:init_cache\n ~f:(fun running_cache wrapped_cmd ->\n let cmd = Command_wrapper.unwrap wrapped_cmd in\n let cmd_failed = Command_wrapper.is_failed wrapped_cmd in\n let verified_cmd : t =\n create cmd ~failed:cmd_failed\n ~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 ~account_id ~vk_hash with\n | None ->\n Error\n (Error.of_string\n \"verification key not found in cache\" )\n | Some vk ->\n Ok vk )\n |> Or_error.ok_exn\n in\n let running_cache' =\n (* update the cache if the command is not failed *)\n if not cmd_failed then\n List.fold (extract_vks cmd) ~init:running_cache\n ~f:(fun acc (account_id, vk) ->\n Cache.add acc ~account_id ~vk )\n else running_cache\n in\n ( running_cache'\n , Command_wrapper.map wrapped_cmd ~f:(Fn.const verified_cmd) ) )\n ) )\n end\n\n (* There are 2 situations in which we are converting commands to their verifiable format:\n - we are reasoning about the validity of commands when the sequence is not yet known\n - we are reasoning about the validity of commands when the sequence (and by extension, status) is known\n *)\n\n module From_unapplied_sequence = struct\n module Cache = struct\n type t = Verification_key_wire.t Zkapp_basic.F_map.Map.t Account_id.Map.t\n\n let find (t : t) ~account_id ~vk_hash =\n let%bind.Option vks = Map.find t account_id in\n Map.find vks vk_hash\n\n let add (t : t) ~account_id ~(vk : Verification_key_wire.t) =\n Map.update t account_id ~f:(fun vks_opt ->\n let vks =\n Option.value vks_opt ~default:Zkapp_basic.F_map.Map.empty\n in\n Map.set vks ~key:vk.hash ~data:vk )\n end\n\n module Command_wrapper : Command_wrapper_intf with type 'a t = 'a = struct\n type 'a t = 'a\n\n let unwrap t = t\n\n let map t ~f = f t\n\n let is_failed _ = false\n end\n\n include Make_create_all (Cache) (Command_wrapper)\n end\n\n module From_applied_sequence = struct\n module Cache = struct\n type t = Verification_key_wire.t Account_id.Map.t\n\n let find (t : t) ~account_id ~vk_hash =\n let%bind.Option vk = Map.find t account_id in\n Option.some_if (Zkapp_basic.F.equal vk_hash vk.hash) vk\n\n let add (t : t) ~account_id ~vk = Map.set t ~key:account_id ~data:vk\n end\n\n module Command_wrapper :\n Command_wrapper_intf with type 'a t = 'a With_status.t = struct\n type 'a t = 'a With_status.t\n\n let unwrap = With_status.data\n\n let map { With_status.status; data } ~f =\n { With_status.status; data = f data }\n\n let is_failed { With_status.status; _ } =\n match status with Applied -> false | Failed _ -> true\n end\n\n include Make_create_all (Cache) (Command_wrapper)\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 -> failed:bool\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) ~failed ~find_vk : t Or_error.t =\n Verifiable.create t ~failed ~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 lazy\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 is_incompatible_version t =\n Call_forest.exists t.account_updates ~f:(fun p ->\n match p.body.update.permissions with\n | Keep ->\n false\n | Set { set_verification_key = _auth, txn_version; _ } ->\n not Mina_numbers.Txn_version.(equal_to_current txn_version) )\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) ~failed ~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 ~failed ~find_vk cmd\n |> Or_error.map ~f:(fun cmd -> Zkapp_command cmd)\n\nmodule Make_to_all_verifiable\n (Strategy : Zkapp_command.Verifiable.Create_all_intf) =\nstruct\n let to_all_verifiable (ts : t Strategy.Command_wrapper.t list) ~load_vk_cache\n : Verifiable.t Strategy.Command_wrapper.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 Strategy.Command_wrapper.unwrap cmd with\n | Zkapp_command c ->\n First (i, Strategy.Command_wrapper.map cmd ~f:(Fn.const c))\n | Signed_command c ->\n Second (i, Strategy.Command_wrapper.map cmd ~f:(Fn.const 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 (* TODO: we could optimize this by skipping the fee payer and non-proof authorizations *)\n let accounts_referenced =\n List.fold_left zk_cmds ~init:Account_id.Set.empty ~f:(fun set zk_cmd ->\n Strategy.Command_wrapper.unwrap zk_cmd\n |> Zkapp_command.accounts_referenced |> Account_id.Set.of_list\n |> Set.union set )\n in\n let vk_cache = load_vk_cache accounts_referenced in\n let%map vzk_cmds = Strategy.create_all zk_cmds vk_cache 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, Strategy.Command_wrapper.map cmd ~f:(fun c -> Signed_command c)) )\n @ List.map ivzk_cmds ~f:(fun (i, cmd) ->\n (i, Strategy.Command_wrapper.map cmd ~f:(fun c -> Zkapp_command c)) )\n |> List.sort ~compare:(fun (i, _) (j, _) -> i - j)\n in\n (* Drop the indices *)\n List.unzip ivs |> snd\nend\n\nmodule Unapplied_sequence =\n Make_to_all_verifiable (Zkapp_command.Verifiable.From_unapplied_sequence)\nmodule Applied_sequence =\n Make_to_all_verifiable (Zkapp_command.Verifiable.From_applied_sequence)\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\nlet has_insufficient_fee ~minimum_fee t = Currency.Fee.(fee t < minimum_fee)\n\nlet is_disabled = function\n | Zkapp_command _ ->\n Node_config_unconfigurable_constants.zkapps_disabled\n | _ ->\n false\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 -> (Account_id.t * Verification_key_wire.t) List.t =\n 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 ~failed ~find_vk (t : t) : Valid.t Or_error.t =\n to_verifiable ~failed ~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\nlet is_incompatible_version = function\n | Signed_command _ ->\n false\n | Zkapp_command p ->\n Zkapp_command.is_incompatible_version p\n\nlet has_invalid_call_forest : t -> bool = function\n | Signed_command _ ->\n false\n | Zkapp_command cmd ->\n List.exists cmd.account_updates ~f:(fun call_forest ->\n let root_may_use_token =\n call_forest.elt.account_update.body.may_use_token\n in\n not (Account_update.May_use_token.equal root_may_use_token No) )\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 | Zkapp_invalid_call_forest\n | Transaction_type_disabled\n | Incompatible_version\n [@@deriving compare, to_yojson, sexp]\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)\n | Zkapp_invalid_call_forest ->\n \"Zkapp has an invalid call forest (root account updates may not use \\\n tokens)\"\n | Incompatible_version ->\n \"Set verification-key permission is updated to an incompatible version\"\n | Transaction_type_disabled ->\n \"Transaction type disabled\"\nend\n\nlet check_well_formedness ~(genesis_constants : Genesis_constants.t) t :\n (unit, Well_formedness_error.t list) result =\n let preds =\n let open Well_formedness_error in\n [ ( has_insufficient_fee\n ~minimum_fee:genesis_constants.minimum_user_command_fee\n , Insufficient_fee )\n ; (has_zero_vesting_period, Zero_vesting_period)\n ; (is_incompatible_version, Incompatible_version)\n ; (is_disabled, Transaction_type_disabled)\n ; (has_invalid_call_forest, Zkapp_invalid_call_forest)\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\ntype fee_payer_summary_t = Signature.t * Account.key * int\n[@@deriving yojson, hash]\n\nlet fee_payer_summary : t -> fee_payer_summary_t = function\n | Zkapp_command cmd ->\n let fp = Zkapp_command.fee_payer_account_update cmd in\n let open Account_update in\n let body = Fee_payer.body fp in\n ( Fee_payer.authorization fp\n , Body.Fee_payer.public_key body\n , Body.Fee_payer.nonce body |> Unsigned.UInt32.to_int )\n | Signed_command cmd ->\n Signed_command.\n (signature cmd, fee_payer_pk cmd, nonce cmd |> Unsigned.UInt32.to_int)\n\nlet fee_payer_summary_json =\n Fn.compose fee_payer_summary_t_to_yojson fee_payer_summary\n\nlet fee_payer_summary_string =\n let to_string (signature, pk, nonce) =\n sprintf \"%s (%s %d)\"\n (Signature.to_base58_check signature)\n (Signature_lib.Public_key.Compressed.to_base58_check pk)\n nonce\n in\n Fn.compose to_string fee_payer_summary\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 (* The order of this list will impact the order of new accounts in the\n ledger witness. We use `List.rev` to have the same order as the tx\n application (in `apply_coinbase`) where the \"coinbase fee transfer\"\n receiver is created before the \"coinbase\" receiver.\n *)\n List.map account_ids ~f:(fun acct_id -> (acct_id, access_status))\n |> List.rev\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, to_yojson, compare, equal]\n end\n end]\n\n val of_yojson : Yojson.Safe.t -> (t, string) result\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 = Hash_prefix_create.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 let init (t : t) = t.init\n\n let curr (t : t) = t.curr\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 Hash_prefix_create.salt \"PendingCoinbaseMerkleTree\"\n |> Random_oracle.digest |> of_hash\n\n let of_digest = 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\n let data (t : t) = t.data\n\n let state (t : t) = t.state\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 (* the type below triggers the ppx derivers to insert unused `rec` flags, so we ignore such warnings *)\n [@@@warning \"-39\"]\n\n type t = Hash_builder.t constraint t = Hash_versioned.t\n [@@deriving equal, compare, sexp, yojson, hash]\n\n [@@@warning \"+39\"]\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 hash_at_level =\n let cached = ref [||] in\n fun i ->\n let len = Array.length !cached in\n let len =\n if len = 0 then (\n cached := [| Stack.data_hash Stack.empty |] ;\n 1 )\n else len\n 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.For_unit_tests.Constraint_constants.t\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.For_unit_tests.Constraint_constants.t\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.For_unit_tests.Constraint_constants.t\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.For_unit_tests.Constraint_constants.t\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.For_unit_tests.Constraint_constants.t 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","open 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 = Bounded_types.String.Stable.V1.t\n [@@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 = Bounded_types.String.Stable.V1.t\n [@@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 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 (* TODO: We could just use a prover value. *)\n printf \"WARNING: improperly transporting staged-ledger-hash\\n\" ;\n 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 = Bounded_types.String.Stable.V1.t\n [@@deriving sexp, hash, compare, equal, yojson]\n\n let to_latest = Fn.id\n\n include\n Binable.Of_binable_without_uuid\n (Bounded_types.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","open 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\n and slots_per_sub_window = Int.gen_incl 1 ((k + 9) / 9) in\n let%bind grace_period_slots = Int.gen_incl 0 ((slots_per_epoch / 3) - 1) 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 = T.of_int slots_per_epoch\n ; slots_per_sub_window = T.of_int slots_per_sub_window\n ; grace_period_slots = T.of_int grace_period_slots\n ; genesis_state_timestamp\n }\nend\n\ntype value = Value.t\n\nlet value_of_t\n ({ k\n ; delta\n ; slots_per_epoch\n ; slots_per_sub_window\n ; grace_period_slots\n ; genesis_state_timestamp\n } :\n Genesis_constants.Protocol.t ) : value =\n { k = T.of_int k\n ; delta = T.of_int delta\n ; slots_per_epoch = T.of_int slots_per_epoch\n ; slots_per_sub_window = T.of_int slots_per_sub_window\n ; grace_period_slots = T.of_int grace_period_slots\n ; genesis_state_timestamp = Block_time.of_int64 genesis_state_timestamp\n }\n\nlet t_of_value\n ({ k\n ; delta\n ; slots_per_epoch\n ; slots_per_sub_window\n ; grace_period_slots\n ; genesis_state_timestamp\n } :\n value ) : Genesis_constants.Protocol.t =\n { k = T.to_int k\n ; delta = T.to_int delta\n ; slots_per_epoch = T.to_int slots_per_epoch\n ; slots_per_sub_window = T.to_int slots_per_sub_window\n ; grace_period_slots = T.to_int grace_period_slots\n ; genesis_state_timestamp = Block_time.to_int64 genesis_state_timestamp\n }\n\nlet to_input\n ({ k\n ; delta\n ; slots_per_epoch\n ; slots_per_sub_window\n ; grace_period_slots\n ; genesis_state_timestamp\n } :\n value ) =\n Array.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [| T.to_input k\n ; T.to_input delta\n ; T.to_input slots_per_epoch\n ; T.to_input slots_per_sub_window\n ; T.to_input grace_period_slots\n ; Block_time.to_input genesis_state_timestamp\n |]\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 ; 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\n ({ k\n ; delta\n ; slots_per_epoch\n ; slots_per_sub_window\n ; grace_period_slots\n ; genesis_state_timestamp\n } :\n var ) =\n let k = T.Checked.to_input k\n and delta = T.Checked.to_input delta\n and slots_per_epoch = T.Checked.to_input slots_per_epoch\n and slots_per_sub_window = T.Checked.to_input slots_per_sub_window\n and grace_period_slots = T.Checked.to_input grace_period_slots in\n let genesis_state_timestamp =\n Block_time.Checked.to_input 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 ; grace_period_slots\n ; genesis_state_timestamp\n |]\n\nlet%test_unit \"value = var\" =\n let compiled = Genesis_constants.For_unit_tests.t.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","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\nlet yojson_summary_of_command =\n let is_proof upd =\n match Account_update.authorization upd with Proof _ -> true | _ -> false\n in\n let zkapp_type cmd =\n let updates = Zkapp_command.account_updates_list cmd in\n Printf.sprintf \"zkapp:%d:%d\" (List.length updates)\n (List.count updates ~f:is_proof)\n in\n let mk_record type_ memo signature =\n `List\n [ `String type_\n ; `String (Signature.to_base58_check signature)\n ; `String (Signed_command_memo.to_string_hum memo)\n ]\n in\n function\n | User_command.Zkapp_command cmd ->\n mk_record (zkapp_type cmd) (Zkapp_command.memo cmd)\n ( Zkapp_command.fee_payer_account_update cmd\n |> Account_update.Fee_payer.authorization )\n | Signed_command cmd ->\n mk_record \"payment\" (Signed_command.memo cmd)\n (Signed_command.signature cmd)\n\nlet yojson_summary = function\n | Command cmd ->\n yojson_summary_of_command cmd\n | Fee_transfer _ ->\n `List [ `String \"fee_transfer\" ]\n | Coinbase cb ->\n let amount = Currency.Amount.to_yojson @@ Coinbase.amount cb in\n `List [ `String \"coinbase\"; amount ]\n\nlet yojson_summary_with_status cmd_with_status =\n let status =\n Transaction_status.to_yojson (With_status.status cmd_with_status)\n in\n match yojson_summary (With_status.data cmd_with_status) with\n | `List lst ->\n `List (lst @ [ status ])\n","open Core_kernel\nopen Mina_base\n\nmodule T = struct\n include Blake2.Make ()\nend\n\ninclude T\n\n(* Base58Check functions for original mainnet transaction hashes *)\nmodule V1_base58_check = Codable.Make_base58_check (struct\n (* top tag needed for compatibility *)\n type t = Stable.Latest.With_top_version_tag.t [@@deriving bin_io_unversioned]\n\n let version_byte = Base58_check.Version_bytes.v1_transaction_hash\n\n let description = \"V1 Transaction hash\"\nend)\n\nlet to_base58_check_v1 = V1_base58_check.to_base58_check\n\nlet of_base58_check_v1 = V1_base58_check.of_base58_check\n\nlet of_base58_check_exn_v1 = V1_base58_check.of_base58_check_exn\n\n(* Base58Check functions for current hard fork *)\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 (Lazy.force 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\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 \"decode, recode v1 hashes\" =\n let v1_hashes =\n [ \"CkpZirFuoLVVab6x2ry4j8Ld5gMmQdak7VHW6f5C7VJYE34WAEWqa\"\n ; \"CkpZB4WE3wDRJ4CqCXqS4dqF8hoRQDVK8banePKUgTR6kvhTfyjRp\"\n ; \"CkpYeG32dVJUjs6iq3oroXWitXar1eBtV3GVFyH5agw7HPp9bG4yQ\"\n ]\n in\n let decoded = List.map v1_hashes ~f:of_base58_check_exn_v1 in\n let recoded = List.map decoded ~f:to_base58_check_v1 in\n List.equal String.equal v1_hashes recoded\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 = (Lazy.force 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 (Lazy.force 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 \"5JtWZqwvKEgSMSHbDhYXg6s76GhfBNscQtxLKXnT6YYTsUKQkcpV\"\n in\n run_test ~transaction_id ~expected_hash\n end )\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 :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> t\n -> Currency.Amount.Signed.t Or_error.t =\n fun ~constraint_constants 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 constraint_constants.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 :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> t\n -> 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\n val new_accounts : t -> Account_id.t list\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 module Stack (Elt : sig\n type t\n end) : sig\n type t = Elt.t list\n\n val if_ : bool -> then_:t -> else_:t -> t\n\n val empty : unit -> t\n\n val is_empty : t -> bool\n\n val pop_exn : t -> Elt.t * t\n\n val pop : t -> (Elt.t * t) option\n\n val push : Elt.t -> onto:t -> t\n end\n\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 : Account.t) ~txn_amount\n ~txn_global_slot =\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.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\n let verification_key_perm_fallback_to_signature_with_older_version =\n Permissions.Auth_required\n .verification_key_perm_fallback_to_signature_with_older_version\n end\n\n module Txn_version = struct\n type t = Mina_numbers.Txn_version.t\n\n let if_ = value_if\n\n let equal_to_current = Mina_numbers.Txn_version.equal_to_current\n\n let older_than_current = Mina_numbers.Txn_version.older_than_current\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 = Bounded_types.String.t\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_auth : t -> Controller.t =\n fun a -> fst a.permissions.set_verification_key\n\n let set_verification_key_txn_version : t -> Txn_version.t =\n fun a -> snd 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 let local_state = ref local_state in\n let check failure b =\n local_state := Inputs.Local_state.add_check !local_state failure b\n in\n Zkapp_precondition.Account.check ~new_account ~check\n account_update.body.preconditions.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 module Stack = Inputs.Stack\n\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, Mina_numbers.Txn_version.current)\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 = Zkapp_precondition.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 (Lazy.force 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 = Zkapp_precondition.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.t) =\n { (Account.to_poly 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 Field = Impl.Field\nmodule Boolean = Impl.Boolean\nmodule Typ = Impl.Typ\nmodule Backend = Pickles.Backend\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 Promise_js_helpers.js_promise )\n Js.prop\n ; featureFlags : bool option Pickles_types.Plonk_types.Features.t 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\nlet map_feature_flags_option\n (feature_flags_ : bool option Pickles_types.Plonk_types.Features.t) =\n Pickles_types.Plonk_types.Features.map feature_flags_ ~f:(function\n | Some true ->\n Pickles_types.Opt.Flag.Yes\n | Some false ->\n Pickles_types.Opt.Flag.No\n | None ->\n Pickles_types.Opt.Flag.Maybe )\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.Promise.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\n (* this is called after `picklesRuleFromFunction()` and finishes the circuit *)\n let finish_circuit prevs self js_result :\n _ Pickles.Inductive_rule.main_return =\n (* convert js rule output to pickles rule output *)\n let public_output = js_result##.publicOutput in\n let previous_proofs_should_verify =\n should_verifys prevs js_result##.shouldVerify\n in\n let previous_public_inputs =\n prev_statements ~public_input_size ~public_output_size ~self prevs\n js_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, prev_values, widths, heights) H4.T(Pickles.Tag).t\n -> ( prev_vars\n , widths )\n H2.T(Pickles.Inductive_rule.Previous_proof_statement).t =\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 ()) ~request:(fun () ->\n 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 prevs\n in\n { previous_proof_statements; public_output; auxiliary_output = () }\n in\n\n let rule ~(self : (Statement.t, Statement.Constant.t, _, _) Pickles.Tag.t)\n : _ Pickles.Inductive_rule.Promise.t =\n let prevs = prevs ~self in\n\n let main ({ public_input } : _ Pickles.Inductive_rule.main_input) =\n (* add dummy constraints *)\n dummy_constraints () ;\n (* circuit from js *)\n rule##.main public_input\n |> Promise_js_helpers.of_js\n |> Promise.map ~f:(finish_circuit prevs self)\n in\n { identifier = Js.to_string rule##.identifier\n ; feature_flags =\n Pickles_types.Plonk_types.Features.map rule##.featureFlags\n ~f:(function\n | Some true ->\n true\n | _ ->\n false )\n ; prevs\n ; main\n }\n in\n Rule rule\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.Promise).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.Promise).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\nmodule Cache = struct\n module Sync : Key_cache.Sync = struct\n open Key_cache\n include T (Or_error)\n\n module Disk_storable = struct\n include Disk_storable (Or_error)\n\n let of_binable = Trivial.Disk_storable.of_binable\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 = _ } key =\n Or_error.find_map_ok spec ~f:(fun s ->\n let res, cache_hit =\n match s with\n | Spec.On_disk { should_write; _ } ->\n let path = to_string key in\n ( read ~path key\n , if should_write then `Locally_generated else `Cache_hit )\n | S3 _ ->\n (Or_error.errorf \"Downloading from S3 is disabled\", `Cache_hit)\n in\n Or_error.map res ~f:(fun res -> (res, cache_hit)) )\n\n let write spec { Disk_storable.to_string; read = _; write } key value =\n let errs =\n List.filter_map spec ~f:(fun s ->\n let res =\n match s with\n | Spec.On_disk { should_write; _ } ->\n if should_write then write key value (to_string key)\n else Or_error.return ()\n | S3 _ ->\n Or_error.return ()\n in\n match res with Error e -> Some e | Ok () -> None )\n in\n match errs with [] -> Ok () | errs -> Error (Error.of_list errs)\n end\n\n let () = Key_cache.set_sync_implementation (module Sync)\n\n open Pickles.Cache\n\n type any_key =\n | Step_pk of Step.Key.Proving.t\n | Step_vk of Step.Key.Verification.t\n | Wrap_pk of Wrap.Key.Proving.t\n | Wrap_vk of Wrap.Key.Verification.t\n\n type any_value =\n | Step_pk of Backend.Tick.Keypair.t\n | Step_vk of Kimchi_bindings.Protocol.VerifierIndex.Fp.t\n | Wrap_pk of Backend.Tock.Keypair.t\n | Wrap_vk of Pickles.Verification_key.t\n\n let step_pk = function Step_pk v -> Ok v | _ -> Or_error.errorf \"step_pk\"\n\n let step_vk = function Step_vk v -> Ok v | _ -> Or_error.errorf \"step_vk\"\n\n let wrap_pk = function Wrap_pk v -> Ok v | _ -> Or_error.errorf \"wrap_pk\"\n\n let wrap_vk = function Wrap_vk v -> Ok v | _ -> Or_error.errorf \"wrap_vk\"\n\n type js_storable =\n { read : any_key -> Js.js_string Js.t -> (any_value, unit) result\n ; write : any_key -> any_value -> Js.js_string Js.t -> (unit, unit) result\n ; can_write : bool\n }\n\n let or_error f = function Ok v -> f v | _ -> Or_error.errorf \"failed\"\n\n let map_error = function Ok v -> Ok v | _ -> Or_error.errorf \"failed\"\n\n let step_storable { read; write; _ } : Step.storable =\n let read key ~path =\n read (Step_pk key) (Js.string path) |> or_error step_pk\n in\n let write key value path =\n write (Step_pk key) (Step_pk value) (Js.string path) |> map_error\n in\n Sync.Disk_storable.simple Step.Key.Proving.to_string read write\n\n let step_vk_storable { read; write; _ } : Step.vk_storable =\n let read key ~path =\n read (Step_vk key) (Js.string path) |> or_error step_vk\n in\n let write key value path =\n write (Step_vk key) (Step_vk value) (Js.string path) |> map_error\n in\n Sync.Disk_storable.simple Step.Key.Verification.to_string read write\n\n let wrap_storable { read; write; _ } : Wrap.storable =\n let read key ~path =\n read (Wrap_pk key) (Js.string path) |> or_error wrap_pk\n in\n let write key value path =\n write (Wrap_pk key) (Wrap_pk value) (Js.string path) |> map_error\n in\n Sync.Disk_storable.simple Wrap.Key.Proving.to_string read write\n\n let wrap_vk_storable { read; write; _ } : Wrap.vk_storable =\n let read key ~path =\n read (Wrap_vk key) (Js.string path) |> or_error wrap_vk\n in\n let write key value path =\n write (Wrap_vk key) (Wrap_vk value) (Js.string path) |> map_error\n in\n Sync.Disk_storable.simple Wrap.Key.Verification.to_string read write\n (* TODO get this code to understand equivalence of versions of Pickles.Verification_key.t *)\n |> Obj.magic\n\n let storables s : Pickles.Storables.t =\n { step_storable = step_storable s\n ; step_vk_storable = step_vk_storable s\n ; wrap_storable = wrap_storable s\n ; wrap_vk_storable = wrap_vk_storable s\n }\n\n let cache_dir { can_write; _ } : Key_cache.Spec.t list =\n let d : Key_cache.Spec.t =\n On_disk { directory = \"\"; should_write = can_write }\n in\n [ d ]\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 pickles_compile (choices : pickles_rule_js array)\n (config :\n < publicInputSize : int Js.prop\n ; publicOutputSize : int Js.prop\n ; storable : Cache.js_storable Js.optdef_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 = config##.publicInputSize in\n let public_output_size = config##.publicOutputSize in\n let override_wrap_domain =\n Js.Optdef.to_option config##.overrideWrapDomain\n |> Option.map ~f:Pickles_base.Proofs_verified.of_int_exn\n in\n let (Choices choices) =\n Choices.of_js ~public_input_size ~public_output_size choices\n in\n\n (* parse caching configuration *)\n let storables =\n Js.Optdef.to_option config##.storable |> Option.map ~f:Cache.storables\n in\n let cache =\n Js.Optdef.to_option config##.storable |> Option.map ~f:Cache.cache_dir\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 ?storables ?cache\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 let get_vk () =\n let vk = Pickles.Side_loaded.Verification_key.of_compiled_promise tag in\n Promise.map vk ~f:(fun vk ->\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 |> 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 val getVerificationKey = get_vk\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 load_srs_fp () = Backend.Tick.Keypair.load_urs ()\n\nlet load_srs_fq () = Backend.Tock.Keypair.load_urs ()\n\nlet dummy_proof (max_proofs_verified : int) (domain_log2 : int) : some_proof =\n match max_proofs_verified with\n | 0 ->\n let n = Pickles_types.Nat.N0.n in\n Proof0 (Pickles.Proof.dummy n n n ~domain_log2)\n | 1 ->\n let n = Pickles_types.Nat.N1.n in\n Proof1 (Pickles.Proof.dummy n n n ~domain_log2)\n | 2 ->\n let n = Pickles_types.Nat.N2.n in\n Proof2 (Pickles.Proof.dummy n n n ~domain_log2)\n | _ ->\n failwith \"invalid\"\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 encode_verification_key (vk : Pickles.Verification_key.t) =\n Pickles.Verification_key.to_yojson vk |> Yojson.Safe.to_string |> Js.string\n\nlet decode_verification_key (bytes : Js.js_string Js.t) =\n let vk_or_error =\n Pickles.Verification_key.of_yojson @@ Yojson.Safe.from_string\n @@ Js.to_string bytes\n in\n let open Ppx_deriving_yojson_runtime.Result in\n match vk_or_error with\n | Ok vk ->\n vk\n | Error err ->\n failwithf \"Could not decode verification key: %s\" err ()\n\nmodule Util = struct\n let to_ml_string s = Js.to_string s\n\n let from_ml_string s = Js.string s\nend\n\nlet side_loaded_create (name : Js.js_string Js.t) (max_proofs_verified : int)\n (public_input_length : int) (public_output_length : int)\n (feature_flags_js : bool option Pickles_types.Plonk_types.Features.t) =\n let name = Js.to_string name in\n let feature_flags = map_feature_flags_option feature_flags_js in\n let typ = statement_typ public_input_length public_output_length in\n match max_proofs_verified with\n | 0 ->\n Obj.magic\n @@ Pickles.Side_loaded.create ~name\n ~max_proofs_verified:(module Pickles_types.Nat.N0)\n ~feature_flags ~typ\n | 1 ->\n Obj.magic\n @@ Pickles.Side_loaded.create ~name\n ~max_proofs_verified:(module Pickles_types.Nat.N1)\n ~feature_flags ~typ\n | 2 ->\n Obj.magic\n @@ Pickles.Side_loaded.create ~name\n ~max_proofs_verified:(module Pickles_types.Nat.N2)\n ~feature_flags ~typ\n | _ ->\n failwith \"side_loaded_create is unhappy; you should pass 0, 1, or 2\"\n\nlet vk_to_circuit vk =\n let vk () =\n match\n Pickles.Side_loaded.Verification_key.of_base64 (Js.to_string (vk ()))\n 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 Impl.exists Pickles.Side_loaded.Verification_key.typ ~compute:(fun () ->\n vk () )\n\nlet vk_digest vk =\n Pickles.Side_loaded.Verification_key.Checked.to_input vk\n |> Random_oracle.Checked.pack_input\n\nlet in_circuit tag checked_vk = Pickles.Side_loaded.in_circuit tag checked_vk\n\nlet in_prover tag (vk : Js.js_string Js.t) =\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.in_prover tag vk\n\nlet pickles =\n object%js\n val compile = pickles_compile\n\n val verify = verify\n\n val loadSrsFp = load_srs_fp\n\n val loadSrsFq = load_srs_fq\n\n val dummyProof = dummy_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\n val encodeVerificationKey = encode_verification_key\n\n val decodeVerificationKey = decode_verification_key\n\n val util =\n object%js\n val toMlString = Util.to_ml_string\n\n val fromMlString = Util.from_ml_string\n end\n\n val sideLoaded =\n object%js\n val create = side_loaded_create\n\n val inCircuit =\n (* We get weak variables here, but they're synthetic. Don't try this\n at home.\n *)\n Obj.magic in_circuit\n\n val inProver =\n (* We get weak variables here, but they're synthetic. Don't try this\n at home.\n *)\n Obj.magic in_prover\n\n val vkToCircuit = vk_to_circuit\n\n val vkDigest = vk_digest\n end\n end\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 lazy\n ( Account_update.Graphql_repr.deriver\n @@ 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 (Lazy.force 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 (Lazy.force 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 lazy\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 (Lazy.force body_deriver)\n |> Account_update.Body.of_graphql_repr\n in\n body_of_json\n\nlet get_network_id_of_js_string (network : Js.js_string Js.t) =\n match Js.to_string network with\n | \"mainnet\" ->\n Mina_signature_kind.Mainnet\n | \"testnet\" ->\n Mina_signature_kind.Testnet\n | other ->\n Mina_signature_kind.(Other_network other)\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 (network_id : Js.js_string Js.t) =\n Signature_lib.Schnorr.Chunked.sign\n ~signature_kind:(get_network_id_of_js_string network_id)\n 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) (network_id : Js.js_string Js.t) =\n p |> account_update_of_json\n |> Account_update.digest ~chain:(get_network_id_of_js_string network_id)\n\n let transaction_commitments (tx_json : Js.js_string Js.t)\n (network_id : Js.js_string Js.t) =\n let chain = get_network_id_of_js_string network_id in\n let tx =\n Zkapp_command.of_json @@ Yojson.Safe.from_string @@ Js.to_string tx_json\n in\n let get_account_updates_hash xs =\n let hash_account_update (p : Account_update.t) =\n Zkapp_command.Digest.Account_update.create ~chain p\n in\n Zkapp_command.Call_forest.accumulate_hashes ~hash_account_update xs\n in\n let commitment =\n let account_updates_hash =\n Zkapp_command.Call_forest.hash\n (get_account_updates_hash tx.account_updates)\n in\n Zkapp_command.Transaction_commitment.create ~account_updates_hash\n in\n let fee_payer = Account_update.of_fee_payer tx.fee_payer in\n let fee_payer_hash =\n Zkapp_command.Digest.Account_update.create ~chain fee_payer\n 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_zkapp_command (command : Js.js_string Js.t) =\n let command : Zkapp_command.t =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Zkapp_command.of_json\n in\n Mina_transaction.Transaction_hash.(\n command |> hash_zkapp_command |> to_base58_check |> Js.string)\n\n let hash_payment_v1 (command : Js.js_string Js.t) =\n let command : Signed_command.Stable.V1.t =\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.Stable.V1.t =\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 hashZkAppCommand = hash_zkapp_command\n\n val examplePayment = example_payment\n end\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","open! Import\n\nlet to_string _ = `Deprecated_use_Exn_to_string_instead\nlet print _ = `Deprecated_use_Exn_to_string_instead\nlet catch _ _ = `Deprecated_use_Exn_handle_uncaught_instead\nlet print_backtrace = Caml.Printexc.print_backtrace\nlet get_backtrace = Caml.Printexc.get_backtrace\nlet record_backtrace = Caml.Printexc.record_backtrace\nlet backtrace_status = Caml.Printexc.backtrace_status\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","(* 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 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","(*\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 Core_kernel\nopen Core_kernel.Hash.Builtin\n\nmodule N16 = struct\n let max_array_len = 16\nend\n\nmodule N4000 = struct\n let max_array_len = 4000\nend\n\nmodule ArrayN (N : sig\n val max_array_len : int\nend) =\nstruct\n module Stable = struct\n module V1 = struct\n type 'a t = 'a array [@@deriving sexp, yojson, bin_io]\n\n let __versioned__ = ()\n\n let hash_fold_t = hash_fold_array_frozen\n\n [%%define_locally Core_kernel.Array.(compare, equal)]\n\n let to_latest s = s\n\n let bin_shape_t bin_shape_elt =\n Bin_prot.Shape.basetype\n (Bin_prot.Shape.Uuid.of_string \"Bounded_types.Array.t\")\n [ bin_shape_elt ]\n\n let bin_write_t bin_write_el buf ~pos a =\n if Array.length a > N.max_array_len then\n failwithf \"Exceeded array maximum size (max %d < got %d)\"\n N.max_array_len (Array.length a) () ;\n bin_write_array bin_write_el buf ~pos a\n\n let bin_read_t bin_read_el buf ~pos_ref =\n let pos = !pos_ref in\n let len = (Bin_prot.Read.bin_read_nat0 buf ~pos_ref :> int) in\n if len > N.max_array_len then\n Bin_prot.Common.raise_read_error\n Bin_prot.Common.ReadError.Array_too_long !pos_ref\n else (\n pos_ref := pos ;\n bin_read_array bin_read_el buf ~pos_ref )\n end\n end\n\n type 'a t = 'a Stable.V1.t\n\n [%%define_locally\n Stable.V1.\n (compare, equal, hash_fold_t, sexp_of_t, t_of_sexp, to_yojson, of_yojson)]\nend\n\nmodule String = struct\n let max_string_len = 100_000_000\n\n module Stable = struct\n module V1 = struct\n type t = string [@@deriving sexp, yojson, bin_io]\n\n let __versioned__ = ()\n\n let to_latest s = s\n\n [%%define_locally Core_kernel.String.(compare, equal)]\n\n let hash = hash_string\n\n let hash_fold_t = hash_fold_string\n\n let bin_shape_t =\n Bin_prot.Shape.basetype\n (Bin_prot.Shape.Uuid.of_string \"Bounded_types.String.t\")\n []\n\n let bin_write_t buf ~pos s =\n if String.length s > max_string_len then\n failwith \"Exceeded string maximum size\" ;\n bin_write_string buf ~pos s\n\n let bin_read_t buf ~pos_ref =\n let pos = !pos_ref in\n let len = (Bin_prot.Read.bin_read_nat0 buf ~pos_ref :> int) in\n if len > max_string_len then\n Bin_prot.Common.raise_read_error\n Bin_prot.Common.ReadError.Array_too_long !pos_ref\n else (\n pos_ref := pos ;\n bin_read_string buf ~pos_ref )\n end\n end\n\n type t = Stable.V1.t\n\n [%%define_locally\n Stable.V1.\n ( compare\n , equal\n , hash\n , hash_fold_t\n , sexp_of_t\n , t_of_sexp\n , to_yojson\n , of_yojson )]\n\n module Tagged = struct\n module Stable = struct\n module V1 = struct\n include Stable.V1\n\n (* because this is replacing a primitive,\n there is no actual version tag handling\n needed (and in fact, that will make a\n test in transaction fail *)\n module With_all_version_tags = Stable.V1\n end\n end\n\n include Stable.V1\n end\n\n module Of_stringable (M : Stringable.S) =\n Bin_prot.Utils.Make_binable_without_uuid (struct\n module Binable = Stable.V1\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 = try M.of_string s with x -> raise (Of_binable (s, x))\n end)\nend\n\nmodule Wrapped_error = struct\n module Stable = struct\n module V1 = struct\n type t = Core_kernel.Error.Stable.V2.t [@@deriving sexp]\n\n let __versioned__ = ()\n\n let to_latest = Core_kernel.Fn.id\n\n include String.Of_stringable (struct\n type nonrec t = t\n\n let to_string (s : t) =\n Core_kernel.Error.sexp_of_t s |> Core_kernel.Sexp.to_string_mach\n\n let of_string s =\n Core_kernel.Error.t_of_sexp (Core_kernel.Sexp.of_string s)\n end)\n end\n end\n\n type t = Stable.V1.t\nend\n\nmodule ArrayN16 = ArrayN (N16)\nmodule ArrayN4000 = ArrayN (N4000)\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, 'n) t = ('a, 'n) Mina_wire_types.Pickles_types.Vector.t =\n | [] : ('a, z) t\n | ( :: ) : '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! 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 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\n\n val verification_key_perm_fallback_to_signature_with_older_version : t -> t\nend\n\nmodule type Txn_version_intf = sig\n include Iffable\n\n val equal_to_current : t -> bool\n\n val older_than_current : 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 type txn_version\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_auth : t -> controller\n\n val set_verification_key_txn_version : t -> txn_version\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 Txn_version : Txn_version_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 Permissions.txn_version := Txn_version.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 older_than_current_version =\n Txn_version.older_than_current\n (Account.Permissions.set_verification_key_txn_version a)\n in\n let original_auth = Account.Permissions.set_verification_key_auth a in\n let auth =\n Controller.if_ older_than_current_version\n ~then_:\n (Controller\n .verification_key_perm_fallback_to_signature_with_older_version\n original_auth )\n ~else_:original_auth\n in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies auth\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","(* 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","(* 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 print_rust : t -> unit = \"caml_pasta_fp_print_rust\"\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 print_rust : t -> unit = \"caml_pasta_fq_print_rust\"\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","(* 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.lookup_table array\n -> Pasta_bindings.Fp.t Kimchi_types.runtime_table_cfg array\n -> int\n -> SRS.Fp.t\n -> t\n = \"caml_pasta_fp_plonk_index_create_bytecode\" \"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.lookup_table array\n -> Pasta_bindings.Fq.t Kimchi_types.runtime_table_cfg array\n -> int\n -> SRS.Fq.t\n -> t\n = \"caml_pasta_fq_plonk_index_create_bytecode\" \"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_no_public\"\n\n external create_with_public_evals :\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.proof_with_public\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_no_public\"\n\n external create_with_public_evals :\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.proof_with_public\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 Kimchi_types.runtime_table 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.proof_with_public = \"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 Kimchi_types.runtime_table 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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public = \"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.proof_with_public\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.proof_with_public\n = \"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 Kimchi_types.runtime_table 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.proof_with_public = \"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.proof_with_public\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.proof_with_public\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.proof_with_public = \"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.proof_with_public\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.proof_with_public\n = \"caml_pasta_fq_plonk_proof_deep_copy\"\n end\n end\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 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 : 'bool Pickles_types.Plonk_types.Features.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 type 'a columns_vec = ('a, Pickles_types.Nat.fifteen) Pickles_types.Vector.t\n\n type 'a quotient_polynomial_vec =\n ('a, Pickles_types.Nat.seven) Pickles_types.Vector.t\n\n type 'a permuts_minus_1_vec =\n ('a, Pickles_types.Nat.six) Pickles_types.Vector.t\n\n module Commitments = struct\n module V1 = struct\n type t =\n { w_comm : (Pasta_bindings.Fp.t * Pasta_bindings.Fp.t) columns_vec\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\n }\n end\n end\n\n module Evaluations = struct\n module V1 = struct\n type t =\n { w : (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t) columns_vec\n ; coefficients :\n (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t) columns_vec\n ; z : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; s : (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t) permuts_minus_1_vec\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.V1.t\n }\n end\n end\n\n module Proof = struct\n type challenge_constant =\n Pickles_types.Nat.two Pickles_limb_vector.Constant.t\n\n type tock_affine = Pasta_bindings.Fp.t * Pasta_bindings.Fp.t\n\n type 'a step_bp_vec = ('a, Pickles_types.Nat.sixteen) Pickles_types.Vector.t\n\n module Base = struct\n module Wrap = struct\n module V2 = struct\n type digest_constant =\n Pickles_types.Nat.four Pickles_limb_vector.Constant.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\n Pickles_types.Shifted_value.Type1.V1.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.V1.t\n (* A job half-done may be worse than not done at all.\n TODO: Migrate Plonk_types here, and actually include the\n *wire* type, not this in-memory version.\n *)\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.two, Pickles_types.Nat.two) 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 = struct\n type n = Pickles_types.Nat.two\n end\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.two, Pickles_types.Nat.two) t\n end\n end\n end\n\n module Side_loaded : sig\n module Verification_key : sig\n module Max_width : sig\n type n = Pickles_types.Nat.two\n end\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","open Utils\n\nmodule Types = struct\n module type S = sig\n module Digest : V1S0\n\n include V2S0\n end\nend\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\nmodule M = struct\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\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 Txn_version = 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","module 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","open Utils\n\nmodule Types = struct\n module type S = V2S0\nend\n\nmodule type Concrete = sig\n module V2 : sig\n type t = { transaction : int; network : int; patch : int }\n end\nend\n\nmodule M = struct\n module V2 = struct\n type t = { transaction : int; network : int; patch : int }\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! 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","(**************************************************************************)\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\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","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","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","open Core_kernel\nopen Async_kernel\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\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 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","(* bits.ml *)\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\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","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","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 -> 'a req -> 'a option =\n fun stack0 req0 ->\n let rec go req = function\n | [] ->\n None\n | { handle } :: hs -> (\n match handle req with\n | Provide x ->\n Some 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 tbl (handler : Request.Handler.t) =\n match t with\n | Request rc ->\n let r = run rc tbl in\n Request.Handler.run handler r\n | Compute c ->\n Some (run c tbl)\n | Both (rc, c) -> (\n let r = run rc tbl in\n match Request.Handler.run handler r with\n | None | (exception _) ->\n Some (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\nlet id = ref 0\n\n(** The internal state used to run a checked computation. *)\ntype 'field t =\n { id : int\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 let my_id = !id in\n incr id ;\n { id = my_id\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 id { id; _ } = id\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 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 id = Run_state.id state in\n let state, x = run t0 state in\n let final_id = Run_state.id state in\n if id <> final_id then\n failwith \"Snarky's internal state has been clobbered.\" ;\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 id = Run_state.id state in\n let res = run t0 state in\n map res ~f:(function state, x ->\n let final_id = Run_state.id state in\n if id <> final_id then\n failwith \"Snarky's internal state has been clobbered.\" ;\n (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 let id = Run_state.id state in\n let state, x = run t0 state in\n let final_id = Run_state.id state in\n if id <> final_id then\n failwith \"Snarky's internal state has been clobbered.\" ;\n 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 module Constraint_system_builder : sig\n type ('input_var, 'return_var, 'field, 'checked) t =\n { run_computation : 'a. ('input_var -> 'field Run_state.t -> 'a) -> 'a\n ; finish_computation :\n 'field Run_state.t * 'return_var -> R1CS_constraint_system.t\n }\n\n val build :\n input_typ:\n ( 'input_var\n , 'input_value\n , field\n , (unit, field) Checked.Types.Checked.t )\n Types0.Typ.typ\n -> return_typ:\n ( 'retvar\n , 'retval\n , field\n , (unit, field) Checked.Types.Checked.t )\n Types0.Typ.typ\n -> ('input_var, 'retvar, field, 'checked) t\n end = struct\n let allocate_public_inputs :\n type input_var input_value output_var output_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:\n ( output_var\n , output_value\n , field\n , (unit, field) Checked.Types.Checked.t )\n Types.Typ.t\n -> input_var * output_var =\n fun next_input ~input_typ:(Typ input_typ) ~return_typ:(Typ return_typ) ->\n (* allocate variables for the public input and the public output *)\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 (var, retval)\n\n type ('input_var, 'return_var, 'field, 'checked) t =\n { run_computation : 'a. ('input_var -> 'field Run_state.t -> 'a) -> 'a\n ; finish_computation :\n 'field Run_state.t * 'return_var -> R1CS_constraint_system.t\n }\n\n let build :\n type checked input_var input_value retvar retval.\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:(retvar, retval, _, _) Types.Typ.t\n -> (input_var, retvar, field, checked) t =\n fun ~input_typ ~return_typ ->\n let next_input = ref 0 in\n (* allocate variables for the public input and the public output *)\n let var, retvar =\n allocate_public_inputs next_input ~input_typ ~return_typ\n in\n let (Typ return_typ) = return_typ in\n let num_inputs = !next_input in\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 id = Run_state.id state in\n let state, () =\n (* create constraints to validate the input (using the input [Typ]'s [check]) *)\n let checked =\n let (Typ input_typ) = input_typ in\n input_typ.check var\n in\n Checked.run checked state\n in\n let run_computation k = k var state in\n let finish_computation (state, res) =\n let final_id = Run_state.id state in\n if id <> final_id then\n failwith \"Snarky's internal state has been clobbered.\" ;\n let res, _ = return_typ.var_to_fields res in\n let retvar, _ = return_typ.var_to_fields retvar in\n let _state =\n Array.fold2_exn ~init:state res retvar ~f:(fun state res retvar ->\n fst @@ Checked.run (Checked.assert_equal res retvar) state )\n in\n let auxiliary_input_size = !next_auxiliary - num_inputs in\n R1CS_constraint_system.set_auxiliary_input_size system\n auxiliary_input_size ;\n system\n in\n { run_computation; finish_computation }\n end\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 let builder = Constraint_system_builder.build ~input_typ ~return_typ in\n let state, res =\n builder.run_computation (fun var state -> run (k var) state)\n in\n builder.finish_computation (state, res)\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 module Conv = struct\n type ('input_var, 'output_var) t =\n { input_var : 'input_var\n ; output_var : 'output_var\n ; first_auxiliary : int\n ; primary_input : Field.Vector.t\n }\n\n let receive_public_input :\n ('input_var, 'input_value, _, _) Types.Typ.t\n -> _ Types.Typ.t\n -> 'input_value\n -> _ =\n fun input_typ (Typ return_typ) value ->\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 let fields, aux = value_to_fields value in\n let fields = Array.map ~f:store_field_elt fields in\n let input_var = var_of_fields (fields, aux) in\n let output_var =\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 let first_auxiliary = !next_input in\n { input_var; output_var; first_auxiliary; primary_input }\n end\n\n module Witness_builder = struct\n type ('input_var, 'return_var, 'return_value, 'field, 'checked) t =\n { run_computation : 'a. ('input_var -> 'field Run_state.t -> 'a) -> 'a\n ; finish_witness_generation :\n 'field Run_state.t * 'return_var -> Proof_inputs.t * 'return_value\n }\n\n let auxiliary_input ?(handlers = ([] : Handler.t list)) ~input_typ\n ~return_typ value =\n let { Conv.input_var\n ; output_var = output\n ; first_auxiliary = num_inputs\n ; primary_input = input\n } =\n Conv.receive_public_input input_typ return_typ value\n in\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 ~num_inputs ~input:(pack_field_vec input)\n ~next_auxiliary ~aux:(pack_field_vec aux) ~handler\n ~with_witness:true ()\n in\n let id = Run_state.id state in\n let run_computation t0 = t0 input_var state in\n let finish_witness_generation (state, res) =\n let final_id = Run_state.id state in\n if id <> final_id then\n failwith \"Snarky's internal state has been clobbered.\" ;\n let (Typ return_typ) = return_typ in\n let res_fields, auxiliary_output_data =\n return_typ.var_to_fields res\n in\n let output_fields, _ = return_typ.var_to_fields output in\n let state =\n Array.fold2_exn ~init:state res_fields output_fields\n ~f:(fun state res_field output_field ->\n Field.Vector.emplace_back input\n (Runner.get_value state res_field) ;\n fst\n @@ Checked.run\n (Checked.assert_equal res_field output_field)\n state )\n in\n let true_output =\n (* NB: We use [output_fields] to avoid resolving [Cvar.t]s beyond a\n vector access.\n *)\n let fields = Array.map ~f:(Runner.get_value state) output_fields in\n return_typ.value_of_fields (fields, auxiliary_output_data)\n in\n ( { Proof_inputs.public_inputs = input; auxiliary_inputs = aux }\n , true_output )\n in\n { run_computation; finish_witness_generation }\n end\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 return_typ k0 value ->\n let { Conv.input_var; output_var; first_auxiliary; primary_input } =\n Conv.receive_public_input input_typ return_typ value\n in\n cont0 first_auxiliary output_var (k0 () input_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 value ->\n (* NB: No need to finish witness generation, we'll discard the\n witness and public output anyway.\n *)\n let { Witness_builder.run_computation; finish_witness_generation = _ } =\n Witness_builder.auxiliary_input ?handlers ~input_typ ~return_typ value\n in\n let state, res =\n run_computation (fun input_var state -> run (k input_var) state)\n in\n ignore (state, res)\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 value ->\n let builder =\n Witness_builder.auxiliary_input ?handlers ~input_typ ~return_typ value\n in\n let state, res =\n builder.run_computation (fun input_var state ->\n run (k input_var) state )\n in\n let witness, output = builder.finish_witness_generation (state, res) in\n f witness output\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","type z = Mina_wire_types.Pickles_types.Nat.z = Z of z\n\ntype 'a s = 'a Mina_wire_types.Pickles_types.Nat.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 module Wrap = Nat.N15\n\n module Wrap_vector : Vector.With_version(Wrap).S\n\n module Step = Nat.N16\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\n(* poseidon params *)\n\nlet poseidon_params_fp = Sponge.Params.(map pasta_p_kimchi ~f:Fp.of_string)\n\nlet poseidon_params_fq = Sponge.Params.(map pasta_q_kimchi ~f:Fq.of_string)\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 = Opt\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 = 'bool Lazy.t Plonk_types.Features.Full.t\n\nlet expand_feature_flags (type boolean)\n (module B : Bool_intf with type t = boolean)\n (features : boolean Plonk_types.Features.t) : boolean all_feature_flags =\n features\n |> Plonk_types.Features.map ~f:(fun x -> lazy x)\n |> Plonk_types.Features.to_full\n ~or_:(fun x y -> lazy B.(Lazy.force x ||| Lazy.force y))\n ~any:(fun x -> lazy (B.any (List.map ~f:Lazy.force x)))\n\nlet lookup_tables_used feature_flags =\n let module Bool = struct\n type t = 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.uses_lookups\n\nlet get_feature_flag (feature_flags : _ all_feature_flags)\n (feature : Kimchi_types.feature_flag) =\n let lazy_flag =\n Plonk_types.Features.Full.get_feature_flag feature_flags feature\n in\n Option.map ~f:Lazy.force lazy_flag\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 ~zk_rows ~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 ( omega_to_zk_minus_1\n , omega_to_zk\n , omega_to_intermediate_powers\n , omega_to_zk_plus_1\n , omega_to_minus_1 ) =\n (* generator^{n - 3} *)\n let gen = domain#generator in\n (* gen_inv = gen^{n - 1} = gen^{-1} *)\n let omega_to_minus_1 = one / gen in\n let omega_to_minus_2 = square omega_to_minus_1 in\n let omega_to_intermediate_powers, omega_to_zk_plus_1 =\n let next_term = ref omega_to_minus_2 in\n let omega_to_intermediate_powers =\n Array.init\n Stdlib.(zk_rows - 3)\n ~f:(fun _ ->\n let term = !next_term in\n next_term := term * omega_to_minus_1 ;\n term )\n in\n (omega_to_intermediate_powers, !next_term)\n in\n let omega_to_zk = omega_to_zk_plus_1 * omega_to_minus_1 in\n let omega_to_zk_minus_1 = lazy (omega_to_zk * omega_to_minus_1) in\n ( omega_to_zk_minus_1\n , omega_to_zk\n , omega_to_intermediate_powers\n , omega_to_zk_plus_1\n , omega_to_minus_1 )\n in\n let zk_polynomial =\n (* Vanishing polynomial of\n [omega_to_minus_1, omega_to_zk_plus_1, omega_to_zk]\n evaluated at x = zeta\n *)\n (zeta - omega_to_minus_1)\n * (zeta - omega_to_zk_plus_1)\n * (zeta - omega_to_zk)\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_zk_rows = omega_to_zk\n ; zeta_to_n_minus_1 = domain#vanishing_polynomial zeta\n ; zeta_to_srs_length = lazy (pow2pow (module F) zeta srs_length_log2)\n ; endo_coefficient = endo\n ; mds = (fun (row, col) -> mds.(row).(col))\n ; srs_length_log2\n ; vanishes_on_zero_knowledge_and_previous_rows =\n ( match joint_combiner with\n | None ->\n (* No need to compute anything when not using lookups *)\n F.one\n | Some _ ->\n Array.fold omega_to_intermediate_powers\n ~init:(zk_polynomial * (zeta - Lazy.force omega_to_zk_minus_1))\n ~f:(fun acc omega_pow -> acc * (zeta - omega_pow)) )\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 | false, 0 ->\n one\n | false, 1 ->\n domain#generator\n | false, -1 ->\n omega_to_minus_1\n | false, -2 ->\n omega_to_zk_plus_1\n | false, -3 | true, 0 ->\n omega_to_zk\n | true, -1 ->\n Lazy.force omega_to_zk_minus_1\n | b, i ->\n failwithf \"TODO: unnormalized_lagrange_basis(%b, %i)\" b i ()\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 p_eval0 =\n Option.value_exn\n (Array.fold_right ~init:None p_eval0 ~f:(fun p_eval0 acc ->\n match acc with\n | None ->\n Some p_eval0\n | Some acc ->\n let zeta1 = Lazy.force env.zeta_to_srs_length in\n Some F.(p_eval0 + (zeta1 * acc)) ) )\n 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_zk_rows)\n + (zeta1m1 * alpha_pow Int.(perm_alpha0 + 2) * (zeta - one)) )\n * (one - e0 z)\n in\n let denominator = (zeta - env.omega_to_minus_zk_rows) * (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 = Lazy.force env.zeta_to_srs_length\n ; perm\n ; joint_combiner = Opt.of_option 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 = Opt.to_option_unsafe plonk.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","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 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\nlet combine_split_commitments _t ~scale_and_add ~init:i ~xi\n ~reduce_without_degree_bound ~reduce_with_degree_bound (type n)\n (without_degree_bound : (_, n) Vector.t) with_degree_bound =\n let flat =\n List.concat_map\n (Vector.to_list without_degree_bound)\n ~f:reduce_without_degree_bound\n @ List.concat_map\n (Vector.to_list with_degree_bound)\n ~f:reduce_with_degree_bound\n in\n let rec go = function\n | [] ->\n failwith \"combine_split_commitments: empty\"\n | init :: comms -> (\n match i init with\n | None ->\n go comms\n | Some init ->\n List.fold_left comms ~init ~f:(fun acc p ->\n scale_and_add ~acc ~xi p ) )\n in\n go (List.rev flat)\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","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","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","(* 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 ?commit_id:_ ~id:_ ~processor:_ ~transport:_ = not_implemented\nend\n\ntype t = Metadata.Stable.Latest.t [@@deriving bin_io_unversioned]\n\nlet metadata = Fn.id\n\nlet create ?metadata:_ ?id:_ ?itn_features:_ () = Metadata.empty\n\nlet null () = Metadata.empty\n\nlet extend t _ = t\n\nlet change_id t ~id:_ = t\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\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.Latest.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.Latest.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.Latest.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.Latest.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.Latest.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.Latest.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 failwith\n \"Pickles cannot handle point at infinity. Commitments must \\\n be representable in affine coordinates\"\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 type with_public_evals\n\n module Challenge_polynomial : T0\n\n module Backend : sig\n type t\n\n type with_public_evals\n end\n\n val to_backend :\n Challenge_polynomial.t list -> Field.t list -> t -> Backend.t\n\n val to_backend_with_public_evals :\n Challenge_polynomial.t list\n -> Field.t list\n -> with_public_evals\n -> Backend.with_public_evals\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\n val create_with_public_evals :\n Verifier_index.t -> Proof.Backend.with_public_evals -> 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 let create_with_public_evals vk prev_challenge input\n (pi : Proof.with_public_evals) =\n let pi = Proof.to_backend_with_public_evals prev_challenge input pi in\n Backend.create_with_public_evals 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 :\n t\n -> Gate_vector.t\n * Scalar_field.t Kimchi_types.lookup_table array\n * Scalar_field.t Kimchi_types.runtime_table_cfg array\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.lookup_table array\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, fixed_lookup_tables, runtime_table_cfgs =\n Inputs.Constraint_system.finalize_and_get_gates cs\n 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 let index =\n Inputs.Index.create gates public_input_size fixed_lookup_tables\n runtime_table_cfgs 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 }\n\n let full_vk_commitments (t : Inputs.Verifier_index.t) :\n ( Inputs.Curve.Affine.t array\n , Inputs.Curve.Affine.t array option )\n Pickles_types.Plonk_verification_key_evals.Step.t =\n let g c : Inputs.Curve.Affine.t array =\n match Inputs.Poly_comm.of_backend_without_degree_bound c with\n | `Without_degree_bound x ->\n x\n | `With_degree_bound _ ->\n assert false\n in\n let lookup f =\n let open Option.Let_syntax in\n let%bind l = t.lookup_index in\n f l >>| g\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 ; xor_comm = Option.map ~f:g t.evals.xor_comm\n ; range_check0_comm = Option.map ~f:g t.evals.range_check0_comm\n ; range_check1_comm = Option.map ~f:g t.evals.range_check1_comm\n ; foreign_field_add_comm = Option.map ~f:g t.evals.foreign_field_add_comm\n ; foreign_field_mul_comm = Option.map ~f:g t.evals.foreign_field_mul_comm\n ; rot_comm = Option.map ~f:g t.evals.rot_comm\n ; lookup_table_comm =\n Pickles_types.Vector.init\n Pickles_types.Plonk_types.Lookup_sorted_minus_1.n ~f:(fun i ->\n lookup (fun l -> Option.try_with (fun () -> l.lookup_table.(i))) )\n ; lookup_table_ids = lookup (fun l -> l.table_ids)\n ; runtime_tables_selector = lookup (fun l -> l.runtime_tables_selector)\n ; lookup_selector_lookup = lookup (fun l -> l.lookup_selectors.lookup)\n ; lookup_selector_xor = lookup (fun l -> l.lookup_selectors.xor)\n ; lookup_selector_range_check =\n lookup (fun l -> l.lookup_selectors.range_check)\n ; lookup_selector_ffmul = lookup (fun l -> l.lookup_selectors.ffmul)\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 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\nmodule Run_state = Snarky_backendless.Run_state\n\ntype field = Impl.field\n\n(* light-weight wrapper around snarky-ml core *)\n\nlet empty_typ : (_, _, unit, field, _) Impl.Internal_Basic.Typ.typ' =\n { var_to_fields = (fun fields -> (fields, ()))\n ; var_of_fields = (fun (fields, _) -> fields)\n ; value_to_fields = (fun fields -> (fields, ()))\n ; value_of_fields = (fun (fields, _) -> fields)\n ; size_in_field_elements = 0\n ; constraint_system_auxiliary = (fun _ -> ())\n ; check = (fun _ -> Impl.Internal_Basic.Checked.return ())\n }\n\nlet typ (size_in_field_elements : int) : (Field.t array, field array) Typ.t =\n Typ { empty_typ with size_in_field_elements }\n\nmodule Run = struct\n let exists (size_in_fields : int) (compute : unit -> Field.Constant.t array) =\n Impl.exists (typ size_in_fields) ~compute\n\n let exists_one (compute : unit -> Field.Constant.t) =\n Impl.exists Field.typ ~compute\n\n let in_prover () = Impl.in_prover ()\n\n let as_prover = Impl.as_prover\n\n let in_prover_block () = As_prover.in_prover_block () |> Js.bool\n\n let set_eval_constraints b = Snarky_backendless.Snark0.set_eval_constraints b\n\n let enter_constraint_system () =\n let builder =\n Impl.constraint_system_manual ~input_typ:Impl.Typ.unit\n ~return_typ:Impl.Typ.unit\n in\n builder.run_circuit (fun () () -> ()) ;\n builder.finish_computation\n\n let enter_generate_witness () =\n let builder =\n Impl.generate_witness_manual ~input_typ:Impl.Typ.unit\n ~return_typ:Impl.Typ.unit ()\n in\n builder.run_circuit (fun () () -> ()) ;\n let finish () = builder.finish_computation () |> fst in\n finish\n\n let enter_as_prover size = Impl.as_prover_manual size |> Staged.unstage\n\n module State = struct\n let alloc_var state = Run_state.alloc_var state ()\n\n let store_field_elt state x = Run_state.store_field_elt state x\n\n let as_prover state = Run_state.as_prover state\n\n let set_as_prover state b = Run_state.set_as_prover state b\n\n let has_witness state = Run_state.has_witness state\n\n let get_variable_value state i = Run_state.get_variable_value state i\n end\nend\n\nmodule Constraint_system = struct\n let rows cs = Backend.R1CS_constraint_system.get_rows_len cs\n\n let digest cs =\n Backend.R1CS_constraint_system.digest cs |> Md5.to_hex |> Js.string\n\n let to_json cs =\n Backend.R1CS_constraint_system.to_json cs |> Js.string |> Util.json_parse\nend\n\nmodule Field' = struct\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 (** 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\nend\n\nlet add_gate (label : string) gate =\n Impl.with_label label (fun () ->\n Impl.assert_\n { annotation = None\n ; basic =\n Kimchi_backend_common.Plonk_constraint_system.Plonk_constraint.T\n gate\n } )\n\nmodule Gates = struct\n let zero in1 in2 out =\n add_gate \"zero\"\n (Raw { kind = Zero; values = [| in1; in2; out |]; coeffs = [||] })\n\n let generic sl l sr r so o sm sc =\n add_gate \"generic\"\n (Basic { l = (sl, l); r = (sr, r); o = (so, o); m = sm; c = sc })\n\n let poseidon state = add_gate \"poseidon\" (Poseidon { state })\n\n let ec_add p1 p2 p3 inf same_x slope inf_z x21_inv =\n add_gate \"ec_add\"\n (EC_add_complete { p1; p2; p3; inf; same_x; slope; inf_z; x21_inv }) ;\n (* TODO: do we need this? *)\n p3\n\n let ec_scale state = add_gate \"ec_scale\" (EC_scale { state })\n\n let ec_endoscale state xs ys n_acc =\n add_gate \"ec_endoscale\" (EC_endoscale { state; xs; ys; n_acc })\n\n let ec_endoscalar state = add_gate \"ec_endoscalar\" (EC_endoscalar { state })\n\n let lookup (w0, w1, w2, w3, w4, w5, w6) =\n add_gate \"lookup\" (Lookup { w0; w1; w2; w3; w4; w5; w6 })\n\n let range_check0 v0 (v0p0, v0p1, v0p2, v0p3, v0p4, v0p5)\n (v0c0, v0c1, v0c2, v0c3, v0c4, v0c5, v0c6, v0c7) compact =\n add_gate \"range_check0\"\n (RangeCheck0\n { (* Current row *) 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 ; (* Coefficients *)\n compact\n } )\n\n let range_check1 v2 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 ( 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 add_gate \"range_check1\"\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 let xor in1 in2 out in1_0 in1_1 in1_2 in1_3 in2_0 in2_1 in2_2 in2_3 out_0\n out_1 out_2 out_3 =\n add_gate \"xor\"\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\n let foreign_field_add (left_input_lo, left_input_mi, left_input_hi)\n (right_input_lo, right_input_mi, right_input_hi) field_overflow carry\n (foreign_field_modulus0, foreign_field_modulus1, foreign_field_modulus2)\n sign =\n add_gate \"foreign_field_add\"\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 ; foreign_field_modulus0\n ; foreign_field_modulus1\n ; foreign_field_modulus2\n ; sign\n } )\n\n let foreign_field_mul (left_input0, left_input1, left_input2)\n (right_input0, right_input1, right_input2) (remainder01, remainder2)\n (quotient0, quotient1, quotient2) quotient_hi_bound\n (product1_lo, product1_hi_0, product1_hi_1) carry0\n ( carry1_0\n , carry1_12\n , carry1_24\n , carry1_36\n , carry1_48\n , carry1_60\n , carry1_72 ) (carry1_84, carry1_86, carry1_88, carry1_90)\n foreign_field_modulus2\n ( neg_foreign_field_modulus0\n , neg_foreign_field_modulus1\n , neg_foreign_field_modulus2 ) =\n add_gate \"foreign_field_mul\"\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 ; foreign_field_modulus2\n ; neg_foreign_field_modulus0\n ; neg_foreign_field_modulus1\n ; neg_foreign_field_modulus2\n } )\n\n let rotate word rotated excess\n (bound_limb0, bound_limb1, bound_limb2, 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 ) two_to_rot =\n add_gate \"rot64\"\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 (* Coefficients *)\n ; two_to_rot (* Rotation scalar 2^rot *)\n } )\n\n let add_fixed_lookup_table id data =\n add_gate \"add_fixed_lookup_table\" (AddFixedLookupTable { id; data })\n\n let add_runtime_table_config id first_column =\n add_gate \"add_runtime_table_config\" (AddRuntimeTableCfg { id; first_column })\n\n let raw kind values coeffs = add_gate \"raw\" (Raw { kind; values; coeffs })\nend\n\nmodule Group = struct\n let scale_fast_unpack (base : Field.t * Field.t)\n (scalar : Field.t Pickles_types.Shifted_value.Type1.t) num_bits :\n (Field.t * Field.t) * Boolean.var array =\n Pickles.Step_main_inputs.Ops.scale_fast_unpack base scalar ~num_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 = Kimchi_pasta_basic.poseidon_params_fp\n\n let sponge_params_checked = Sponge.Params.map sponge_params ~f:Field.constant\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 val run =\n let open Run in\n object%js\n method exists = exists\n\n method existsOne = exists_one\n\n val inProver = in_prover\n\n method asProver = as_prover\n\n val inProverBlock = in_prover_block\n\n val setEvalConstraints = set_eval_constraints\n\n val enterConstraintSystem = enter_constraint_system\n\n val enterGenerateWitness = enter_generate_witness\n\n val enterAsProver = enter_as_prover\n\n val state =\n object%js\n val allocVar = State.alloc_var\n\n val storeFieldElt = State.store_field_elt\n\n val asProver = State.as_prover\n\n val setAsProver = State.set_as_prover\n\n val hasWitness = State.has_witness\n\n val getVariableValue = State.get_variable_value\n end\n end\n\n val constraintSystem =\n object%js\n method rows = Constraint_system.rows\n\n method digest = Constraint_system.digest\n\n method toJson = Constraint_system.to_json\n end\n\n val field =\n let open Field' in\n object%js\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 truncateToBits16 = truncate_to_bits16\n end\n\n val gates =\n object%js\n method zero = Gates.zero\n\n method generic = Gates.generic\n\n method poseidon = Gates.poseidon\n\n method ecAdd = Gates.ec_add\n\n method ecScale = Gates.ec_scale\n\n method ecEndoscale = Gates.ec_endoscale\n\n method ecEndoscalar = Gates.ec_endoscalar\n\n method lookup = Gates.lookup\n\n method rangeCheck0 = Gates.range_check0\n\n method rangeCheck1 = Gates.range_check1\n\n method xor = Gates.xor\n\n method foreignFieldAdd = Gates.foreign_field_add\n\n method foreignFieldMul = Gates.foreign_field_mul\n\n method rotate = Gates.rotate\n\n method addFixedLookupTable = Gates.add_fixed_lookup_table\n\n method addRuntimeTableConfig = Gates.add_runtime_table_config\n\n method raw = Gates.raw\n end\n\n val group =\n object%js\n val scaleFastUnpack = Group.scale_fast_unpack\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 -> Import.Types.Digest.Constant.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","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 = poseidon_params_fp\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 = poseidon_params_fq\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","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-ro.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 : Pickles_types.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 : Opt.Flag.t\n ; dummy1 : 'a1\n ; dummy2 : 'a2\n ; bool : (module Bool_intf with type var = 'bool)\n }\n -> ('a1 option, ('a2, 'bool) Opt.t, 'env) t\n | Opt_unflagged :\n { inner : ('a1, 'a2, (< bool1 : bool ; bool2 : 'bool ; .. > as 'env)) t\n ; flag : 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 | Nothing ->\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 | Just 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 Opt.constant_layout_typ bool flag ~dummy:dummy1 ~dummy_var:dummy2 ~true_\n ~false_ (typ t inner)\n | Opt_unflagged { inner; flag; dummy1; dummy2 } -> (\n match flag with\n | 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 | 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 : _ Opt.t) : _ Opt.t =\n match x with\n | Nothing ->\n Opt.nothing\n | Just x ->\n Opt.just (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 ( Opt.constant_layout_typ ~dummy:dummy1 ~dummy_var:(f_a' dummy2)\n ~true_:(f_bool' B.true_) ~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(* original mainnet transaction hashes *)\nlet v1_transaction_hash : t = '\\x12'\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","(* 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 if not (Char.equal decoded.[0] version_byte) then\n raise (Invalid_base58_version_byte (decoded.[0], 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 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","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","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_exn 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) ->\n Array.concat_map x ~f:(fun x -> 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 ~feature_flags prev_statement =\n let input =\n let (T (typ, _conv, _conv_inv)) = Impls.Wrap.input ~feature_flags () 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 ~feature_flags s =\n tock_unpadded_public_input_of_statement ~feature_flags s\n\nlet tick_public_input_of_statement ~max_proofs_verified\n (prev_statement : _ Impls.Step.statement) =\n let input =\n let (T (input, _conv, _conv_inv)) =\n Impls.Step.input ~proofs_verified:max_proofs_verified\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 ~negate\n ~verification_key:(m : _ array Plonk_verification_key_evals.t)\n ~(plonk : _ Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t)\n ~t_comm =\n let reduce_chunks comm =\n let n = Array.length comm in\n let res = ref comm.(n - 1) in\n for i = n - 2 downto 0 do\n res := comm.(i) + scale !res plonk.zeta_to_srs_length\n done ;\n !res\n 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 sigma_comm_last = reduce_chunks sigma_comm_last in\n let f_comm = List.reduce_exn ~f:( + ) [ scale sigma_comm_last plonk.perm ] in\n let chunked_t_comm = reduce_chunks t_comm 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) Opt.t) : Field.t =\n match fx with\n | Nothing ->\n acc\n | Just 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 | Just x ->\n x\n | Nothing ->\n Field.zero\n | Maybe (b, x) ->\n (b :> Field.t) * x )\n ~xi without_degree_bound )\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 lazy\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 =\n forbidden_shifted_values ~size_in_bits ~modulus:other_mod\n 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 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 (Lazy.force 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 type unfinalized_proof =\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 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 type 'proofs_verified statement =\n ( (unfinalized_proof, 'proofs_verified) Pickles_types.Vector.t\n , Import.Types.Digest.Constant.t\n , (Import.Types.Digest.Constant.t, 'proofs_verified) Pickles_types.Vector.t\n )\n Import.Types.Step.Statement.t\n\n type unfinalized_proof_var =\n ( Field.t\n , Field.t Scalar_challenge.t\n , Other_field.t Shifted_value.Type2.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\n type 'proofs_verified statement_var =\n ( (unfinalized_proof_var, 'proofs_verified) Pickles_types.Vector.t\n , Impl.field Snarky_backendless.Cvar.t\n , ( Impl.field Snarky_backendless.Cvar.t\n , 'proofs_verified )\n Pickles_types.Vector.t )\n Import.Types.Step.Statement.t\n\n let input ~proofs_verified =\n let open Types.Step.Statement in\n let spec = spec proofs_verified Tock.Rounds.n 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))\n\n module Async_promise = Async_generic (Promise)\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 lazy\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 =\n forbidden_shifted_values ~size_in_bits ~modulus:other_mod\n 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 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 (Lazy.force 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 ~feature_flags:\n ({ Plonk_types.Features.Full.uses_lookups; _ } as feature_flags) () =\n let feature_flags = Plonk_types.Features.of_full feature_flags in\n let lookup =\n { Types.Wrap.Lookup_parameters.use = uses_lookups\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 (In_circuit.spec (module Impl) lookup feature_flags)\n in\n let typ =\n Typ.transport typ\n ~there:(In_circuit.to_data ~option_map:Option.map)\n ~back:(In_circuit.of_data ~option_map:Option.map)\n in\n Spec.ETyp.T\n ( typ\n , (fun x -> In_circuit.of_data ~option_map:Opt.map (f x))\n , fun x -> f_inv (In_circuit.to_data ~option_map:Opt.map x) )\nend\n","include Make_sponge.Make (Backend.Tick.Field)\n\nlet params = Kimchi_pasta_basic.poseidon_params_fp\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 lazy\n (let open Plonk_types in\n let e =\n Evals.map Evaluation_lengths.default ~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 lazy\n (Plonk_types.All_evals.map (Lazy.force 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 lazy\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 lazy\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 ~num_chunks ~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 array\n , Wrap_main_inputs.Inner_curve.Constant.t array option )\n Wrap_verifier.index'\n , branches )\n Vector.t\n Promise.t\n Lazy.t ) (step_widths : (int, branches) Vector.t)\n (step_domains : (Domains.t, branches) Vector.t Promise.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 Promise.t\n Lazy.t =\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 let%map.Lazy step_keys = step_keys in\n let%bind.Promise step_domains = step_domains in\n let%map.Promise step_keys = step_keys in\n fun ({ 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 =\n 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 = 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\n Nat.N2.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 ~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 step_keys\n ~f:\n (Plonk_verification_key_evals.Step.map\n ~f:(Array.map ~f:Inner_curve.constant)\n ~f_opt:(function\n | None ->\n Opt.nothing\n | Some x ->\n Opt.just (Array.map ~f:Inner_curve.constant x) ) ) ) )\n in\n let () =\n (* Check consistency between index and feature flags. *)\n let { Plonk_verification_key_evals.Step.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 ; xor_comm\n ; range_check0_comm\n ; range_check1_comm\n ; foreign_field_add_comm\n ; foreign_field_mul_comm\n ; rot_comm\n ; lookup_table_comm =\n [ lookup_table_comm0\n ; lookup_table_comm1\n ; lookup_table_comm2\n ; lookup_table_comm3\n ]\n ; lookup_table_ids =\n _ (* Unconstrained, doesn't affect the flags. *)\n ; runtime_tables_selector\n ; lookup_selector_lookup\n ; lookup_selector_xor\n ; lookup_selector_range_check\n ; lookup_selector_ffmul\n } =\n step_plonk_index\n in\n let { Plonk_types.Features.Full.range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n ; uses_lookups\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 } =\n Plonk_checks.expand_feature_flags\n ( module struct\n type t = Boolean.var\n\n include Boolean\n end )\n plonk.feature_flags\n in\n let commitment_flag = function\n | Opt.Just _ ->\n Boolean.true_\n | Opt.Maybe (b, _) ->\n b\n | Opt.Nothing ->\n Boolean.false_\n in\n let assert_consistent comm flag =\n Boolean.Assert.( = ) (commitment_flag comm) (Lazy.force flag)\n in\n assert_consistent xor_comm xor ;\n assert_consistent range_check0_comm range_check0 ;\n assert_consistent range_check1_comm range_check1 ;\n assert_consistent foreign_field_add_comm foreign_field_add ;\n assert_consistent foreign_field_mul_comm foreign_field_mul ;\n assert_consistent rot_comm rot ;\n assert_consistent lookup_table_comm0 table_width_at_least_1 ;\n assert_consistent lookup_table_comm1 table_width_at_least_2 ;\n assert_consistent lookup_table_comm2 table_width_3 ;\n assert_consistent lookup_table_comm3 (lazy Boolean.false_) ;\n assert_consistent runtime_tables_selector runtime_tables ;\n assert_consistent lookup_selector_lookup lookup ;\n assert_consistent lookup_selector_xor lookup_pattern_xor ;\n assert_consistent lookup_selector_range_check\n lookup_pattern_range_check ;\n assert_consistent lookup_selector_ffmul foreign_field_mul\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 () ->\n 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\n (module Impl)\n ~num_chunks:1 Plonk_types.Features.Full.none\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:\n (wrap_domain :> _ Plonk_checks.plonk_domain)\n ~sponge ~old_bulletproof_challenges\n deferred_values 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 Field.Assert.equal messages_for_next_step_proof\n prev_proof_state.messages_for_next_step_proof ;\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 =\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.default ~num_chunks) )\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 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 ; mutable 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 cond_permute ~params ~permute state =\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\n let consume_pairs ~params ~state ~pos:start_pos pairs =\n Array.fold ~init:start_pos pairs ~f:(fun p ((b, x), (b', y)) ->\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 p' = Boolean.( lxor ) p b in\n let pos_after = Boolean.( lxor ) p' b' in\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 ~params ~permute state ;\n add_in state p' Field.(y * (add_in_y_after_perm :> t)) ;\n pos_after )\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 num_pairs = n / 2 in\n let remaining = n - (2 * num_pairs) in\n let pairs =\n Array.init num_pairs ~f:(fun i -> (input.(2 * i), input.((2 * i) + 1)))\n in\n let pos = consume_pairs ~params ~state ~pos:start_pos pairs in\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 let pos_after = Boolean.( lxor ) p b in\n ignore (pos_after : Boolean.var) ;\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 ~params ~permute:should_permute state\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.needs_final_permute_if_empty <- true ;\n t.sponge_state <- Squeezed 1 ;\n t.state.(0)\n\n let consume_all_pending (t : t) =\n match t.sponge_state with\n | Squeezed _ ->\n failwith \"Nothing pending\"\n | Absorbing { next_index; xs } ->\n let input = Array.of_list_rev xs in\n assert (Array.length t.state = m) ;\n let n = Array.length input in\n let num_pairs = n / 2 in\n let remaining = n - (2 * num_pairs) in\n let pairs =\n Array.init num_pairs ~f:(fun i ->\n (input.(2 * i), input.((2 * i) + 1)) )\n in\n let pos =\n consume_pairs ~params:t.params ~state:t.state ~pos:next_index pairs\n in\n let pos_after =\n if remaining = 1 then (\n let b, x = input.(n - 1) in\n let p = pos in\n let pos_after = Boolean.( lxor ) p b in\n add_in t.state p Field.(x * (b :> t)) ;\n pos_after )\n else pos\n in\n (* TODO: We should propagate the emptiness state of the pairs,\n otherwise this will break in some edge cases.\n *)\n t.sponge_state <- Absorbing { next_index = pos_after; xs = [] }\n\n let recombine ~original_sponge b (t : t) =\n match[@warning \"-4\"] (original_sponge.sponge_state, t.sponge_state) with\n | Squeezed orig_i, Squeezed curr_i ->\n if orig_i <> curr_i then failwithf \"Squeezed %i vs %i\" orig_i curr_i () ;\n Array.iteri original_sponge.state ~f:(fun i x ->\n t.state.(i) <- Field.if_ b ~then_:t.state.(i) ~else_:x )\n | ( Absorbing { next_index = next_index_orig; xs = xs_orig }\n , Absorbing { next_index = next_index_curr; xs = xs_curr } ) ->\n (* TODO: Should test for full equality here, if we want to catch all\n sponge misuses.\n OTOH, if you're using this sponge then you'd better know what it's\n doing..\n *)\n if List.length xs_orig <> List.length xs_curr then\n failwithf \"Pending absorptions %i vs %i\" (List.length xs_orig)\n (List.length xs_curr) () ;\n Array.iteri original_sponge.state ~f:(fun i x ->\n t.state.(i) <- Field.if_ b ~then_:t.state.(i) ~else_:x ) ;\n t.sponge_state <-\n Absorbing\n { next_index =\n Boolean.if_ b ~then_:next_index_curr ~else_:next_index_orig\n ; xs = xs_curr\n }\n | _, _ ->\n failwith \"Incompatible states\"\nend\n","open Pickles_types\n\nlet default ~num_chunks =\n { Plonk_types.Messages.Poly.w =\n Vector.init Plonk_types.Columns.n ~f:(fun _ -> num_chunks)\n ; z = num_chunks\n ; t = 7 * num_chunks\n }\n","let default =\n let one = 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\nlet verify_promise = Verify.verify\n\nopen Kimchi_backend\nmodule Proof_ = P.Base\nmodule Proof = P\n\ntype chunking_data = Verify.Instance.chunking_data =\n { num_chunks : int; domain_size : int; zk_rows : int }\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_promise : Verification_key.t Promise.t Lazy.t\n\n val verification_key : Verification_key.t Deferred.t Lazy.t\n\n val id_promise : Cache.Wrap.Key.Verification.t Promise.t Lazy.t\n\n val id : Cache.Wrap.Key.Verification.t Deferred.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 array\n , Wrap_main_inputs.Inner_curve.Constant.t array option )\n Wrap_verifier.index'\n , 'branches )\n Vector.t\n Promise.t\n Lazy.t\n -> (int, 'branches) Pickles_types.Vector.t\n -> (Import.Domains.t, 'branches) Pickles_types.Vector.t Promise.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 Opt.t\n , ( Impls.Wrap.Impl.Field.t Composition_types.Scalar_challenge.t\n , Impls.Wrap.Boolean.var )\n Pickles_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 Promise.t\n Lazy.t\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 , 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 , Import.Types.Digest.Constant.t\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 , 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 , Import.Types.Digest.Constant.t\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 Storables = struct\n type t =\n { step_storable : Cache.Step.storable\n ; step_vk_storable : Cache.Step.vk_storable\n ; wrap_storable : Cache.Wrap.storable\n ; wrap_vk_storable : Cache.Wrap.vk_storable\n }\n\n let default =\n { step_storable = Cache.Step.storable\n ; step_vk_storable = Cache.Step.vk_storable\n ; wrap_storable = Cache.Wrap.storable\n ; wrap_vk_storable = Cache.Wrap.vk_storable\n }\nend\n\nlet create_lock () =\n let lock = ref (Promise.return ()) in\n\n let open Promise.Let_syntax in\n let run_in_sequence (f : unit -> 'a Promise.t) : 'a Promise.t =\n (* acquire the lock *)\n let existing_lock = !lock in\n let unlock = ref (fun () -> ()) in\n lock := Promise.create (fun resolve -> unlock := resolve) ;\n (* await the existing lock *)\n let%bind () = existing_lock in\n (* run the function and release the lock *)\n try\n let%map res = f () in\n !unlock () ; res\n with exn -> !unlock () ; raise exn\n in\n run_in_sequence\n\n(* turn a vector of promises into a promise of a vector *)\nlet promise_all (type a n) (vec : (a Promise.t, n) Vector.t) :\n (a, n) Vector.t Promise.t =\n let open Promise.Let_syntax in\n let%map () =\n (* Wait for promises to resolve. *)\n Vector.fold ~init:(Promise.return ()) vec ~f:(fun acc el ->\n let%bind _ = el in\n acc )\n in\n Vector.map ~f:(fun x -> Option.value_exn @@ Promise.peek x) vec\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.Promise.T (Arg_var) (Arg_value) (Ret_var) (Ret_value)\n (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.Proving_key.t * Dirty.t) Promise.t Lazy.t\n * (Kimchi_bindings.Protocol.VerifierIndex.Fp.t * Dirty.t) Promise.t Lazy.t\n end\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 -> storables:Storables.t\n -> proof_cache:Proof_cache.t option\n -> ?disk_keys:\n (Cache.Step.Key.Verification.t, branches) Vector.t\n * Cache.Wrap.Key.Verification.t\n -> ?override_wrap_domain:Pickles_base.Proofs_verified.t\n -> ?override_wrap_main:\n (max_proofs_verified, branches, prev_varss) wrap_main_generic\n -> ?num_chunks:int\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\n ~storables:\n { step_storable; step_vk_storable; wrap_storable; wrap_vk_storable }\n ~proof_cache ?disk_keys ?override_wrap_domain ?override_wrap_main\n ?(num_chunks = 1) ~branches:(module Branches) ~max_proofs_verified ~name\n ?constraint_constants ~public_input ~auxiliary_typ ~choices () ->\n let snark_keys_header kind constraint_system_hash =\n let constraint_constants : Snark_keys_header.Constraint_constants.t =\n match constraint_constants with\n | Some constraint_constants ->\n constraint_constants\n | None ->\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 in\n { Snark_keys_header.header_version = Snark_keys_header.header_version\n ; kind\n ; constraint_constants\n ; length = (* This is a dummy, it gets filled in on read/write. *) 0\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 -> Opt.Flag.t Plonk_types.Features.Full.t =\n fun rules ->\n match rules with\n | [] ->\n Plonk_types.Features.Full.none\n | [ r ] ->\n Plonk_types.Features.map r.feature_flags ~f:(function\n | true ->\n Opt.Flag.Yes\n | false ->\n Opt.Flag.No )\n |> Plonk_types.Features.to_full ~or_:Opt.Flag.( ||| )\n | r :: rules ->\n let feature_flags = go rules in\n Plonk_types.Features.Full.map2\n (Plonk_types.Features.to_full ~or_:( || ) r.feature_flags)\n feature_flags ~f:(fun enabled flag ->\n match (enabled, flag) with\n | true, Yes ->\n 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 ~num_chunks\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 * unit Promise.t\n -> (a, b, c, d) H4.T(Branch_data).t = function\n | [], _ ->\n []\n | rule :: rules, chain_to ->\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 ~num_chunks\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 ~chain_to )\n in\n Timer.clock __LOC__ ; incr i ; res\n in\n let (T b) = first in\n let chain_to = Promise.map b.domains ~f:(fun _ -> ()) in\n first :: f (rules, chain_to)\n in\n f (choices, Promise.return ())\n in\n Timer.clock __LOC__ ;\n let step_domains =\n let module Domains_promise = struct\n type t = Domains.t Promise.t\n end in\n let module M =\n H4.Map (Branch_data) (E04 (Domains_promise))\n (struct\n let f (T b : _ Branch_data.t) = b.domains\n end)\n in\n let module V = H4.To_vector (Domains_promise) in\n V.f prev_varss_length (M.f step_data)\n in\n\n let all_step_domains = promise_all step_domains in\n let run_in_sequence = create_lock () in\n\n let cache_handle = ref (Lazy.return (Promise.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 = Impls.Step.input ~proofs_verified:Max_proofs_verified.n\n\n let f (T b : _ Branch_data.t) =\n let open Impls.Step in\n let k_p =\n lazy\n (let (T (typ, _conv, conv_inv)) = etyp in\n let%bind.Promise main =\n b.main ~step_domains:all_step_domains\n in\n run_in_sequence (fun () ->\n let main () () =\n let%map.Promise res = main () in\n Impls.Step.with_label \"conv_inv\" (fun () ->\n conv_inv res )\n in\n let constraint_builder =\n Impl.constraint_system_manual ~input_typ:Typ.unit\n ~return_typ:typ\n in\n let%map.Promise res =\n constraint_builder.run_circuit main\n in\n let cs = constraint_builder.finish_computation res 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 (Promise.return ks.(b.index))\n | None ->\n lazy\n (let%map.Promise id, _header, index, cs =\n Lazy.force k_p\n 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 ~s_p:step_storable k_p ~s_v:step_vk_storable k_v )\n in\n accum_dirty (Lazy.map pk ~f:(Promise.map ~f:snd)) ;\n accum_dirty (Lazy.map vk ~f:(Promise.map ~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 (let step_keypairs = V.f prev_varss_length step_keypairs in\n let%map.Promise () =\n (* Wait for keypair promises to resolve. *)\n Vector.fold ~init:(Promise.return ()) step_keypairs\n ~f:(fun acc (_, vk) ->\n let%bind.Promise _ = Lazy.force vk in\n acc )\n in\n Vector.map step_keypairs ~f:(fun (_, vk) ->\n Tick.Keypair.full_vk_commitments\n (fst (Option.value_exn @@ Promise.peek @@ 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 ~num_chunks ~feature_flags ~srs full_signature\n prev_varss_length step_vks proofs_verifieds all_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 all_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 self_id = Type_equal.Id.uid self.id in\n let disk_key_prover =\n lazy\n (let%map.Promise wrap_main = Lazy.force wrap_main in\n let (T (typ, conv, _conv_inv)) = input ~feature_flags () in\n let main x () = wrap_main (conv x) in\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%map.Promise 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 @@ Promise.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 ~s_p:wrap_storable disk_key_prover\n ~s_v:wrap_vk_storable disk_key_verifier )\n in\n (r, disk_key_verifier)\n in\n Timer.clock __LOC__ ;\n let wrap_vk =\n Lazy.map wrap_vk\n ~f:\n (Promise.map ~f:(fun ((wrap_vk, _) as res) ->\n let computed_domain_size =\n wrap_vk.Verification_key.index.domain.log_size_of_group\n in\n let (Pow_2_roots_of_unity proposed_domain_size) =\n wrap_domains.h\n in\n if computed_domain_size <> proposed_domain_size then\n failwithf\n \"This circuit was compiled for proofs using the wrap domain \\\n of size %d, but the actual wrap domain size for the \\\n circuit has size %d. You should pass the \\\n ~override_wrap_domain argument to set the correct domain \\\n size.\"\n proposed_domain_size computed_domain_size () ;\n res ) )\n in\n accum_dirty (Lazy.map wrap_pk ~f:(Promise.map ~f:snd)) ;\n accum_dirty (Lazy.map wrap_vk ~f:(Promise.map ~f:snd)) ;\n let wrap_vk = Lazy.map wrap_vk ~f:(Promise.map ~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 ~proof_cache ~maxes handler next_state =\n let%bind.Promise wrap_vk = Lazy.force wrap_vk in\n let%bind.Promise step_pk = Lazy.force step_pk in\n S.f ?handler branch_data next_state ~prevs_length:prev_vars_length\n ~self ~step_domains:all_step_domains\n ~self_dlog_plonk_index:\n ((* TODO *) Plonk_verification_key_evals.map\n ~f:(fun x -> [| x |])\n wrap_vk.commitments )\n ~public_input ~auxiliary_typ ~feature_flags ~proof_cache ~maxes\n (fst step_pk) wrap_vk.index\n in\n let wrap ?handler next_state =\n let%bind.Promise step_vk, _ = Lazy.force step_vk in\n let%bind.Promise wrap_vk = Lazy.force wrap_vk in\n let%bind.Promise ( proof\n , return_value\n , auxiliary_value\n , actual_wrap_domains ) =\n step ~proof_cache 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 let%bind.Promise wrap_main = Lazy.force wrap_main in\n let%bind.Promise wrap_pk = Lazy.force wrap_pk in\n Wrap.wrap ~proof_cache ~max_proofs_verified:Max_proofs_verified.n\n ~feature_flags ~actual_feature_flags:b.feature_flags\n full_signature.maxes wrap_requests ?tweak_statement\n ~dlog_plonk_index:\n ((* TODO *) Plonk_verification_key_evals.map\n ~f:(fun x -> [| x |])\n wrap_vk.commitments )\n wrap_main ~typ ~step_vk ~step_plonk_indices:(Lazy.force step_vks)\n ~actual_wrap_domains (fst wrap_pk) 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 =\n Lazy.map wrap_vk\n ~f:\n (Promise.map ~f:(fun x ->\n Plonk_verification_key_evals.map\n (Verification_key.commitments x) ~f:(fun x -> [| x |]) ) )\n ; wrap_vk = Lazy.map wrap_vk ~f:(Promise.map ~f:Verification_key.index)\n ; wrap_domains\n ; step_domains\n ; feature_flags\n ; num_chunks\n ; zk_rows =\n ( match num_chunks with\n | 1 ->\n 3\n | num_chunks ->\n let permuts = 7 in\n ((2 * (permuts + 1) * num_chunks) - 1 + permuts) / permuts )\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_promise tag : t Promise.t =\n let d = Types_map.lookup_compiled tag.Tag.id in\n let%bind.Promise wrap_key = Lazy.force d.wrap_key in\n let%map.Promise wrap_vk = Lazy.force d.wrap_vk in\n let actual_wrap_domain_size =\n Common.actual_wrap_domain_size\n ~log_2_domain_size:wrap_vk.domain.log_size_of_group\n in\n ( { wrap_vk = Some wrap_vk\n ; wrap_index =\n Plonk_verification_key_evals.map wrap_key ~f:(fun x -> x.(0))\n ; max_proofs_verified =\n Pickles_base.Proofs_verified.of_nat_exn\n (Nat.Add.n d.max_proofs_verified)\n ; actual_wrap_domain_size\n }\n : t )\n\n let of_compiled tag = of_compiled_promise tag |> Promise.to_deferred\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 Plonk_types.Features.to_full ~or_:Opt.Flag.( ||| ) feature_flags\n ; num_chunks = 1\n ; zk_rows = 3\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, None, 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 -> ?storables:Storables.t\n -> ?proof_cache:Proof_cache.t\n -> ?disk_keys:\n (Cache.Step.Key.Verification.t, branches) Vector.t\n * Cache.Wrap.Key.Verification.t\n -> ?override_wrap_domain:Pickles_base.Proofs_verified.t\n -> ?override_wrap_main:\n (max_proofs_verified, branches, prev_varss) wrap_main_generic\n -> ?num_chunks:int\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.Promise).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 = []) ?(storables = Storables.default) ?proof_cache\n ?disk_keys ?override_wrap_domain ?override_wrap_main ?num_chunks\n ~public_input ~auxiliary_typ ~branches ~max_proofs_verified ~name\n ?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.Promise).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 ~self ~proof_cache ~cache ~storables ?disk_keys\n ?override_wrap_domain ?override_wrap_main ?num_chunks ~branches\n ~max_proofs_verified ~name ~public_input ~auxiliary_typ\n ?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 chunking_data =\n match num_chunks with\n | None ->\n Promise.return None\n | Some num_chunks ->\n let compiled = Types_map.lookup_compiled self.id in\n let%map.Promise domains = promise_all compiled.step_domains in\n let { h = Pow_2_roots_of_unity domain_size } =\n domains\n |> Vector.reduce_exn\n ~f:(fun\n { h = Pow_2_roots_of_unity d1 }\n { h = Pow_2_roots_of_unity d2 }\n -> { h = Pow_2_roots_of_unity (Int.max d1 d2) } )\n in\n Some\n { Verify.Instance.num_chunks\n ; domain_size\n ; zk_rows = compiled.zk_rows\n }\n 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_promise = wrap_disk_key\n\n let id = Lazy.map ~f:Promise.to_deferred wrap_disk_key\n\n let verification_key_promise = wrap_vk\n\n let verification_key = Lazy.map ~f:Promise.to_deferred wrap_vk\n\n let verify_promise ts =\n let%bind.Promise chunking_data = chunking_data in\n let%bind.Promise verification_key = Lazy.force verification_key_promise in\n verify_promise ?chunking_data\n ( module struct\n include Max_proofs_verified\n end )\n (module Value)\n verification_key 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, Lazy.return @@ Promise.return @@ 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 , 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 , Import.Types.Digest.Constant.t\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 , 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 , Import.Types.Digest.Constant.t\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 rule self : _ Inductive_rule.Promise.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 Promise.return\n { Inductive_rule.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 ~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\"\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 Promise.return\n { Inductive_rule.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 = Kimchi_pasta_basic.poseidon_params_fq\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:(Lazy.force 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 =\n Vector.to_array (Lazy.force 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 (Lazy.force 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 let chals = Lazy.force Dummy.Ipa.Wrap.challenges_computed in\n Vector.iter ~f:(S.absorb sponge) chals ;\n let s1 = full_state sponge in\n Vector.iter ~f:(S.absorb sponge) chals ;\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\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.Full.none ~bool:Boolean.typ\n ~dummy:Inner_curve.Params.one\n ~commitment_lengths:(Commitment_lengths.default ~num_chunks:1)\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\nmodule Make (M : sig\n type _ t\nend) =\nstruct\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 *)\n type ( '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 M.t\n ; feature_flags : bool Pickles_types.Plonk_types.Features.t\n }\n\n module T\n (Statement : T0)\n (Statement_value : T0)\n (Return_var : T0)\n (Return_value : T0)\n (Auxiliary_var : T0)\n (Auxiliary_value : T0) =\n struct\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\n end\nend\n\nmodule Promise = Make (Promise)\nmodule Deferred = Make (Async_kernel.Deferred)\ninclude Make (Id)\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 array Plonk_verification_key_evals.t\n ; wrap_vk : Impls.Wrap.Verification_key.t\n ; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t\n ; num_chunks : int\n ; zk_rows : int\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 : Opt.Flag.t Plonk_types.Features.Full.t\n ; branches : 'n2 Nat.t\n ; num_chunks : int\n ; zk_rows : int\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\n ; public_input\n ; branches\n ; feature_flags\n ; num_chunks\n ; zk_rows\n }\n ; ephemeral\n } =\n let wrap_key, wrap_vk =\n match ephemeral with\n | Some { index = `In_prover i | `In_both (i, _) } ->\n let wrap_index =\n Plonk_verification_key_evals.map i.wrap_index ~f:(fun x -> [| x |])\n in\n (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 ; num_chunks\n ; zk_rows\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 : Opt.Flag.t Plonk_types.Features.Full.t\n ; num_chunks : int\n ; zk_rows : int\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 :\n Tick.Inner_curve.Affine.t array Plonk_verification_key_evals.t Promise.t\n Lazy.t\n ; wrap_vk : Impls.Wrap.Verification_key.t Promise.t Lazy.t\n ; wrap_domains : Domains.t\n ; step_domains : (Domains.t Promise.t, 'branches) Vector.t\n ; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t\n ; num_chunks : int\n ; zk_rows : int\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 ; num_chunks\n ; zk_rows\n } =\n let%bind.Promise wrap_key = Lazy.force wrap_key in\n let%map.Promise wrap_vk = Lazy.force wrap_vk in\n { Basic.max_proofs_verified\n ; wrap_domains\n ; public_input\n ; branches = Vector.length step_domains\n ; wrap_key\n ; wrap_vk\n ; feature_flags\n ; num_chunks\n ; zk_rows\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 array 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 : Opt.Flag.t Plonk_types.Features.Full.t\n ; num_chunks : int\n ; zk_rows : int\n }\n\n let of_side_loaded (type a b c d)\n ({ ephemeral\n ; permanent =\n { branches\n ; max_proofs_verified\n ; public_input\n ; feature_flags\n ; num_chunks\n ; zk_rows\n }\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 let wrap_key =\n Plonk_verification_key_evals.map index.wrap_index ~f:(fun x -> [| x |])\n in\n { branches\n ; max_proofs_verified\n ; public_input\n ; proofs_verifieds = `Side_loaded\n ; wrap_key\n ; wrap_domain = `Side_loaded index.actual_wrap_domain_size\n ; step_domains = `Side_loaded\n ; feature_flags\n ; num_chunks\n ; zk_rows\n }\n\n module Optional_wrap_key = struct\n type 'branches known =\n { wrap_key :\n Tick.Inner_curve.Affine.t array Plonk_verification_key_evals.t\n ; step_domains : (Domains.t, 'branches) Vector.t\n }\n\n type 'branches t = 'branches known option\n end\n\n let of_compiled_with_known_wrap_key\n ({ wrap_key; step_domains } : _ Optional_wrap_key.known)\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 ; num_chunks\n ; zk_rows\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 wrap_key\n ~f:(Array.map ~f:Step_main_inputs.Inner_curve.constant)\n ; wrap_domain = `Known wrap_domains.h\n ; step_domains = `Known step_domains\n ; feature_flags\n ; num_chunks\n ; zk_rows\n }\n\n let of_compiled ({ wrap_key; step_domains; _ } as t : _ Compiled.t) =\n let%map.Promise wrap_key = Lazy.force wrap_key\n and step_domains =\n let%map.Promise () =\n (* Wait for promises to resolve. *)\n Vector.fold ~init:(Promise.return ()) step_domains\n ~f:(fun acc step_domain ->\n let%bind.Promise _ = step_domain in\n acc )\n in\n Vector.map ~f:(fun x -> Option.value_exn @@ Promise.peek x) step_domains\n in\n of_compiled_with_known_wrap_key { wrap_key; step_domains } t\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.\n (var, value, n, m) Tag.t -> (var, value, n, m) Basic.t Promise.t =\n fun t ->\n match t.kind with\n | Compiled ->\n Compiled.to_basic (lookup_compiled t.id)\n | Side_loaded ->\n Promise.return @@ 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 -> Opt.Flag.t Plonk_types.Features.Full.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 num_chunks : type var value. (var, value, _, _) Tag.t -> int =\n fun tag ->\n match tag.kind with\n | Compiled ->\n (lookup_compiled tag.id).num_chunks\n | Side_loaded ->\n (lookup_side_loaded tag.id).permanent.num_chunks\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 Opt.t\n , (scalar_challenge, Impl.Boolean.var) 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 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 ~num_chunks\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_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 ~num_chunks\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 = Impls.Step.unfinalized_proof_var\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 = Impls.Step.unfinalized_proof\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\n (Lazy.force 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 ~zk_rows:3\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 -> assert (Option.is_none (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\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 Promise.t 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 array 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 Promise.t 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 :\n Tock.Curve.Affine.t array 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 gates) ?feature_flags\n (module Impl : Snarky_backendless.Snark_intf.Run\n with type field = field\n and type R1CS_constraint_system.t = ( field\n , gates )\n Kimchi_backend_common\n .Plonk_constraint_system\n .t )\n (Spec.ETyp.T (typ, conv, _conv_inv))\n (Spec.ETyp.T (return_typ, _ret_conv, ret_conv_inv)) main =\n let main x () = Promise.map ~f:ret_conv_inv (main (conv x)) in\n\n let domains2 sys =\n let open Domain in\n (* Compute the domain required for the lookup tables *)\n let lookup_table_length_log2 =\n match feature_flags with\n | None ->\n 0\n | Some feature_flags ->\n let { Pickles_types.Plonk_types.Features.range_check0\n ; range_check1\n ; foreign_field_add =\n _\n (* Does not use lookup tables, therefore we do\n not need in the computation *)\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n } =\n feature_flags\n in\n let combined_lookup_table_length =\n let range_check_table_used =\n range_check0 || range_check1 || foreign_field_mul || rot\n in\n let xor_table_used = xor in\n (if range_check_table_used then Int.pow 2 12 else 0)\n + (if xor_table_used then Int.pow 2 8 else 0)\n + ( if lookup then (\n Kimchi_backend_common.Plonk_constraint_system\n .finalize_fixed_lookup_tables sys ;\n Kimchi_backend_common.Plonk_constraint_system\n .get_concatenated_fixed_lookup_table_size sys )\n else 0 )\n +\n if runtime_tables then (\n Kimchi_backend_common.Plonk_constraint_system\n .finalize_runtime_lookup_tables sys ;\n Kimchi_backend_common.Plonk_constraint_system\n .get_concatenated_runtime_lookup_table_size sys )\n else 0\n in\n\n Int.ceil_log2 (combined_lookup_table_length + zk_rows + 1)\n 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 =\n Pow_2_roots_of_unity Int.(max lookup_table_length_log2 (ceil_log2 rows))\n }\n in\n let constraint_builder =\n Impl.constraint_system_manual ~input_typ:typ ~return_typ\n in\n let%map.Promise res = constraint_builder.run_circuit main in\n let constraint_system = constraint_builder.finish_computation res in\n domains2 constraint_system\n","open Core_kernel\nopen Pickles_types\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 ~num_chunks ~max_proofs_verified =\n let num_choices = Hlist.Length.to_nat choices_length in\n let dummy_step_domains =\n Promise.return\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 (Promise.return\n (Vector.init num_choices ~f:(fun _ ->\n let num_chunks = (* TODO *) 1 in\n let g =\n Array.init num_chunks ~f:(fun _ ->\n Backend.Tock.Inner_curve.(to_affine_exn one) )\n in\n Verification_key.dummy_step_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 ~num_chunks ~srs full_signature\n choices_length dummy_step_keys dummy_step_widths dummy_step_domains\n max_proofs_verified\n in\n Timer.clock __LOC__ ;\n let%bind.Promise main = Lazy.force main in\n let t =\n Fix_domains.domains\n (module Impls.Wrap)\n (Impls.Wrap.input ~feature_flags ())\n (T (Snarky_backendless.Typ.unit (), Fn.id, Fn.id))\n (fun input -> Promise.return (main input))\n in\n Timer.clock __LOC__ ; t\n\n let f full_signature num_choices choices_length ~feature_flags ~num_chunks\n ~max_proofs_verified =\n Common.wrap_domains\n ~proofs_verified:(Nat.to_int (Nat.Add.n max_proofs_verified))\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 : (_ array * _ array, _) 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 For_tests_only = struct\n type shifted_tick_field =\n Backend.Tick.Field.t Pickles_types.Shifted_value.Type1.t\n\n type scalar_challenge_constant =\n Import.Challenge.Constant.t Import.Scalar_challenge.t\n\n type deferred_values_and_hints =\n { x_hat_evals : Backend.Tick.Field.t array * Backend.Tick.Field.t array\n ; sponge_digest_before_evaluations : Backend.Tick.Field.t\n ; deferred_values :\n ( ( Import.Challenge.Constant.t\n , scalar_challenge_constant\n , shifted_tick_field\n , (shifted_tick_field, bool) Opt.t\n , (scalar_challenge_constant, bool) Opt.t\n , bool )\n Import.Types.Wrap.Proof_state.Deferred_values.Plonk.In_circuit.t\n , scalar_challenge_constant\n , shifted_tick_field\n , scalar_challenge_constant Import.Bulletproof_challenge.t\n Import.Types.Step_bp_vec.t\n , Import.Branch_data.t )\n Import.Types.Wrap.Proof_state.Deferred_values.t\n }\n\n let deferred_values (type n)\n ~(sgs : (Backend.Tick.Curve.Affine.t, n) Vector.t) ~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)\n ~(proof : Backend.Tick.Proof.with_public_evals)\n ~(actual_proofs_verified : n Nat.t) : deferred_values_and_hints =\n let module O = Tick.Oracles in\n let o =\n O.create_with_public_evals 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 =\n match proof.public_evals with\n | Some x ->\n x\n | None ->\n O.([| p_eval_1 o |], [| p_eval_2 o |])\n 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.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 ~zk_rows:step_vk.zk_rows ~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 =\n Array.map prechals ~f:(fun x -> Ipa.Step.compute_challenge x)\n 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:\n (Nat.Add.create actual_proofs_verified)\n { evals = proof.proof.openings.evals; public_input = x_hat }\n ~r ~xi ~zeta ~zetaw\n ~old_bulletproof_challenges:prev_challenges ~env:tick_env\n ~domain:tick_domain ~ft_eval1:proof.proof.openings.ft_eval1\n ~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 ; joint_combiner = Opt.of_option plonk0.joint_combiner\n }\n }\n ; x_hat_evals = x_hat\n ; sponge_digest_before_evaluations = O.digest_before_evaluations o\n }\nend\n\ninclude For_tests_only\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 ) ~proof_cache\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 = 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.proof.messages\n | Openings_proof ->\n k proof.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\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.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 ~feature_flags () 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 create_proof () =\n Backend.Tock.Proof.create_async ~primary:public_inputs\n ~auxiliary:auxiliary_inputs pk ~message:next_accumulator\n in\n let%map.Promise proof =\n match proof_cache with\n | None ->\n create_proof ()\n | Some proof_cache -> (\n match\n Proof_cache.get_wrap_proof proof_cache ~keypair:pk\n ~public_input:public_inputs\n with\n | None ->\n if\n Proof_cache.is_env_var_set_requesting_error_for_proofs\n ()\n then failwith \"Regenerated proof\" ;\n let%map.Promise proof = create_proof () in\n Proof_cache.set_wrap_proof proof_cache ~keypair:pk\n ~public_input:public_inputs proof.proof ;\n proof\n | Some proof ->\n Promise.return\n ( { proof; public_evals = None }\n : Tock.Proof.with_public_evals ) )\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 joint_combiner =\n Opt.to_option\n next_statement.proof_state.deferred_values.plonk\n .joint_combiner\n }\n }\n }\n } )\n in\n [%log internal] \"Pickles_wrap_proof_done\" ;\n ( { proof = Wrap_wire_proof.of_kimchi_proof next_proof.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.proof.openings.evals }\n ; ft_eval1 = proof.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) ~zk_rows\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 ~zk_rows\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 ; joint_combiner = plonk0.joint_combiner\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 Array.iter ~f:absorb x1 ;\n Array.iter ~f: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 chunking_data = { num_chunks : int; domain_size : int; zk_rows : int }\n\n type t =\n | T :\n (module Nat.Intf with type n = 'n)\n * (module Intf.Statement_value with type t = 'a)\n * chunking_data option\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 = 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 , chunking_data\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, expected_num_chunks =\n let expected_num_chunks =\n Option.value_map ~default:1 chunking_data ~f:(fun x ->\n x.Instance.num_chunks )\n in\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\n Array.length x > expected_num_chunks\n || Array.length y > expected_num_chunks\n then raise Is_chunked )\n with\n | exception Is_chunked ->\n (false, expected_num_chunks)\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, expected_num_chunks)\n in\n check\n ( lazy (sprintf \"only uses %i chunks\" expected_num_chunks)\n , 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 let expected_domain_size =\n match chunking_data with\n | None ->\n Nat.to_int Backend.Tick.Rounds.n\n | Some { domain_size; _ } ->\n domain_size\n in\n check\n ( lazy \"domain size is small enough\"\n , Domain.log2_size step_domain <= expected_domain_size ) ;\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 let zk_rows =\n Option.value_map ~default:3 chunking_data ~f:(fun x ->\n x.Instance.zk_rows )\n in\n Wrap_deferred_values.expand_deferred ~evals ~zk_rows\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 , _chunking_data\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:\n (Plonk_verification_key_evals.map\n ~f:(fun x -> [| x |])\n 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\n ~feature_flags:Plonk_types.Features.Full.maybe 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\n , { proof = Wrap_wire_proof.to_kimchi_proof t.proof\n ; public_evals = None\n }\n , input\n , 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) ?chunking_data\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, chunking_data, key, x, p) )\n )\n","open Pickles_types\nopen Hlist\nopen Import\nopen Impls.Step\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 let open Step_verifier 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 (must_verify : B.t) : _ Vector.t * B.t =\n Boolean.Assert.( = ) unfinalized.should_finalize must_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 Step_verifier.finalize_other_proof d.max_proofs_verified\n ~step_domains:d.step_domains ~zk_rows:d.zk_rows ~sponge\n ~prev_challenges 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 Step_verifier.hash_messages_for_next_step_proof_opt ~index:d.wrap_key\n to_field_elements\n in\n (sponge_after_index, unstage hash_messages_for_next_step_proof)\n in\n (* prepare the statement to be verified below *)\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 (* Returns messages for the next step proof and messages for the next\n wrap proof *)\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 (* and when the statement is prepared, we call the step verifier with this\n statement *)\n let verified =\n with_label __LOC__ (fun () ->\n Step_verifier.verify ~srs\n ~feature_flags:(Plonk_types.Features.of_full d.feature_flags)\n ~lookup_parameters:\n { use = d.feature_flags.uses_lookups\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 must_verify) ~sponge_after_index\n ~sg_old:prev_challenge_polynomial_commitments ~proof:wrap_proof\n ~wrap_verification_key:d.wrap_key statement 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 must_verify = read Boolean.typ must_verify in\n printf \"finalized: %b\\n%!\" finalized ;\n printf \"verified: %b\\n%!\" verified ;\n printf \"must_verify: %b\\n\\n%!\" must_verify) ;\n (chals, Boolean.(verified &&& finalized ||| not must_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 -> known_wrap_keys:\n local_branches H1.T(Types_map.For_step.Optional_wrap_key).t\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.Promise.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 Promise.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 ~known_wrap_keys\n ~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_and_num_chunks (d : _ Tag.t) =\n if Type_equal.Id.same self.id d.id then\n (basic.feature_flags, basic.num_chunks)\n else (Types_map.feature_flags d, Types_map.num_chunks d)\n in\n let feature_flags_and_num_chunks =\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 -> (Opt.Flag.t Plonk_types.Features.Full.t * int, 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_and_num_chunks 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 -> (Opt.Flag.t Plonk_types.Features.Full.t * int, 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_flags_and_num_chunkss ->\n match[@warning \"-4\"]\n (ds, ns1, ns2, ld, ln1, ln2, feature_flags_and_num_chunkss)\n 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, num_chunks) :: feature_flags_and_num_chunkss ) ->\n let t =\n Per_proof_witness.typ Typ.unit n1 ~feature_flags ~num_chunks\n in\n t :: join ds ns1 ns2 ld ln1 ln2 feature_flags_and_num_chunkss\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_and_num_chunks\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 Promise.t =\n let open Impls.Step in\n let logger = Context_logger.get () in\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 app_state = exists input_typ ~request:(fun () -> Req.App_state) in\n let%bind.Promise { 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 () -> rule.main { public_input = app_state })\n in\n with_label \"step_main\" (fun () ->\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 let%map.Promise () =\n Async_promise.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 =\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)\n (tag : (var, value, n, m) Tag.t) (var : var) :\n 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 in\n let dlog_plonk_index =\n let num_chunks = (* TODO *) 1 in\n exists\n ~request:(fun () -> Req.Wrap_index)\n (Plonk_verification_key_evals.typ\n (Typ.array ~length:num_chunks Step_verifier.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_and_num_chunks ) )\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 proof_witnesses =\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 proof_witnesses datas messages_for_next_wrap_proofs\n unfinalizeds stmts pi ~actual_wrap_domains ->\n match\n ( proof_witnesses\n , datas\n , messages_for_next_wrap_proofs\n , unfinalizeds\n , stmts\n , pi\n , actual_wrap_domains )\n with\n | [], [], [], [], [], Z, [] ->\n ([], [])\n | ( pw :: proof_witnesses\n , d :: datas\n , messages_for_next_wrap_proof\n :: messages_for_next_wrap_proofs\n , unfinalized :: unfinalizeds\n , { proof_must_verify = must_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 pw d messages_for_next_wrap_proof\n unfinalized must_verify\n in\n let chalss, vs =\n go proof_witnesses datas messages_for_next_wrap_proofs\n unfinalizeds 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 ; num_chunks = basic.num_chunks\n ; zk_rows = basic.zk_rows\n }\n in\n let rec go :\n type a1 a2 n m.\n (a1, a2, n, m) H4.T(Tag).t\n -> m H1.T(Types_map.For_step.Optional_wrap_key).t\n -> (a1, a2, n, m) H4.T(Types_map.For_step).t =\n fun tags optional_wrap_keys ->\n match (tags, optional_wrap_keys) with\n | [], [] ->\n []\n | tag :: tags, optional_wrap_key :: optional_wrap_keys ->\n let data =\n match Type_equal.Id.same_witness self.id tag.id with\n | None -> (\n match tag.kind with\n | Compiled ->\n Types_map.For_step\n .of_compiled_with_known_wrap_key\n (Option.value_exn optional_wrap_key)\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 | Some T ->\n self_data\n in\n data :: go tags optional_wrap_keys\n in\n go rule.prevs known_wrap_keys\n in\n go proof_witnesses datas messages_for_next_wrap_proofs\n unfinalized_proofs previous_proof_statements proofs_verified\n ~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 (Step_verifier.Inner_curve))\n (struct\n let f :\n type a b c.\n (a, b, c) Per_proof_witness.t\n -> Step_verifier.Inner_curve.t =\n fun acc ->\n acc.wrap_proof.opening.challenge_polynomial_commitment\n end)\n in\n let module V = H3.To_vector (Step_verifier.Inner_curve) in\n V.f proofs_verified (M.f proof_witnesses)\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 (Step_verifier.hash_messages_for_next_step_proof\n ~index:dlog_plonk_index 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 Promise.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.Promise.t\n ; main :\n step_domains:(Domains.t, 'branches) Vector.t Promise.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 Promise.t )\n Promise.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 ~(feature_flags : Opt.Flag.t Plonk_types.Features.Full.t)\n ~num_chunks ~(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 ~(chain_to : unit Promise.t)\n (rule : _ Inductive_rule.Promise.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 (* Here, we prefetch the known wrap keys for all compiled rules.\n These keys may resolve asynchronously due to key generation for other\n pickles rules, but we want to preserve the single-threaded behavior of\n pickles to maximize our chances of successful debugging.\n Hence, we preload here, and pass the values in as needed when we create\n [datas] below.\n *)\n let module Optional_wrap_key = Types_map.For_step.Optional_wrap_key in\n let known_wrap_keys =\n let rec go :\n type a1 a2 n m.\n (a1, a2, n, m) H4.T(Tag).t -> m H1.T(Optional_wrap_key).t Promise.t =\n function\n | [] ->\n Promise.return ([] : _ H1.T(Optional_wrap_key).t)\n | tag :: tags ->\n let%bind.Promise opt_wrap_key =\n match Type_equal.Id.same_witness self.id tag.id with\n | Some T ->\n Promise.return None\n | None -> (\n match tag.kind with\n | Compiled ->\n let compiled = Types_map.lookup_compiled tag.id in\n let%map.Promise wrap_key = Lazy.force compiled.wrap_key\n and step_domains =\n let%map.Promise () =\n (* Wait for promises to resolve. *)\n Vector.fold ~init:(Promise.return ())\n compiled.step_domains ~f:(fun acc step_domain ->\n let%bind.Promise _ = step_domain in\n acc )\n in\n Vector.map\n ~f:(fun x -> Option.value_exn @@ Promise.peek x)\n compiled.step_domains\n in\n Some { Optional_wrap_key.wrap_key; step_domains }\n | Side_loaded ->\n Promise.return None )\n in\n let%map.Promise rest = go tags in\n (opt_wrap_key :: rest : _ H1.T(Optional_wrap_key).t)\n in\n go rule.prevs\n in\n Timer.clock __LOC__ ;\n let step ~step_domains ~known_wrap_keys =\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 ; num_chunks\n ; zk_rows =\n ( match num_chunks with\n | 1 ->\n 3\n | num_chunks ->\n let permuts = 7 in\n ((2 * (permuts + 1) * num_chunks) - 1 + permuts) / permuts )\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 ~known_wrap_keys ~self\n |> unstage\n in\n Timer.clock __LOC__ ;\n let own_domains =\n let%bind.Promise known_wrap_keys = known_wrap_keys in\n let main =\n step\n ~step_domains:\n (Vector.init branches ~f:(fun _ -> Fix_domains.rough_domains))\n ~known_wrap_keys\n in\n let etyp =\n Impls.Step.input ~proofs_verified:max_proofs_verified\n (* TODO *)\n in\n let%bind.Promise () = chain_to in\n Fix_domains.domains ~feature_flags:actual_feature_flags\n (module Impls.Step)\n (T (Snarky_backendless.Typ.unit (), Fn.id, Fn.id))\n etyp main\n in\n let step ~step_domains =\n let%bind.Promise known_wrap_keys = known_wrap_keys in\n let%map.Promise step_domains = step_domains in\n step ~step_domains ~known_wrap_keys\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 ~proof_cache\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 = 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 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 -> _ array Plonk_verification_key_evals.t\n -> value\n -> (local_max_proofs_verified, local_max_proofs_verified) Proof.t\n -> (var, value, local_max_proofs_verified, m) Types_map.Basic.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) data ~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 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 ~zk_rows:data.zk_rows\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 ~zk_rows:data.zk_rows ~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 ; joint_combiner = plonk0.joint_combiner\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 ~feature_flags\n 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 = Plonk_types.Features.none_bool\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\n (Lazy.force 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 ~zk_rows:3\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 [%log internal] \"Step_compute_prev_proof_parts\" ;\n let%map.Promise prevs =\n let rec go :\n type vars values ns ms.\n (vars, values, ns, ms) H4.T(Tag).t\n -> (vars, values, ns, ms) H4.T(Types_map.Basic).t Promise.t =\n function\n | [] ->\n Promise.return ([] : _ H4.T(Types_map.Basic).t)\n | tag :: tags ->\n let%bind.Promise data = Types_map.lookup_basic tag in\n let%map.Promise rest = go tags in\n (data :: rest : _ H4.T(Types_map.Basic).t)\n in\n go branch_data.rule.prevs\n in\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 -> (vars, values, ns, ms) H4.T(Types_map.Basic).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 datas prev_proof_stmts l ->\n match (ts, datas, prev_proof_stmts, l) with\n | [], [], [], Z ->\n ([], [], [], [], [], [], [])\n | ( t :: ts\n , data :: datas\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 (data.wrap_vk, data.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 data ~must_verify\n and sgs, us, ss, xs, ws, ps, domains =\n go ts datas prev_proof_stmts l\n 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 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 [%log internal] \"Step_compute_prev_proof_parts_done\"\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 Lazy.force 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 k (compute_prev_proof_parts prev_proof_requests)\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_exn 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.with_public_evals)\n , _next_statement_hashed ) =\n let (T (input, _conv, conv_inv)) =\n Impls.Step.input ~proofs_verified:Max_proofs_verified.n\n in\n let%bind.Promise main = branch_data.main ~step_domains in\n let%bind.Promise step_domains = step_domains 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) (fun () ->\n [%log internal] \"Step_generate_witness_conv\" ;\n let builder =\n Impls.Step.generate_witness_manual ~handlers:[ handler ]\n ~input_typ:Impls.Step.Typ.unit ~return_typ:input ()\n in\n let%bind.Promise res =\n builder.run_circuit (fun () () ->\n Promise.map ~f:conv_inv (main ()) )\n in\n let ( { Impls.Step.Proof_inputs.auxiliary_inputs; public_inputs }\n , next_statement_hashed ) =\n builder.finish_computation res\n in\n [%log internal] \"Backend_tick_proof_create_async\" ;\n let create_proof () =\n Backend.Tick.Proof.create_async ~primary:public_inputs\n ~auxiliary:auxiliary_inputs\n ~message:(Lazy.force prev_challenge_polynomial_commitments)\n pk\n in\n let%map.Promise proof =\n match proof_cache with\n | None ->\n create_proof ()\n | Some proof_cache -> (\n match\n Proof_cache.get_step_proof proof_cache ~keypair:pk\n ~public_input:public_inputs\n with\n | None ->\n if Proof_cache.is_env_var_set_requesting_error_for_proofs ()\n then failwith \"Regenerated proof\" ;\n let%map.Promise proof = create_proof () in\n Proof_cache.set_step_proof proof_cache ~keypair:pk\n ~public_input:public_inputs proof.proof ;\n proof\n | Some proof ->\n Promise.return\n ( { proof; public_evals = None }\n : Tick.Proof.with_public_evals ) )\n in\n [%log internal] \"Backend_tick_proof_create_async_done\" ;\n (proof, next_statement_hashed) )\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\n ; public_input =\n (let x1, x2 = x_hat in\n ([| x1 |], [| x2 |]) )\n }\n } ) )\n lte Max_proofs_verified.n (Lazy.force 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 Promise.t Lazy.t\n\nlet generate_or_load (t : t) = Lazy.force t\n\nlet ( + ) (t1 : t) (t2 : t) : t =\n lazy\n (let%map.Promise t1 = Lazy.force t1 and t2 = Lazy.force t2 in\n Dirty.(t1 + 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","open Core_kernel\ninclude List\n\nmodule 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","open Core_kernel\n\n(* A non-empty list is a tuple of the head and the rest (as a list) *)\n[%%versioned\nmodule Stable = struct\n module V1 = struct\n type 'a t = 'a * 'a list [@@deriving sexp, compare, equal, hash, to_yojson]\n end\nend]\n\nlet init x xs = (x, xs)\n\nlet singleton x = (x, [])\n\nlet uncons = Fn.id\n\nlet cons x' (x, xs) = (x', x :: xs)\n\nlet head (x, _) = x\n\nlet tail (_, xs) = xs\n\nlet last (x, xs) = if List.is_empty xs then x else List.last_exn xs\n\nlet of_list_opt = function [] -> None | x :: xs -> Some (x, xs)\n\nlet tail_opt t = of_list_opt (tail t)\n\nlet map (x, xs) ~f = (f x, List.map ~f xs)\n\nlet rev (x, xs) = List.fold xs ~init:(singleton x) ~f:(Fn.flip cons)\n\n(* As the Base.Container docs state, we'll add each function from C explicitly\n * rather than including C *)\nmodule C = Container.Make (struct\n type nonrec 'a t = 'a t\n\n let fold (x, xs) ~init ~f = List.fold xs ~init:(f init x) ~f\n\n let iter = `Custom (fun (x, xs) ~f -> f x ; List.iter xs ~f)\n\n let length = `Define_using_fold\nend)\n\n[%%define_locally C.(find, find_map, iter, length, fold)]\n\nlet to_list (x, xs) = x :: xs\n\nlet append (x, xs) ys = (x, xs @ to_list ys)\n\nlet take (x, xs) = function\n | 0 ->\n None\n | 1 ->\n Some (x, [])\n | n ->\n Some (x, List.take xs (n - 1))\n\nlet min_elt ~compare (x, xs) =\n Option.value_map ~default:x (List.min_elt ~compare xs) ~f:(fun mininum ->\n if compare x mininum < 0 then x else mininum )\n\nlet max_elt ~compare (x, xs) =\n Option.value_map ~default:x (List.max_elt ~compare xs) ~f:(fun maximum ->\n if compare x maximum > 0 then x else maximum )\n\nlet rec iter_deferred (x, xs) ~f =\n let open Async_kernel in\n let%bind () = f x in\n match xs with [] -> return () | h :: t -> iter_deferred (h, t) ~f\n","(* bits_intf.ml *)\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\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","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 *)\nopen Core_kernel\nopen Snark_params.Tick\nopen Bitstring_lib\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 (* 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 })\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 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 }\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","include Mina_signature_kind_type\n\nlet t =\n match Node_config.network with\n | \"testnet\" ->\n Testnet\n | \"mainnet\" ->\n Mainnet\n | _ ->\n Other_network Node_config.network\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 let r =\n if string_length <= length_in_bytes then\n let diff = length_in_bytes - string_length in\n s ^ String.init diff (fun _ -> padding_char)\n else String.sub s 0 length_in_bytes\n 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_mainnet = create \"MainnetZkappBody\"\n\nlet zkapp_body_testnet = create \"TestnetZkappBody\"\n\nlet zkapp_body ?(chain = Mina_signature_kind.t) =\n match chain with\n | Mainnet ->\n zkapp_body_mainnet\n | Testnet ->\n zkapp_body_testnet\n | Other_network chain_name ->\n create (chain_name ^ \"ZkappBody\")\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 \"CodaReceiptUC\"\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_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","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\nmodule Field = Pickles.Impls.Step.Field.Constant\n\nexternal get_ts_bindings : unit -> Js.Unsafe.any Js.Optdef.t = \"getTsBindings\"\n\n(* the ?. operator from JS *)\nlet ( |. ) (value : _ Js.Optdef.t) (key : string) =\n Js.(\n if phys_equal value undefined then undefined\n else Unsafe.get value (string key))\n\nlet lookup kind prefix =\n get_ts_bindings () |. kind |. prefix |> Js.Optdef.to_option\n\nlet of_js x =\n Js.to_array x |> Array.map ~f:(Fn.compose Field.of_string Js.to_string)\n\nlet salt s =\n match lookup \"prefixHashes\" s with\n | Some state ->\n of_js state |> Random_oracle.State.of_array\n | None ->\n Random_oracle.salt s\n\nlet salt_legacy s =\n match lookup \"prefixHashesLegacy\" s with\n | Some state ->\n of_js state |> Random_oracle.Legacy.State.of_array\n | None ->\n Random_oracle.Legacy.salt s\n","open Core_kernel\nopen Hash_prefixes\n\nlet salt (s : Hash_prefixes.t) = Hash_prefix_create.salt (s :> string)\n\nlet salt_legacy (s : Hash_prefixes.t) =\n Hash_prefix_create.salt_legacy (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 ?(chain = Mina_signature_kind.t) = salt @@ zkapp_body ~chain\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_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\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[@warning \"-32\"] get_or_create_account (t : t) (id : Account_id.t)\n (a : Account.t) :\n (Mina_base.Ledger_intf.account_state * location) Or_error.t =\n match location_of_account t id with\n | Some loc ->\n let a' = Option.value_exn (get t loc) in\n if Account.equal a a' then Ok (`Existed, loc)\n else\n Or_error.errorf\n !\"account %{sexp: Account_id.t} already present with different \\\n contents\"\n 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 (`Added, loc)\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[@warning \"-32\"] remove_accounts_exn (t : t) (ids : Account_id.t list) :\n 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 =\n lazy (Mina_base.Account.deriver @@ Fields_derivers_zkapps.o ())\n in\n let to_json (account : Mina_base.Account.t) : Js.Unsafe.any =\n Mina_base.Account.to_poly account\n |> Fields_derivers_zkapps.to_json (Lazy.force deriver)\n |> 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 lazy\n ( Mina_base.Zkapp_precondition.Protocol_state.View.deriver\n @@ Fields_derivers_zkapps.o () )\n 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\n |> Fields_derivers_zkapps.of_json (Lazy.force deriver)\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.Compiled.constraint_constants 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 () =\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","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","open Core_kernel\nopen Fold_lib\ninclude Intf\nmodule Intf = Intf\nopen Snark_bits\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\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 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 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 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","open 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 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\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\nmodule type S = sig\n include S_unchecked\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\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\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","include Nat.Make32 ()\n","module T = Nat.Make32 ()\n\nmodule Wire_types = Mina_wire_types.Mina_numbers.Txn_version\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\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n\nlet current = of_int @@ Protocol_version.(transaction current)\n\nlet equal_to_current t = t = current\n\nlet older_than_current t = t < current\n\nlet current_checked = Checked.constant current\n\nlet equal_to_current_checked t = Checked.(t = current_checked)\n\nlet older_than_current_checked t = Checked.(t < current_checked)\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 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","(** 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]\n\n let to_latest = Fn.id\n\n let sexp_of_t (Global_slot_span u32) = Sexp.Atom (T.to_string u32)\n\n let t_of_sexp = function\n | Sexp.Atom i ->\n Global_slot_span (T.of_string i)\n | _ ->\n failwith \"Global_slot.of_sexp: Expected Atom\"\n\n let to_yojson (Global_slot_span t) = `String (T.to_string t)\n\n let of_yojson = function\n | `String s ->\n Ok (Global_slot_span (T.of_string s))\n | `List [ `String \"Global_slot_span\"; `String s ] ->\n Ok (Global_slot_span (T.of_string s))\n | _ ->\n Error \"Global_slot_span.of_yojson: expected string\"\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 sexp_of_t = Stable.Latest.sexp_of_t\n\n let t_of_sexp = Stable.Latest.t_of_sexp\n\n let to_yojson = Stable.Latest.to_yojson\n\n let of_yojson = Stable.Latest.of_yojson\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 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","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 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","(** 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]\n\n let to_latest = Fn.id\n\n let sexp_of_t (Since_genesis u32) = Sexp.Atom (T.to_string u32)\n\n let t_of_sexp = function\n | Sexp.Atom i ->\n Since_genesis (T.of_string i)\n | _ ->\n failwith \"Global_slot.of_sexp: Expected Atom\"\n\n let to_yojson (Since_genesis u32) = `String (T.to_string u32)\n\n let of_yojson = function\n | `String i ->\n Ok (Since_genesis (T.of_string i))\n | `List [ `String \"Since_genesis\"; `String i ] ->\n Ok (Since_genesis (T.of_string i))\n | _ ->\n Error \"Global_slot.of_yojson: Expected `String\"\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\n let sexp_of_t = Stable.Latest.sexp_of_t\n\n let t_of_sexp = Stable.Latest.t_of_sexp\n\n let to_yojson = Stable.Latest.to_yojson\n\n let of_yojson = Stable.Latest.of_yojson\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, compare, equal]\n\n let to_latest = Fn.id\n\n let sexp_of_t (Since_hard_fork u32) = Sexp.Atom (T.to_string u32)\n\n let t_of_sexp = function\n | Sexp.Atom i ->\n Since_hard_fork (T.of_string i)\n | _ ->\n failwith \"Global_slot.of_sexp: Expected Atom\"\n\n let to_yojson (Since_hard_fork u32) = `String (T.to_string u32)\n\n let of_yojson = function\n | `String i ->\n Ok (Since_hard_fork (T.of_string i))\n | `List [ `String \"Since_hard_fork\"; `String i ] ->\n Ok (Since_hard_fork (T.of_string i))\n | _ ->\n Error \"Global_slot.of_yojson: Expected `String\"\n end\n end]\n\n module T = T\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 to_yojson = Stable.Latest.to_yojson\n\n let of_yojson = Stable.Latest.of_yojson\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","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\nmodule Txn_version = Txn_version\n","open 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 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 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\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 type magnitude_var\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 (* allows creation of negative 0 *)\n val create_preserve_zero_sign : 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 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\nend\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\nmodule type S = sig\n include Basic\n\n include Arithmetic_intf with type t := t\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 val add_signed_flagged : t -> Signed.t -> t * [ `Overflow of bool ]\nend\n\nmodule type Full = sig\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 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 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 (* TODO: Get rid of signed fee, use signed amount *)\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 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 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 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 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 (* 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 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 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 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 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 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","open Core_kernel\nopen Snark_params.Tick\nopen Snark_bits\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 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 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 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 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","open 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","open 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 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 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 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\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 token_id =\n Legacy_token.to_field token_id |> Account_id.Digest.of_field\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\nlet of_string s =\n try Account_id.Digest.of_string s\n with Base58_check.Invalid_base58_check_length _ ->\n Legacy_token.of_string s |> Stable.V1.to_latest\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\nopen Core_kernel\nopen Currency\nopen Snark_params\nopen Tick\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 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\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\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\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\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(** 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(* 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(* '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\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(** 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\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\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\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","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","open 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 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 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 *)\nopen Core_kernel\nopen Currency\nopen Snark_params.Tick\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 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 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 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\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\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\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\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 -> ?min_fee:Currency.Fee.t\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 -> ?min_fee:Currency.Fee.t\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 -> ?min_fee:Currency.Fee.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 -> ?min_fee:Currency.Fee.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 signature : t -> Signature.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 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.Latest.t\n , Public_key.Stable.Latest.t\n , Signature.Stable.Latest.t )\n Poly.Stable.V1.t\n [@@deriving sexp, hash, version]\n\n val to_yojson : t -> Yojson.Safe.t\n\n val of_yojson : Yojson.Safe.t -> (t, string) result\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","include Pickles.Side_loaded.Verification_key\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 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 = 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","open Core_kernel\nopen Snark_params.Tick\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\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","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 Coinbase_stack : sig\n [%%versioned:\n module Stable : sig\n module V1 : sig\n type t = Field.t\n end\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\n val init : t -> Field.t\n\n val curr : t -> Field.t\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\n val data : t -> Coinbase_stack.t\n\n val state : t -> State_stack.t\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 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 = 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\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 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 , add_wide_path_unsafe\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\nlet blockchain_dummy = lazy (Dummy_values.blockchain_proof ())\n\nlet transaction_dummy = lazy (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\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 get_or_create_account :\n t -> Account_id.t -> Account.t -> (account_state * location) Or_error.t\n\n val create_new_account : t -> Account_id.t -> Account.t -> unit Or_error.t\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","open Core_kernel\nmodule Js = Js_of_ocaml.Js\n\nexternal get_ts_bindings : unit -> Js.Unsafe.any Js.Optdef.t = \"getTsBindings\"\n\n(* the ?. operator from JS *)\nlet ( |. ) (value : _ Js.Optdef.t) (key : string) =\n Js.(\n if phys_equal value undefined then undefined\n else Unsafe.get value (string key))\n\nmodule Js_environment = struct\n type t = Node | Web | Unknown\n\n let value =\n let env = get_ts_bindings () |. \"jsEnvironment\" in\n Js.(\n if phys_equal env (def (string \"node\")) then Node\n else if phys_equal env (def (string \"web\")) then Web\n else Unknown)\nend\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 _console_trace s : unit =\n let f = Js.Unsafe.eval_string {js|(function(s) { console.trace(s); })|js} 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 () = O1js_bindings_lib.export_global ()\n\nlet () = O1js_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":"o1js_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","tsBindings","caml_bigint_256_bytes_per_limb","caml_bigint_256_compare","caml_bigint_256_div","caml_bigint_256_num_limbs","caml_bigint_256_of_bytes","caml_bigint_256_of_decimal_string","caml_bigint_256_of_numeral","caml_bigint_256_print","caml_bigint_256_test_bit","caml_bigint_256_to_bytes","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_create_bytes","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","plonk_wasm","require","tsRustConversion","caml_fp_srs_b_poly_commitment","srs","chals","caml_fp_srs_batch_accumulator_check","comms","rust_comms","rust_chals","ok","caml_fp_srs_batch_accumulator_generate","n_comms","tsSrs","caml_fp_srs_create","caml_fp_srs_h","caml_fp_srs_lagrange_commitment","caml_jsstring_of_string","caml_fp_srs_read","path","caml_fp_srs_write","append","caml_fp_vector_create","caml_fp_vector_emplace_back","caml_fp_vector_get","caml_fp_vector_length","caml_fq_srs_add_lagrange_basis","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","caml_utf8_of_utf16","caml_bytes_of_utf16_jsstring","caml_string_of_jsstring","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","pos","clen","new_str","old_data","MlFakeDevice","Symbol","name_slash","mode","raise_unix","parent","RegExp","seen","file","bytes","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_to_array","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","value","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_compare","caml_pasta_fp_copy","caml_pasta_fp_div","caml_pasta_fp_domain_generator","caml_pasta_fp_equal","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_mut_square","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_pasta_fp_plonk_gate_vector_add","free_finalization_registry","instance_representative","free_on_finalize","caml_pasta_fp_plonk_gate_vector_create","caml_bytes_of_uint8array","uint8array","ocaml_bytes","caml_pasta_fp_plonk_gate_vector_digest","caml_pasta_fp_plonk_gate_vector_get","caml_pasta_fp_plonk_gate_vector_len","caml_pasta_fp_plonk_gate_vector_wrap","caml_pasta_fp_plonk_index_create","gates","public_inputs","caml_lookup_tables","caml_runtime_table_cfgs","prev_challenges","urs","wasm_lookup_tables","wasm_runtime_table_cfgs","caml_pasta_fp_plonk_index_create_bytecode","caml_pasta_fp_plonk_index_read","caml_pasta_fp_plonk_index_write","caml_pasta_fp_plonk_proof_batch_verify","indexes","proofs","caml_pasta_fp_plonk_proof_create","witness_cols","caml_runtime_tables","prev_sgs","wasm_runtime_tables","proof","caml_pasta_fp_plonk_proof_verify","caml_pasta_fp_plonk_verifier_index_create","vk","caml_pasta_fp_plonk_verifier_index_read","caml_pasta_fp_plonk_verifier_index_shifts","log2_size","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_square","caml_pasta_fp_sub","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_compare","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_mut_square","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_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_pasta_fq_plonk_index_create","caml_pasta_fq_plonk_index_create_bytecode","caml_pasta_fq_plonk_index_domain_d1_size","caml_pasta_fq_plonk_index_read","caml_pasta_fq_plonk_index_write","caml_pasta_fq_plonk_proof_batch_verify","caml_pasta_fq_plonk_proof_create","caml_pasta_fq_plonk_proof_verify","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_square","caml_pasta_fq_sub","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","decr_nat","borrow","deferred_of_promise","promise","deferred","deferred_bind","func","input","anotherDeferred","deferred_create","promise_creator","resolve","deferred_map","deferred_peek","deferred_return","deferred_run","Error","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","wrap","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","fp_oracles_create","lgr_comm","verifier_index","fp_oracles_create_no_public","fq_oracles_create","fq_oracles_create_no_public","getTsBindings","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","z1","ml_z_add","z2","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","tp_loc$5","tp_loc$6","name$28","tp_loc$7","tp_loc$8","name$29","tp_loc$9","tp_loc$10","name$30","tp_loc$11","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$14","all$2","name$82","tp_loc$15","name$83","module_name$25","name$84","name$85","suffix$6","suffix","tp_loc$16","module_name$26","module_name$27","suffix$13","module_name$28","name$86","name$87","module_name$29","tp_loc$17","tp_loc$18","atom","record$1","label","ocaml_lex_tables$1","ocaml_lex_tables$2","ocaml_lex_tables$3","op","fmt$0","fmt$1","pos$0","slots","slots$0","name$89","here","tp_loc$19","none$1","arg$0","tp_loc$20","level_bits$0","here$0","here$1","here$2","here$3","here$4","here$5","tp_loc$21","tp_loc$22","tp_loc$23","tp_loc$24","list$1","tp_loc$25","list$2","tp_loc$26","empty$15","v_print_debug_messages_for","environment_variable","job_queue","deferred0","deferred1","monitor","import0","error$0","pos$1","c_compiler","ocamlc_cflags","ocamlc_cppflags","ocamlopt_cflags","ocamlopt_cppflags","cmi_magic_number","default_styles","all_native_obj_configs","column_mapping","in_different_places","descriptions","defaults_w","defaults_warn_error","opt$0","empty_docs","v$98","v$97","_1$27","_1$26","v$96","v$95","v$94","v$93","v$92","_3$0","_1$25","_1$24","_1$23","_1$22","_1$21","_1$20","_1$19","_1$18","_1$17","_1$16","_1$15","_1$14","_1$13","_1$12","_1$11","_1$10","v$91","v$90","v$89","v$88","_1$9","_3","v$87","v$86","v$85","v$84","v$83","v$82","v$81","v$80","v$79","v$78","v$77","v$76","v$75","v$74","v$73","v$72","v$71","v$70","v$69","v$68","v$67","v$66","v$65","v$64","v$63","v$62","_1$8","_1$7","_1$6","_1$5","_1$4","_1$3","_1$2","_1$1","v$61","v$60","v$59","v$58","v$57","v$56","v$55","v$54","v$53","v$52","v$51","v$50","v$49","v$48","v$47","v$46","v$45","v$44","v$43","v$42","v$41","v$40","v$39","v$38","v$37","v$36","v$35","v$34","v$33","v$32","v$31","v$30","v$29","v$28","v$27","v$26","v$25","v$24","v$23","v$22","v$21","v$20","v$19","v$18","v$17","v$16","v$15","v$14","v$13","v$12","v$11","_1$0","v$10","v$9","v$8","v$7","v$6","v$5","v$4","v$3","v$2","default_reduction","error$1","action$0","lhs","goto$0","explanation","msg_str","ocaml_lex_tables$4","key_name","alt_names","oattr_unboxed","oattr_untagged","oattr_noalloc","leaf_for_unpack","dummy_method","tvar_none","tunivar_none","desc","fmt$3","fmt$2","item","second$2","first$2","decl$0","second$3","first$3","tag$4","some_private_tag","warn0","kind_table","layout_table","txt1","ctx","splitting_mode$0","splitting_mode","lid$0","lid","mut2","mut1","arg$2","attr$0","staticfail","inter$1","default$7","caller","eqint","neint","leint","ltint","geint","gtint","msg$3","getter","shape$0","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$2","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","state$0","tp_loc$27","tp_loc$28","name$95","module_name$31","name$96","tp_loc$29","tp_loc$30","tp_loc$31","pos$3","label$1","pos$4","tp_loc$32","tp_loc$33","tp_loc$34","pos$5","tp_loc$35","tp_loc$36","tp_loc$37","tp_loc$38","state$13","state$12","state$11","state$10","state$9","state$8","state$7","state$6","state$5","state$4","state$3","state$2","state$1","feature_flags","maybe","tp_loc$39","none$5","actual_feature_flags","tp_loc$40","tp_loc$41","tp_loc$42","tp_loc$43","tp_loc$44","tp_loc$45","tp_loc$46","tp_loc$47","tp_loc$48","tp_loc$49","tp_loc$50","tp_loc$51","tp_loc$52","tp_loc$53","state$14","tp_loc$54","start$2","expected$0","tp_loc$55","pos$7","pos$6","pos$12","pos$11","pos$10","pos$9","pos$8","tp_loc$56","state$16","state$15","tp_loc$57","tp_loc$58","tp_loc$59","state$17","tp_loc$60","pos$13","tp_loc$61","tp_loc$62","pos$15","pos$14","tp_loc$68","tp_loc$63","tp_loc$64","tp_loc$65","tp_loc$66","tp_loc$67","pos$16","pos$19","pos$18","pos$17","name$97","id$5","name$98","id$6","pos$24","pos$23","pos$22","pos$21","pos$20","tp_loc$69","tp_loc$70","tp_loc$71","tp_loc$72","state$19","state$18","tp_loc$73","tp_loc$74","state$21","state$20","tp_loc$75","tp_loc$76","state$26","state$25","state$24","state$23","state$22","tp_loc$77","tp_loc$78","tp_loc$79","tp_loc$80","tp_loc$81","tp_loc$82","tp_loc$83","tp_loc$84","pos$31","pos$30","pos$29","pos$28","pos$27","pos$26","pos$25","state$29","initial_prefix","prefix$7","state$28","state$27","tp_loc$85","tp_loc$86","tp_loc$87","tp_loc$88","tp_loc$89","prefix$6","acc$0","state$31","state$30","tp_loc$90","tp_loc$91","tp_loc$92","pos$32","pos$34","pos$33","state$32","tp_loc$93","sponge_name","description$0","state$34","tp_loc$94","sponge_name$0","pos$42","pos$41","pos$40","pos$39","t2$2","t1$2","t2$3","t1$3","pos$38","pos$37","pos$36","pos$35","t2$0","t1$0","t2$1","t1$1","v0$0","t$7","pos$46","pos$45","pos$44","pos$43","t2$4","t1$4","t2$5","t1$5","t$8","state$46","state$45","state$41","state$42","state$43","state$44","state$36","state$37","state$38","state$39","state$40","tp_loc$95","tp_loc$96","pos$62","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","tp_loc$97","pos$63","tagname","branches","pos$65","pos$64","tp_loc$98","tp_loc$99","pos$66","pos$67","coinbase","proof_level","account_creation_fee_int","default_transaction_fee","default_snark_worker_fee","minimum_user_command_fee","genesis_state_timestamp","network","description$1","description$2","tp_loc$100","tp_loc$101","tp_loc$102","tp_loc$103","tp_loc$104","pos$69","message$1","state$48","tp_loc$109","state$47","tp_loc$105","tp_loc$106","tp_loc$107","tp_loc$108","hex_key_odd","hex_key_even","state$49","tp_loc$110","tp_loc$111","pos$70","coinbase$1","proof_level$0","account_creation_fee_int$0","default_transaction_fee$0","default_snark_worker_fee$0","minimum_user_command_fee$0","genesis_state_timestamp$0","network$0","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$6","t1$7","t1$8","pos$74","pos$73","pos$72","t2$7","t2$8","t2$9","key$1","pos$71","t2$6","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$50","v$105","x$0","state$51","tp_loc$112","tp_loc$113","pos$91","pos$90","t2$11","pos$89","pos$88","t2$10","pos$87","pos$86","description$3","state$53","state$52","tp_loc$114","tp_loc$115","env$1","tp_loc$117","err$3","tp_loc$116","description$4","tp_loc$118","state$54","tp_loc$119","tp_loc$120","description$5","pos$92","tp_loc$121","tp_loc$122","state$56","state$55","tp_loc$123","tp_loc$124","description$6","pos$95","pos$94","state$57","pos$93","tp_loc$125","tp_loc$126","pos$96","s$2","s$1","s$0","description$7","state$59","state$58","tp_loc$127","tp_loc$128","pos$97","tp_loc$129","tp_loc$130","empty$37","state$62","state$61","state$60","tp_loc$131","tp_loc$132","tp_loc$133","tp_loc$134","tp_loc$135","state$64","state$63","tp_loc$136","tp_loc$137","description$8","description$9","description$10","tp_loc$138","tp_loc$139","tp_loc$140","five","state$65","empty_stack_msg","salt_phrase","deriver_name","salt_phrase$0","deriver_name$0","salt_phrase$1","tp_loc$141","state$66","default$12","tp_loc$142","tp_loc$143","description$11","tp_loc$144","pos$102","pos$101","pos$100","pos$99","t2$13","pos$98","t2$12","tp_loc$145","tp_loc$146","tp_loc$147","epoch_data$0","dummy_value","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","tp_loc$172","tp_loc$173","tp_loc$174","state$71","state$70","state$69","tp_loc$175","description$12","tp_loc$176","tp_loc$177","state$73","state$72","tp_loc$178","description$13","tp_loc$179","state$75","state$74","tp_loc$180","description$14","tp_loc$181","state$80","state$79","state$78","state$77","state$76","tp_loc$182","description$15","description$16","tp_loc$183","tp_loc$184","description$17","tp_loc$185","tp_loc$186","tp_loc$187","tp_loc$188","tp_loc$189","tp_loc$190","tp_loc$191","tp_loc$192","tp_loc$193","tp_loc$194","state$84","state$83","state$82","state$81","description$18","description$19","tp_loc$195","names$1","tp_loc$196","names$2","tp_loc$197","tp_loc$198","state$86","state$85","tp_loc$199","tp_loc$200","pos$104","pos$103","tp_loc$201","tp_loc$202","transaction_id$1","expected_hash$1","transaction_id$0","expected_hash$0","transaction_id","expected_hash","v1_hashes","description$20","description$21","pos$105","update_failed","kind$3","tp_loc$203","tp_loc$204","tp_loc$205","tp_loc$206","tp_loc$207","tp_loc$208","tp_loc$209","tp_loc$210","tp_loc$211","nsf_tag","min_balance_tag","name$99","description$23","description$22","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","oc","open_out_gen","perm","open_out","open_out_bin","flush_all","iter","output_string","output_substring","close_out","open_in_gen","open_in_bin","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","executable_name","os_type$0","cygwin","arch_big_endian","match$0","num_bits_int","getenv_opt","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","let$0","map$0","fold","none","iter$0","is_none","map$1","map_error","equal","param$0","nth","l$0","n$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","Error$0","env","clear_parser","height","create","hl","h$0","hr","bal","lr","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","sub_fmtty_rest$4","fmtty_rest$2","sub_fmtty_rest$5","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","expected","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","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","print_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","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","token","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","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_no_args","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","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$3","hash_fold_t$5","hash_fold_t$8","func$1","func$3","t$1","t$2","t$3","t$4","t$5","type_name","compare$11","compare_array","compare_elt","len_a","len_b","ret","compare_option","concat$1","ys","num_bits","word_size","formatter","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$5","bind$0","return$1","map$6","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$13","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$15","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","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$17","equal_array","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$15","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$6","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$7","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$8","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$21","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$23","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$24","to_string$21","v_sorted","bnds","bnds$0","digest_layer","to_digest","to_digest$0","equal$16","opaque","create$25","apply$0","def","recurse","tid","get_poly_variant","annotate","basetype","tuple","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","label$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$26","map$27","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","small_positive_int","uniform_inclusive","log_uniform_inclusive","non_uniform","inclusive","log_inclusive","uniform_all","let_syntax_002","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$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","delta","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","b_002","hash_fold_t$22","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$23","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$24","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$25","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$26","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$27","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_read_t$27","t_of_sexp$25","sexp_of_t$36","equal$18","compare$45","bin_size_t$14","bin_write_t$14","bin_read_t$28","bin_read_t$29","typename_of_t$2","hash_fold_t$32","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","bin_read_array$2","compare_array$0","equal_array$0","group$45","bool$1","group$46","bin_shape_char$0","func$9","group$47","bin_shape_float$0","group$48","bin_shape_int","func$10","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","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$34","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$35","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","start$0","convert","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","shape_tbl","register","path_to_type","ty_decl","canonical1","canonical2","create$49","substring","buffer_len","length$22","bytes_for_client_to_commit","offset_in_buffer","apply$5","unsafe_get_char","count_while","lift2","succ1","input1","more1","succ2","input2","more2","symbol$170","symbol$171","fail$0","more$0","marks","prompt","parser_uncommitted_bytes","parser_committed_bytes","continue$0","demand_input","ensure_suspended","go","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_yojson","poly_a","bin_writer_a","bin_reader_a","bin_a","versioned","to_latest","bin_shape_elt","of_yojson","to_yojson$0","max_string_len","symbol$172","bin_shape_t$71","bin_write_t$29","bin_read_t$58","to_string$37","of_string$38","create$50","length$23","sub$8","copy$4","init$9","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","xor","invalid_arg$0","ror64","dup","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$10","f3","md5_do_chunk","feed$2","to_fill","unsafe_feed_bytes$1","unsafe_feed_bigstring$1","unsafe_get$2","padlen","rol32","dup$2","init$11","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$12","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$13","sha256_do_chunk","feed$5","unsafe_feed_bytes$4","unsafe_feed_bigstring$4","unsafe_get$5","init$14","unsafe_get$6","dup$5","unsafe_feed_bytes$5","unsafe_feed_bigstring$5","rol64","dup$6","init$15","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$16","sha512_do_chunk","feed$7","unsafe_feed_bytes$7","unsafe_feed_bigstring$7","unsafe_get$8","init$17","unsafe_get$9","dup$8","unsafe_feed_bytes$8","unsafe_feed_bigstring$8","init$18","init$19","init$20","init$21","dup$9","init$22","whirlpool_do_chunk","rc","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","digest_size_in_bits","digest_size_in_bytes","char_generator","gen$0","hash_fold_t$1","t_of_sexp$0","equal$0","bin_shape_typ","bin_writer_typ","bin_reader_typ","bin_typ","group$0","bin_shape_t_tagged","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","read_version","top_tag_versions","bin_read_top_tagged_to_latest","saved_pos","pos_ref$0","of_yojson$0","gen$1","of_hex$0","to_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","a_009","b_010","slots_per_tuple","arch_sixtyfour$0","max_slot","t0","t3","t4","t5","t13","masked_tuple_id_num_bits","max_array_length","tuple_id_mask","init$23","create$51","header_index","tuple_id","header_index_mask","invariant$9","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$54","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","dummy","tuple_num$0","create_with_dummy","capacity","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$10","set$9","t_of_sexp$46","sexp_of_t$55","validate$3","sexp_of_t$57","max_num_bits","invariant$10","of_int$6","symbol$173","symbol$174","pow2","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$59","v_level_bits","v_alarm_precision","bnd","create$52","level_bits","max_num_bits$0","num_keys","add_clamp_to_max","min_key_in_same_slot","min_key_in_same_slot_mask","value$3","next$5","pool","prev","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$60","v_how_to_dump","v_dump_if_delayed_by","t_of_sexp$49","sexp_of_t$61","equal$26","x_003","x_004","t_of_sexp$50","sexp_of_t$62","t_of_sexp$51","sexp_of_t$63","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","fields","name1","bnd$0","bnd$1","bnd$2","bnd$3","bnd$4","bnd$5","bnd$6","bnd$7","bnd$8","bnd$9","bnd$10","bnd$11","bnd$12","bnd$13","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","tail$1","field_sexp$19","sexp$2","alarm_precision_field","level_bits_field","capacity_field","duplicates$0","extra$0","field_sexp$18","sexp$0","num_key_bits","alarm_precision_value","sexp$3","sexp$4","fvalue$16","field_sexps$0","dump_if_delayed_by_field","how_to_dump_field","duplicates$1","extra$1","tail$0","field_sexp$20","sexp$1","how_to_dump_value","dump_if_delayed_by_value","fvalue$17","fvalue$18","fvalue$19","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","all$3","debug","debug$0","symbol$175","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$64","create_with_parent","dummy_e","dummy_f","dummy_a","create_array$0","create$53","sexpifier","none$2","is_none$1","is_some$1","create$55","enqueue$0","execution_context","priority","new_capacity","old_jobs","old_front","new_jobs","create$56","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$57","create2","run1","execution_context1","run2","execution_context2","enqueue$1","scheduler","schedule_jobs","add$18","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$5","of_binable$5","map$29","bind$14","map$30","symbol_map$2","bind$15","map$31","both$0","symbol_map$3","choices","unregisters","choices$0","choices$1","handler$0","handler$1","monitor$0","backtrace_history","column","monitor$1","name$1","backtrace$0","backtrace$1","traces","backtrace$2","list_if_not_empty","return$16","bind$16","map$32","return$17","apply$6","map$33","return$18","equal$27","combine$3","bs","sexp_of_t$66","v_pipe_id","v_values_read","values_sent_downstream","values_sent_downstream_and_flu","when_sent_downstream","fill_with_eof","sexp_of_t$67","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$24","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","flexlink","f$16","flexlink$0","safe_string","flat_float_array","lazy_tag$0","errorf$0","decode_prefix","decode_pair","equal_pos","encoded_target","encoded_source","source","rewrite_opt","prefix_map","is_prefix","fatal_errorf","fatal_error","try_finally","always","exceptionally","always_exn","always_bt","always_bt$0","reraise_preserving_backtrace","set_refs","protect_refs","refs","backup","map_end","replicate_list","list_remove","split_last","create_hashtable","cvt_int_aux","int$4","int32$1","int64$2","nativeint$0","get_ref","spellcheck","cutoff","env$0","cutoff$0","cost","best","best$0","dist","best_dist","best_choice","did_you_mean","get_choices","ordinal_suffix","teen","ansi_of_color","code_of_style","ansi_of_style_l","style_of_tag","color_enabled","mark_open_tag","or_else","mark_close_tag","set_color_tag_handling","pct","pot","mct","mot","should_enable_color","term","formatter_l","init$24","map_cache","get_build_path_prefix_map","decode_or_empty","pairs","conf","disjoint_union","print","eq$0","print$0","union_right","union_left","union_merge","m2$0","m1$0","rename","map_keys","of_set","transpose_keys_and_data","transpose_keys_and_data_set","output$0","datum","of_list$0","to_map","of_map","memoize","compare$66","hash$39","equal$28","compare$67","hash$40","equal$29","fatal","set_base_default","add_base_override","reset_base_overrides","set_user_default","add_user_override","parse_exn","parsed","key_value_pair","equals","help_text","parse_no_error","of_string$39","of_string$40","of_string$41","of_string$42","create$59","column_names","global_bindings","s_table","ref","s_ref","files_uncap","dirs","find_uncap","uname","fullname","ufullname","last_warning_number","name_to_number","current$3","disabled$0","without_warnings","restore","is_active","is_error$0","with_state","set_alert","enable","upd","alert","parse_options","errflag","active","modifier","modifier$0","parse_and_eval","get_num","tokens","tokens$0","tokens$1","loop_letter_num","n2$0","print_modifier","commit_chunk","group_consecutive_letters","on_going","consecutive_letters","example","nowhere","spelling_hint","max_seq_len","alerts","ref_manual_explanation","message$0","slist","slist$0","modname","tc2","tc1","cname","file2","file1","modname$0","s$4","s$5","s$6","complaint","is_exception","s$7","kind$0","expansion$0","s$8","expansion","s$9","s$10","s$11","kind$1","s$12","s$13","s$14","sl","unattached","attr_name","attr_name$0","vars$1","s$15","s$16","s$17","s$18","nerrors","report","report_alert","sub_locs","crc","old_source","old_crc","check$0","check_noadd","extract","assc","extract_map","mod_names","to_remove","force","create$60","create_forced","create_failed","force_logged","log","prefix$0","sty","let$1","let$2","classify$0","opt_get","st","shape_at","construct_patch","shape_here","weigth0","j0","weight$0","j_final","i_final","compute_column0","compute_line0","compute_inner_cell","compute_proposition","localstate","del","diff$0","insert","diag","newweight","compare_proposition","curr","prop","curr_res","curr_m","compute_cell","compute_matrix","state0","columns$1","lines$1","lines","columns","columns$0","lines$0","copy$0","copy","may_append","fullstate","with_pos","prefix$1","style$0","create$61","kx","ky","compare$68","merge_edge","ex","ey","rstate","rpos","lstate","lpos","move","moves","left$0","patch","swaps","nx","edge$0","nx$0","edge$1","edge","move$0","in_file","loc$2","get_pos_info","mknoloc","num_loc_lines","setup_colors","print_filename","print_loc","startline","endline","startchar","endchar","capitalize","comma","startline$0","endline$0","mem$8","iset","msg$2","pp_loc","highlight","locs","intervals","kn","nesting","rightmost","end","line_nb","consistent","line_start_cnum","car","left_column_size","lines_nb","ellipsed_last","ellipsed_first","line_r","line_l","pp_txt","pp$21","out_functions","out_string","pp_report_kind","w$0","w$1","w$2","pp_main_loc","pp_main_txt","pp_submsgs","msgs","pp_submsg","pp_submsg_loc","pp_submsg_txt","printer","print_report","mkerror","errorf$1","error_of_printer","error_of_printer_file","default_warning_alert_reporter","mk","is_error","msg_of_str","sub_message","prerr_warning","report$0","prerr_alert","alert$0","use","deprecated","flatten$0","last$0","docstrings","warn_bad_docstrings","ds","docstring","doc_loc","info_attr","add_docs_attrs","docs","attrs","attrs$0","attrs$1","empty_info","add_info_attrs","text_loc","empty_text_lazy","text_attr","add_text_attrs","dsl","fdsl","get_docstring","get_docstrings","param$2","associate_docstrings","pre_table","set_pre_docstrings","get_pre_docs","mark_pre_docs","post_table","set_post_docstrings","get_post_docs","mark_post_docs","get_info","floating_table","set_floating_docstrings","get_text","get_post_text","pre_extra_table","set_pre_extra_docstrings","get_pre_extra_text","post_extra_table","set_post_extra_docstrings","get_post_extra_text","symbol_docs","mark_rhs_docs","symbol_info","rhs_info","symbol_text","rhs_text","rhs_post_extra_text","init$25","payload","mk$0","force_poly","mk$1","attr","var$5","constant","construct","mk$2","ident","let$3","match$7","poly","unreachable","mk$3","mk$4","ident$0","mk$5","f_txt","mk$6","text$0","mk$7","mk$8","mk$9","text$1","mk$10","text$2","mk$11","typ","prim","mk$12","mk$13","mk$14","expr","mk$15","mk$16","mexpr","mk$17","pat","mk$18","virt","mk$19","manifest","cstrs","priv","constructor$0","field$0","mut","mk$20","constructors","mk_exception","decl","rebind","mk$21","tag$2","tys","mk$22","tag$3","inherit$0","pr_var","get1","get_data$0","error_value","foreach_terminal","non_start_production","production_index","find_production","defred","nodefred","is_start","prod","unmarshal2","displacement","displacement$0","terminal","reduce","opcode","please_discard","goto_nt","nt","goto_prod","maybe_goto_nt","semantic_action","may_reduce","prod$0","terminals","reduce_or_accept","productions","lookahead_token","startp","endp","initiating_error_handling","resuming_error_handling","handling_error","check_for_default_reduction","announce_reduce","check_for_error_token","initiate","new_env","initial","offer","triple","resume","checkpoint","strategy","please_discard$0","lexer_lexbuf_to_supplier","lexer","checkpoint$0","checkpoint$1","checkpoint$2","opt$2","loop_handle","succeed","loop_handle_undo","inputneeded","shifts","acceptable","env1","env2","current_state_number","positions","state_has_default_reduction","env_has_default_reduction","pop","force_reduction","input_needed","pop_many","make_loc$0","ghost_loc","mktyp","mkpat","mkexp","mkmty","mksig","mkmod","mkstr","mkclass","mkcty","pstr_typext","ext","te","pstr_primitive","vd","psig_typext","psig_value","mkctf","mkcf","mkrhs","rhs","ghrhs","push_loc","reloc_pat","mkexpvar","mkpatvar","ghexp","ghpat","ghtyp","ghloc","ghstr","mkinfix","neg_string","mkpat_cons","consloc","mktailexp","nilloc","el_loc","exp_el","nil","mktailpat","pl","p1","pat_pl","mkstrexp","mkexp_constraint","mkexp_opt_constraint","constraint","mkpat_opt_constraint","syntax_error","unclosed","opening_name","opening_loc","closing_name","closing_loc","expecting","nonterm","not_expecting","builtin_arraylike_name","paren_kind","opname","submodule_name","builtin_arraylike_index","explist","coords","builtin_indexing_operators","paren_to_strings","user_indexing_operator_name","user_index","user_indexing_operators","mk_indexop_expr","array_indexing_operator","set_expr","paren","dot","set_arg","indexop_unclosed_error","loc_s","loc_e","loc_map","make_ghost","loc_last","exp_of_longident","exp_of_label","lbl","pat_of_label","mk_newtypes","newtypes","newtype","wrap_type_annotation","core_type","exp$0","check_variable","vl","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","mkexp_attrs","mkpat_attrs","wrap_mkstr_ext","wrap_mksig_ext","mk_quotedext","delim","strloc","idloc","exp_id","text_str","text_sig","text_def","extra_text","items","pre_extras","post_extras","post","post_extras$0","extra_str","p2","extra_cstr","extra_csig","extra_def","extra_rhs_core_type","mklb","is_pun","addlb","lbs","mklbs","package_type_of_module_type","pmty","map_cstr","ptyp","mk_directive_arg","mk_directive","token2terminal","error_terminal","token2value","menhir_env","menhir_stack","menhir_stack$0","startpos_1","menhir_s","endpos_2","endpos_1","endpos_1_inlined1","startpos_1_inlined1","inlined1","endpos_rhs","sloc","endpos_1_inlined2","startpos_1_inlined2","inlined2","_4","sloc$0","lident","endpos_xs","_6","endpos_1_inlined3","inlined3","endpos_3","startpos_3","_5","endpos_7","_7","symbolstartpos","endpos_0","endpos_6","mutable","endpos_ty","loc_3","startpos_2","loc_2","loc_1","startpos_e","endpos_xss","startpos_xss","endpos_tyvar","tyvar","endpos_p","startpos_p","endpos_4","startpos_xs","startpos_ty","sloc$1","thing","endpos_bs","startpos_1_inlined3","endpos_1_inlined4","inlined4","startpos_a","nr","endpos_5","endpos_1_inlined5","inlined5","startpos_7","loc_7","startpos_4","loc_4","startpos_5","loc_5","endpos_2_inlined1","sloc$2","startpos_1_inlined4","endpos_8","startpos_8","loc_8","endpos_9","_8","me","modexp","es","tail_exp","list_exp","exten","startpos_6","loc_6","endpos_e","loc_p","startpos_array","closed","closed$0","cty","mty","sloc$3","vars_args_res","startpos_c","endpos_eo","eo","constraint_loc","endpos_x","startpos_x","endpos_x_inlined1","oe","endpos_oe","startpos_x1","endpos_x2","startpos_x_inlined1","endpos_d","cid","startpos_d","endpos_fields","startpos_fields","endpos_pat","constr","cstrs$0","descr$0","endpos_op","startpos_op","oty","endpos_cs","startpos_cs","startpos_s","endpos_s","endpos_mty","syn","endpos_ex","startpos_ex","startpos_me1","me1","endpos_me2","me2","startpos_me","endpos_attr","endpos_me","startpos_arg_and_pos","arg_and_pos","endpos_body","_9","endpos_11","_11","poly_exp_loc","poly_exp","private$0","info_before_semi","endpos_tail","startpos_octy","octy","endpos_opat","opat","pat$0","xs_inlined1","kind_priv_manifest","csig","startpos_bindings","pbop_op","rev_ands","let_exp","let_pat","pbop_exp","pbop_pat","pbop_loc","and","startpos_body","startpos_pat","endpos_exp","endpos_typ","rec_flag","patloc","endpos_label","startpos_label","loc_label","endpos_cty","endpos_codomain","codomain","domain","endpos_v","ands","oploc","startpos_e1","endpos_e2","endpos_10","open_loc","inlined1$0","startpos_domain","meth","parse_expression","interface$0","implementation","keyword_table","reset_string_buffer","get_stored_string","store_string_char","store_string","store_lexeme","string_start_loc","comment_start_loc","in_comment","is_in_string","store_escaped_char","compute_quoted_string_idloc","orig_loc","id_start_pos","loc_start","loc_end","wrap_string_lexer","string_start","wrap_comment_lexer","start_loc","end_loc","error_loc","num_value","char_for_backslash","illegal_escape","char_for_decimal_code","char_for_octal_code","char_for_hexadecimal_code","check_label_name","update_loc","chars","new_file","warn_latin1","comment_list","add_comment","com","expl","explanation$0","literal_loc","explanation$1","quoted_string","edelim","string$3","last$2","digit_count","last$1","comment$0","ocaml_lex_comment_rec","str_start","str_start$0","loc$1","start$1","ocaml_lex_token_rec","op$1","op$2","op$3","op$4","op$5","op$6","op$7","op$8","op$9","illegal_char","name$2","lit","lit$0","modif","lit$1","lit$2","modif$0","delim$0","orig_loc$0","idloc$0","id$1","orig_loc$1","loc$3","idloc$1","id$2","delim$1","orig_loc$2","loc$4","idloc$2","esc","loc$5","loc$6","stars","loc$7","loc$8","stars$0","loc$9","curpos","at_beginning_of_line","directive","ocaml_lex_directive_rec","line_num","init$26","last_token","post_pos","docs$0","docs$1","lines$2","parser","ast","nonterm$0","iter_fst","iter_snd","iter_tuple","iter_opt","iter_loc","row_field","prf_attributes","prf_loc","object_field","pof_attributes","pof_loc","iter$22","tyl","ol","lid$1","iter_type_declaration","ptype_loc","ptype_attributes","ptype_manifest","ptype_kind","ptype_cstrs","ptype_params","ptype_name","iter_type_kind","iter_constructor_arguments","iter_type_extension","ptyext_attributes","ptyext_loc","ptyext_constructors","ptyext_params","ptyext_path","iter_type_exception","ptyexn_attributes","ptyexn_loc","ptyexn_constructor","iter_extension_constructor","pext_attributes","pext_loc","pext_kind","pext_name","cto","ctl","iter$23","ct","iter_field","iter_signature","pcsig_fields","pcsig_self","iter_functor_param","iter$24","sg","mt2","mt","iter_with_constraint","lid2","mty$0","lid$2","lid$3","lid$4","iter_signature_item","iter$25","iter_structure_item","vbs","iter$26","pel","pel$0","pel$1","eo$0","e3","e3$0","e2$3","e1$3","e$5","e$6","e$7","e$8","sel","e$9","e$10","cd","e$11","e$12","e$13","cls","e$14","me$0","e$15","iter_binding_op","iter$27","lpl","pl$0","iter$28","ce","ce$0","ce$1","ce$2","iter_kind","iter_field$0","iter_structure","pcstr_fields","pcstr_self","class_infos","pci_attributes","pci_loc","pci_expr","pci_name","this$0","pval_loc","pval_attributes","pval_type","pval_name","pvb_loc","pvb_attributes","pvb_expr","pvb_pat","popen_attributes","popen_loc","popen_expr","pmtd_loc","pmtd_attributes","pmtd_type","pmtd_name","pms_loc","pms_attributes","pms_manifest","pms_name","pmd_loc","pmd_attributes","pmd_type","pmd_name","pmb_loc","pmb_attributes","pmb_expr","pmb_name","pld_attributes","pld_loc","pld_type","pld_name","pincl_attributes","pincl_loc","pincl_mod","pcd_attributes","pcd_loc","pcd_res","pcd_args","pcd_vars","pcd_name","pc_rhs","pc_guard","pc_lhs","get_no_payload_attribute","report_error","string_of_payload","string_of_opt_payload","error_of_extension","kind_and_message","cat","alert_attr","alert_attrs","alerts_of_attrs","check_alerts","check_alerts_inclusion","attrs1","attrs2","deprecated_mutable_of_attrs","warn_payload","warning_attribute","ppwarning","process","process_alert","attr_loc","attr_payload","attr_loc$0","attr_payload$0","pstr_loc","attr_loc$1","attr_payload$1","warning_scope","explicit_arity","currentstamp","predefstamp","expansion_scope","generic_level","create_scoped","scope","create_local","name$90","persistent","original_equal","same$1","empty$16","mknode","h$1","balance$0","h$2","h$3","h$4","h$5","h$6","h$7","h$8","h$9","rr$0","rd$0","add$19","find_same","param$3","find_name","get_all","find_all$0","fold_aux","fold_name","fold_data","fold_all","make_key_generator","global_id","stamp","compare$69","output$1","hash$41","fmt_ident","same$2","p1$0","p2$0","id2","p2$1","fun2","compare$71","find_free_opt","ids","exists_free","scope$0","kfalse","name$91","head$0","flatten$1","is_uident","constructor_typath","ty_path","is_constructor_typath","is_ocaml_repr","is_unboxed","is_untagged","make_native_repr_args","simple$0","alloc","add_native_repr_attributes","attr_opt","equal_native_repr","nr1","nr2","bi2","report_error$0","coerce","as","of_attributes","equal$30","compare$72","hash$42","comp_unit","output$2","mk$23","current_unit","of_compilation_unit_id","of_predef_id","internal_not_actually_unique","for_actual_declaration","to_string$40","compare$73","value$4","type","module$0","module_type","class$0","class_type","fresh_var","funct_shape_param","var$6","abs$5","leaf","proj","app","decompose_abs","for_persistent_unit","set_uid_if_none","empty$17","add_value","add_type","add_module","add_extcons","add_class","add_class_type","compare$74","hash$43","equal$31","single","union$3","set$10","mem$9","covariant","null$5","unknown$0","full","swap$0","conjugate","get_upper","get_lower","unknown_signature","injective","rank$1","compare$75","default_signature","equal_tag","i2$0","path2","equal$32","item_visibility","vis","bound_value_identifiers","signature_item_id","trail","log_change","field_kind_internal_repr","field_kind_repr","fk","field_public","is_commu_ok","commu_ok","commu_var","repr_link","repr_link1","repr$2","get_desc","get_level","get_scope","get_id","set_desc","set_stub_desc","set_level","set_scope","sc","type_expr","eq_type","row_fields","row","row$0","row_repr_no_fields","row$1","row_more","row_closed","row_fixed","row_name","get_row_field","tag$0","set_row_name","row_fields$0","row_repr","row_field_repr","fi","matched","arg_type","row_field_ext","fi$0","rf_absent","rf_either","use_ext_of","rf_either_of","eq_row_field_ext","rf1","rf2","new_id","newty3","newty2","undo_change","desc$0","ty$1","ty$2","last_snapshot","log_type","link_type","set_type_desc","td","set_level$0","set_univar","rty","set_name","link_row_field_ext","inside","inside$0","link_kind","link_commu","set_commu_ok","snapshot","undo_first_change_after","changes","undo_compress","log$0","wrap_repr","wrap_type_expr","tty","add$20","mem$10","singleton$0","elements$1","add$21","find$11","add$22","find$12","equal$33","hash$44","create$63","clear$7","repr2","add$23","mem$11","print_raw","newgenty","newgenvar","newgenstub","is_Tvar","is_Tunivar","is_Tconstr","merge_fixed_explanation","fixed1","fixed2","fixed_explanation","is_fixed","has_fixed_explanation","static_row","hash_variant$0","proxy","row_of_type","has_constr_row","is_row_name","is_constr_row","allow_ident","fold_row","iter_row","fold_type_expr","ty1$0","fl","iter_type_expr","iter_type_expr_cstr_args","lbls","map_type_expr_cstr_args","iter_type_expr_kind","it_signature","it","it_signature_item","td$0","md","mtd","ctd","it_value_description","it_type_declaration","it_extension_constructor","it_module_declaration","it_modtype_declaration","it_class_declaration","it_class_type_declaration","it_functor_param","it_module_type","it_class_type","cty$0","it_type_kind","it_do_type_expr","it_path","copy_row","fixed","keep","orig_name","orig_fixed","orig_fields","fixed$0","copy_type_desc","keep_names","ty$3","tyl$0","redirect_desc","copy_scope","with_scope","saved_desc","find_expans","priv$0","cleanup_abbrev","abbr","memorize_abbrev","forget_abbrev_rec","path$0","path$1","forget_abbrev","backtrack","is_optional","label_name","prefixed_label_name","extract_label","ls$0","signature_of_class_type","class_body","cty$1","class_type_arity","abbreviate_class_type","self_type","self_type_row","concrete_methods","vr","method_type","not_marked_node","flip_mark_node","try_mark_node","try_logged_mark_node","mark_type","it_type_expr","unmark_type","it_type_expr$0","unmark_iterators","unmark_type_decl","unmark_extension_constructor","unmark_class_signature","cstr_type_path","cstr","print_lident","print_ident","id1","value_ident","print_list","pr","pr_present","pr_vars","print_typlist","print_elem","print_fields","print_out_type","non_gen","print_record_decl","print_typargs","print_simple_out_type","print_out_type_1","print_out_type_2","ng","ng$0","print_present","print_fields$0","print_row_field","opt_amp","pr_of","print_type_parameter","type_parameter","inj","print_out_class_params","print_out_class_type","pr_tyl","csil","self_ty","pr_param","print_out_class_sig_item","out_module_type","out_sig_item","out_signature","out_type_extension","out_functor_parameters","constructor_of_extension_const","print_out_module_type","non_functor","non_functor$0","print_out_functor_parameters","print_simple_out_module_type","print_nonanon_arg","print_args","non_anonymous_functor","mty_arg$0","anons","mty_arg","non_simple","print_out_signature","items$0","items$1","items$2","ext$0","exts","print_out_sig_item","rs","clt","vir_flag","rs$0","clt$0","params$0","vir_flag$0","print_out_constr","print_extended_type","ty_param","rs$1","rs$2","print_constraints","type_defined","print_manifest","print_name_params","print_private","print_immediate","print_unboxed","print_out_tkind","constrs","variants","pr_prims","return_type","ret_type","print_out_type_extension","add_type_path","add_type$0","add_type_function","add_module_path","add_module$0","add_modtype_path","add_modtype","change_locs","is_not_doc","module_path","modtype_path","type_path","cstr$0","to_subst_by_type_function","new_id$0","newpersty","norm","ctype_apply_env_empty","typexp","tm","has_fixed_row","mored","type_expr$0","label_declaration","constructor_arguments","type_declaration","type_declaration$0","class_declaration","class_declaration$0","cltype_declaration","cltype_declaration$0","value_description","value_description$0","extension_constructor$0","extension_constructor$1","merge_path_maps","lazy_modtype","lazy_module_decl","lazy_signature","lazy_signature_item","sg$0","force_signature_once","force_signature_once$0","force_signature","force_signature_item","force_modtype","compose","modtype","scoping","subst_lazy_modtype","subst_lazy_signature","scoping$0","scoping$1","sg$1","subst_lazy_module_decl","mdl_type","force_module_decl","md_type","lazy_modtype_decl","mtdl_type","subst_lazy_modtype_decl","force_modtype_decl","mtd_type","subst_lazy_signature_item","vis$0","vis$1","vis$2","d$1","vis$3","d$2","id$3","vis$4","d$3","id$4","vis$5","d$4","sg$7","sg$8","rename$0","ec","id$7","id$8","id$9","id$10","id$11","id$12","signature","signature_item","comp$0","builtin_idents","ident_create","ident_int","ident_char","ident_bytes","ident_float","ident_bool","ident_unit","ident_exn","ident_array","ident_list","ident_option","ident_nativeint","ident_int32","ident_int64","ident_lazy_t","ident_string","ident_extension_constructor","ident_floatarray","path_int","path_char","path_bytes","path_float","path_bool","path_unit","path_exn","path_array","path_list","path_option","path_nativeint","path_int32","path_int64","path_lazy_t","path_string","path_extension_constructor","path_floatarray","type_int","type_char","type_float","type_bool","type_unit","type_exn","type_array","type_option","type_nativeint","type_int32","type_int64","type_lazy_t","type_string","type_extension_constructor","ident_match_failure","ident_out_of_memory","ident_invalid_argument","ident_failure","ident_not_found","ident_sys_error","ident_end_of_file","ident_division_by_zero","ident_stack_overflow","ident_sys_blocked_io","ident_assert_failure","ident_undefined_recursive_modu","all_predef_exns","path_match_failure","path_assert_failure","ident_false","ident_true","ident_void","ident_nil","ident_cons","ident_none","ident_some","mk_add_type","type_ident","immediate","build_initial_env","add_exception","empty_env","add_type1","variance","separability","add_extension","tvar","common","add_type$1","unsafe_string","free_vars","newgenconstr","constructor_args","cd_args","cd_res","type_ret","arg_vars_set","res_vars","existentials","arg_vars_set$0","type_params","tdecl","extension_descr","path_ext","ty_res","cstr_inlined","cstr_args","none$3","dummy_label","constructors_of_type","num_consts","num_nonconsts","describe_constructors","idx_const","idx_nonconst","cd_uid","cd_attributes","cd_loc","cd_id","ty_res$0","ty_res$1","descr_rem","descr_rem$0","cstr_name","representation","labels_of_type","labels","all_labels","describe_labels","input_cmi","crcs","report_error$1","older_newer","filename$0","filename$1","add_delayed_check_forward","error$3","empty$19","add_import","imported_units","find_in_cache","persistent_structures","pm","import_crcs","penv","crc_units","import_crc","crco","check_consistency","auth","can_load_cmis","acknowledge_pers_struct","pers_sig","cmi","imported_opaque_units","find_pers_struct","val_of_pers_sig","psig","pm$0","ps$0","check_pers_struct","warn","warn$0","ps_name","warn$1","report_error$2","source2","source1","import$0","import$1","add_delayed_check_forward$0","value_declarations","type_declarations","module_declarations","uid_to_loc","register_uid","add_constructor_usage","cu","constructor_usages","constructor_usage_complaint","used_constructors","used_labels","empty$20","add$24","find_same$0","tbl$0","tbl$1","nothing","find_all$1","mark","using","components","using$0","opened","hidden","empty$21","add$25","find_same$1","find_name$0","fold_name$0","diff_keys","tbl1","tbl2","keys2","empty_structure","error$4","lookup_error","same_constr","check_well_formed_module","empty$22","in_signature","is_in_signature","has_local_constraints","is_ext","cda","is_local","wrap$0","wrap_value","vda","wrap_module","mda","components_of_module_maker","components_of_functor_appl","check_functor_application","strengthen","get_unit_name","is","is_ident","is_path","find_same_module","add_persistent_structure","material","summary","modules","components_of_module","addr","mda_address","mda_declaration","mda_shape","mda_components","persistent_env","without_cmis","find_pers_mod","check_pers_mod","get_components_res","get_components","modtype_of_functor_appl","fcomp","subst","find_ident_module","find_functor_components","find_module_components","find_structure_components","f_path","f_comp","find_module_lazy","alias","fc","md$0","find_strengthened_module","aliasable","find_value_full","find_type_full","find_modtype_lazy","find_modtype","find_class_full","find_value","find_class","find_ident_constructor","type_of_cstr","find_type_data","mod_path","tda","find_type","find_type_descrs","get_address","force_address","find_module_address","find_value_address","find_class_address","find_constructor_address","cda$0","find_shape","shape_of_path","shape_or_leaf","required_globals","add_required_global","lax","expand_module_path","path1","normalize_module_path","oloc","normalize_path_prefix","normalize_type_path","normalize_modtype_path$0","expand_modtype_path$0","normalize_modtype_path","find_module","find_module_lazy$0","find_type_expansion","find_type_expansion_opt","find_modtype_expansion_lazy","find_modtype_expansion","is_functor_arg","add_to_tbl","decls","value_declaration_address","module_declaration_address","presence","store_modtype","update_summary","mtda","check_usage","used","store_module","components_of_module_maker$0","cm_shape","cm_mty","cm_addr","cm_path","cm_prefixing_subst","cm_env","rem$4","items_and_paths$7","next_address","vda_shape","decl$1","decl$2","descrs","repr$0","cda_shape","tda_shape","tda$0","addr$0","addr$1","decl$3","final_decl","decl$4","decl$5","addr$2","shape$1","clda","decl$6","decl$7","shape$2","cltda","ty_arg","check_value_name","store_value","store_type","lbl_id","ty_name","env$2","cstr_id","descrs$0","components_of_functor_appl$0","shape_arg","add_value$0","add_module_declaration","add_modtype$0","add_class$0","add_cltype","add_module$1","scrape_alias","enter_value","enter_type","enter_module_declaration","enter_modtype","add_signature","mod_shape","proj_shape$0","proj_shape","mod_shape$0","map$2","shape$3","map$3","shape$4","map$4","shape$5","map$7","parent_shape","enter_signature","add_value$1","add_type$2","add_extension$0","add_class$1","add_cltype$0","add_modtype$1","add_signature$0","enter_unbound_value","add_components","env0","add_l","types","modtypes","classes","cltypes","remove_last_open","d$5","rem_l","root$0","open_pers_signature","mark_module_used","mark_value_used","mark_type_used","mark_type_path_used","mark_constructor_used","mark_label_used","mark_constructor_description_u","mark_label_description_used","mark_class_used","mark_cltype_used","set_type_used_callback","callback","may_lookup_error","report_errors","report_module_unbound","report_value_unbound","rloc","show_hint","hint","use_module","use_value","use_type","use_modtype","use_class","use_cltype","use_label","use_constructor_desc","use_constructor","lookup_ident_module","load","mda$0","lookup_ident_value","lookup_ident_type","lookup_ident_modtype","lookup_ident_class","lookup_ident_cltype","lookup_all_ident_constructors","use_fn","use_fn$0","lookup_dot_module","lookup_structure_components","md$1","lookup_apply","path_arg","comp_f","path_f","md$2","lid0","args0","f0_lid","arg_lid","f_lid","arg_md","arg_path","lookup_module_components","f0_comp","f0_path","check_one_apply","arg_mty","fcomps","param_mty","f_comp$0","args$1","arg_path$0","arg_path$1","f_comp$1","f_path$0","arg_mty$0","arg_path$2","arg_path$3","lookup_dot_value","lookup_dot_type","lookup_dot_modtype","mta","lookup_dot_class","lookup_dot_cltype","lookup_all_dot_labels","use_fun","lookup_all_dot_constructors","lookup_modtype_lazy","find_module_by_name","find_value_by_name","find_type_by_name","find_modtype_by_name","find_class_by_name","find_cltype_by_name","lookup_module_path","lookup_module","lookup_value","lookup_type","lookup_modtype_path","lookup_class","lookup_cltype","lookup_all_constructors","lookup_constructor","use$0","lookup_all_labels","find_all$2","proj1","proj2","find_all_simple_list","fold_values","ve","fold_constructors","print_longident","print_path","spellcheck$0","spellcheck_name","extract_values","extract_types","extract_modules","extract_constructors","extract_labels","extract_classes","extract_modtypes","extract_cltypes","extract_instance_variables","report_lookup_error","def_loc","lid$5","lid$6","lid$7","lid$8","lid$9","lid$10","lid$11","lid$12","lid$13","lid$14","lid$15","cause","report_error$3","error_of_printer$0","swap_position","print_pos","trivial_expansion","map_diff","swap_diff","map_escape","explain","trace","map$34","context","incompatible_fields","swap_elt","swap_trace","unification_error","swap_unification_error","map$35","as_computation_pattern","classify_pattern","shallow_iter_pattern_desc","patl","patl$0","lbl_pat_list","patl$1","shallow_map_pattern_desc","pats","pats$0","lpats","pats$1","p1$1","p1$2","iter_general_pattern","exists_general_pattern","exists_pattern","iter_bound_idents","pat$1","rev_pat_bound_idents_full","idents_full","id_full","rev_only_idents","pat_bound_idents_full","pat_bound_idents","rev_let_bound_idents_full","vb","let_bound_idents_full","let_bound_idents","alpha_var","alpha_pat","new_p","pat_desc","split_pattern","combine_opts","into","cpat","cp2","cp1","exns1","vals1","exns2","vals2","flatten$2","rec_items","next_group","q$1","ht","q$0","ghosts","q$2","ht$0","recursive_sigitem","next$6","cons_group","pre$0","group$1","sgroup","iter$29","raise_trace_for","tr_exn","tr","raise_unexplained_for","raise_for","escape","escape_exn","raise_escape_exn","raise_scope_escape_exn","current_level","nongen_level","global_level","saved_level","get_current_level","init_def","begin_def","begin_class_def","raise_nongen_level","end_def","create_scope","is_object_type","trace_gadt_instances","check_trace_gadt_instances","reset_trace_gadt_instances","wrap_trace_gadt_instances","simple_abbrevs","proper_abbrevs","abbrev","newty","newvar","newvar2","newstub","newobj","newconstr","none$4","umode","equations_generation","assume_injective","allow_recursive_equation","can_generate_equations","set_mode_pattern","generate","allow_recursive","in_current_module","is_datatype","object_fields","flatten_fields","build_fields","associate_fields","fields1","fields2","object_row","opened_object","concrete_object","set_object_name","sort_row_fields","merge_row_fields","fi1$1","fi2$1","fi2$2","fi1$2","fi1","fi2","fi2$0","fi1$0","pairs$0","filter_row_fields","erase","really_closed","free_vars_rec","real","real$0","free_vars$0","free_variables","closed_type","closed_type_decl","closed_extension_constructor","duplicate_type","duplicate_class_type","generalize","generalize_structure","generalize_spine","forward_try_expand_safe","normalize_package_path","orig_level","update_scope","update_scope_for","expand","needs_expand","update_level","snap","update_level_for","var_level","contra","done_contra","must_visit","lower_rec","maybe_expand$0","not_expanded","lower_contravariant","generalize_class_type","generalize_class_type$0","correct_levels","limited_generalize","ty0","graph","roots","inverse","pty","parents","generalize_parents","limited_generalize_class_type","inv_type","compute_univars","inverted","node_univars","add_univar","univ","univs","abbreviations","copy$5","partial","forget","keep$0","free_univars$0","abbrevs","more$3","fields$0","free_univars","more$2","not_reither","more$1","instance","sch","partial$0","generic_instance","instance_list","schl","reified_var_counter","get_new_abstract_name","new_local_type","manifest_and_scope","expansion_scope$0","existential_name","instance_constructor","in_pattern","fresh_constr_scope","existential","to_unify","tv","ty_args","ty_ex","instance_parameterized_type","sch_args","map_kind","instance_declaration","instance_class","copy_class_type","diff_list","conflicts","free","bound$0","delayed_copy","copy_sep","cleanup_scope","may_share","univars","bound_t","dl","visited$0","copy_rec","visited$1","instance_poly","copy_var","instance_poly$0","instance_label","ty_arg$0","unify_var","old_level","body0","abbrev$0","undo_abbrev","apply$7","previous_env","check_abbrev_env","expand_abbrev_gen","lookup_abbrev","expand_abbrev","safe_abbrev","try_expand_once","try_expand_safe","try_expand_head","try_once","expand_head_unif","expand_head","extract_concrete_typedecl","expand_abbrev_opt","try_expand_once_opt","try_expand_safe_opt","expand_head_opt","full_expand","may_forget_scope","generic_abbrev","is_contractive","occur_rec","type_changed","merge$4","occur_for","allow_rec","strict$0","strict$1","local_non_recursive_abbrev","unify_univar","cl2","cl1","find_univ","t_2","unify_univar_for","univar_pairs","occur_univar","inj_only","occur_rec$0","occur_desc$0","occur_desc","has_free_univars","has_injective_univars","occur_univar_for","add_univars","univars_escape","family","occur","enter_poly","tl1","tl2","old_univars","known_univars","enter_poly_for","polyfy","complete","reify_univars","has_cached_expansion","abbrev$1","expand_type","expand_any_trace","expand_trace","expand_to_unification_error","expand_to_equality_error","trace$0","expand_to_moregen_error","unexpanded_diff","deep_occur","gadt_equations_level","get_gadt_equations_level","reify","create_fresh_constr","lev","iterator","o$0","is_newtype","non_aliasable","is_instantiable","compatible_paths","expands_to_datatype","mcomp_record_description","type_pairs","mcomp_variant_description","mcomp_list","u2","tl2$0","mcomp_fields","row2","mcomp_row","tl2$1","rest1","miss2","miss1","has_present","k1$0","k2$0","row1","cannot_erase","mcomp","mcomp_for","find_expansion_scope","add_gadt_equation","destination","destination$0","unify_eq_set","order_type_pair","add_type_equality","eq_package_path","nondep_type","package_subtype","concat_longident","lid1","lid2$0","nondep_instance","complete_type_list","fl1","lv2","mty2","fl2","allow_absent","fl1$0","ntl","nt2","nl$0","nl$1","unify_package","unify_list","lv1","ntl2","ntl1","rigid_variants","unify_eq","unify1_var","record_equation","equated_types","unify3_var","unify_kind","make_rowvar","use1","use2","unify_row_field","rm1","rm2","if_not_fixed","fix","either_fixed","redo","remq","tlu2","tlu1","tu","update_levels","rm","f2$0","unify_row","row1_name","row1_closed","row1_fields","row2_name","row2_closed","row2_fields","switch$0","set_more","case$0","tm1","tm2","md1","md2","unify2","unify3","tt1","create_recursion","unify_fields","va","tr1","tr2","reset_tracing","unify_var$0","unify_pairs","unify","expand_head_trace","filter_arrow","function_type","filter_method_field","filter_method_row","priv$1","priv$2","level$1","priv$3","new_class_signature","add_dummy_method","add_method","virt$0","virt$1","virt$2","meths$0","check_mutability","mut$0","add_instance_variable","unify_self_types","sign1","sign2","self_type1","self_type2","failure","inherit_class_signature","failure$0","close_class_signature","generalize_class_signature_spi","new_meths","moregen_occur","may_instantiate","inst_nongen","moregen_kind","moregen_fields","moregen_list","u1","row2_fixed","may_inst","trace$1","moregen","patt","subj","moregeneral","pat_sch","subj_sch","subj_inst","rigidify_rec","rigidify","all_distinct_vars","expand_head_rigid","eqtype_subst","found1","found2","eqtype_kind","eqtype_row","row2$0","row2$1","eqtype_fields","same_row","ty2$1","eqtype_list","eqtype","equal$34","tyl1","tyl2","is_equal","match_class_sig_shape","vr$0","errors$0","errors$1","moregen_clty","cty1","cty2","cty1$0","cty2$1","cty2$0","match_class_types","sign1$0","sign2$0","self1","self2","match_class_declarations","patt_params","patt_type","subj_params","subj_type","clty_params","pred_expand","pred_enlarge","max_change","collect","filter_visited","memq_warn","find_cltype_for_path","cl_abbr","has_constr_row$0","build_subtype","loops","posi","tt","tlist","tt$0","tlist$0","loops$0","tt$1","visited$2","cn","co","tt$2","visited$3","tt$3","level$2","visited$4","tl$2","c$7","enlarge_type","subtypes","subtype_error","unification_trace","subtype_row","subtype_rec","cstrs$1","subtype_list","subtype_fields","p2$2","cstrs$2","snap$0","subtype","trace0","unalias_object","unalias","nongen_schema_rec","nongen_schema","nongen_class_declaration","normalize_type_rec","fields$1","nondep_hash","nondep_variants","clear_hash","nondep_type_rec","expand_private","try_expand","static$0","nondep_field_rec","nondep_type$0","nondep_class_type","nondep_class_declaration","nondep_cltype_declaration","collapse_conj","collapse_conj_params","same_constr$0","immediacy","type_decl","set$11","out_name","printing_env","in_printing_env","human_unique","size$2","show","pp$22","to_lookup","explanations","collect_explanation","root_name","location$0","pp_explanation","print_located_explanations","reset$4","print_explanations","from_toplevel","ltop","conj","pp_namespace_plural","root_names","unique_root_names","submsgs","hid_start","add_hid_id","find_hid","pervasives","map$36","get$11","set$12","protected$0","fuzzy","fuzzy_id","pervasives_name","hid","env_ident","ident_name_simple","hid$0","hid$1","hid$2","ident_name","reset_naming_context","ident$1","ident_stdlib","non_shadowed_pervasive","find_double_underscore","better_lid","rewrite_double_underscore_path","tree_of_path","tree_of_rec","raw_list","kind_vars","kind_count","list_of_memo","print_name","string_of_label","raw_type","raw_type_desc","raw_type_list","raw_field","raw_row_fixed","raw_type_expr","is_nth","apply_subst","set_printing_env","wrap_printing_env","best_type_path","proxy$0","is_non_gen","nameable_row","printer_iter_type_expr","name_subst","name_counter","named_vars","visited_for_named_vars","weak_counter","weak_var_map","named_weak_vars","add_named_vars","px","substitute","add_subst","name_is_already_used","new_name","new_weak_name","name_of_type","name_generator","current_name","remove_names","with_local_names","old_names","old_subst","reserve_names","visited_objects","aliased","delayed","printed_aliases","add_delayed","is_aliased_proxy","add_alias_proxy","add_alias","add_printed_alias_proxy","add_printed_alias","mark_loops_rec","mark_loops","prepare_type","reset_loop_marks","reset_except_context","reset$5","prepare_for_printing","print_labels","tree_of_typfields","tree_of_typexp","tree_of_typobject","tree_of_typlist","present_fields","sorted_fields","pr_typ","name_gen","tyl$1","present","all_present","tyl$2","out_variant","non_gen$0","all_present$0","non_gen$1","tags$0","tyl$3","tyl$4","old_delayed","fl$0","typexp$0","prepared_type_expr","type_expr$1","type_expr_with_reserved_names","type_scheme","type_path$0","tree_of_constraints","filter_params","prepare_type_constructor_argum","tree_of_constructor_arguments","tree_of_label","tree_of_constructor","constructor$1","tree_of_type_declaration","ty_manifest","tree_of_manifest","abstr","tll","vari","is_var","cocn","constraints","unboxed","unboxed$0","ty$4","constructor_arguments$0","extension_constructor_args_and","ext_args","ext_ret_type","tree_of_extension_constructor","ty_params","ty_params$0","es$0","extension_only_constructor","tree_of_value_description","osig_val_decl","prims","for_all$0","all_unboxed","all_untagged","attr_of_native_repr","type_attrs","method_type$0","prepare_method","prepare_class_type","tree_of_class_type","csil$0","all_vars","all_vars$0","csil$1","all_meths","all_meths$0","csil$2","class_type$0","tree_of_class_param","class_variance","tree_of_class_declaration","class_declaration$1","tree_of_cltype_declaration","has_virtual_vars","has_virtual_meths","has_virtual_vars$0","wrap_env","fenv","ftree","with_hidden_items","add_sigitem","tree_of_modtype","ellipsis","direct","structured","collect_trees_of_rec_group","syntactic_group","display","ellipsis$0","tree_of_modtype_declaration","group_trees","tree_groups","functor_param","custom_printer","functor_parameters","modtype$0","incompatibility_phrase","same_path","trees_of_type_expansion","type_expansion","trees_of_trace","trees_of_type_path_expansion","tp","tp$0","type_path_expansion","diff_printing_status","printing_status","prepare_any_trace","clean_trace","prepare_trace","filter_trace","trace_format","keep_last","type_path_list","hide_variant_name","expanded","expanded$0","print_tag","print_tags","is_unit","unifiable","explain_fixed_row_case","mismatch","intro","explain$0","mis","warn_on_missing_def","prepare_expansion_head","empty_tr","ty_exp","head_error_printer","txt_got","txt_but","warn_on_missing_defs","te2","te1","error$5","txt2","ty_expect_explanation","tr$0","tr$1","tr$2","tr$3","head_error","tr$4","report_error$4","type_expected_explanation","report_unification_error","report_equality_error","report_moregen_error","report_comparison_error","printing_status$0","get_diff","diffed_elt","filter_unification_trace","filter_subtype_trace","unification_get_diff","subtype_get_diff","tree_of_modtype$0","tree_of_type_declaration$0","include_err","env$3","lab$0","lab$1","lab$2","lab$3","lab$4","lab$5","lab$6","lab$7","lab$8","lab$9","report_error$5","errs","print_errs","scrape_lazy","scrape","strengthen_lazy_decl","strengthen_lazy","strengthen_lazy_sig","newdecl","manif","newdecl$0","strengthen$0","strengthen_decl","make_aliases_absent_sig","make_aliases_absent","nondep_modtype_decl","nondep_mty","nondep_sig","is_covariant","type_params$0","nondep_mty_with_presence","mty$1","mty$2","var_inv","res_env","mty$3","mty$4","nondep_supertype","nondep_sig_item","enrich_typedecl","orig_decl","orig_ty","new_ty","orig_ty$0","enrich_modtype","type_paths","type_paths_sig","contains_type_sig","contains_type","get_prefixes","get_arg_paths","rollback_path","collect_ids","remove_aliases_sig","remove_aliases_mty","scrape_for_functor_arg","exclude","scrape_for_type_of","remove_aliases","paths","si","lower_nongen","nglev","report_error$6","primitive_descriptions","pd1","pd2","nra1","nra2","nra2$0","is_absrow","choose$3","ord","choose_other","report_type_inequality","pp_record_diff","lbl2","lbl1","report_patch","pr_diff","no_prefix","pp_diff","report_constructor_mismatch","ord$0","pp_variant_diff","got$0","report_type_mismatch","pr$0","item$0","singular","err$4","mismatch$0","err$5","err$6","ord$1","violation","compare_labels","params1","params2","ld1","ld2","equal$35","labels1","labels2","params1$0","params2$0","labels1$0","labels2$0","rem2","rem1","params2$1","params1$1","update$1","key_right","diffing","cstrs_1","cstrs_2","types_match","compare$76","compare_with_representation","rep1","rep2","compare_constructor_arguments","arg2$0","rec_err","compare_constructors","res1","res2","args1","update$2","compare_with_representation$0","cstrs1","cstrs2","cd1","cd2","privacy_mismatch","decl1","decl2","private_variant","missing","tl1$0","pairs$1","to2","tl1$1","ts2","const2","tl2$2","tl1$2","ts2$0","const2$0","tl2$3","tl1$3","type_declarations$0","equality","ty1$2","ty1$1","is_private_abbrev_2","ty1$3","err$9","err$10","err$11","err$7","mark$0","rep2$0","mark$1","usage$0","err$8","need_variance","abstr$0","opn","imp","cn2","co2","j2","extension_constructors","ext1","ext2","structure","str_final_env","str_items","class_infos$0","module_type_declaration","module_declaration","module_substitution","include_infos","incl_mod","class_type_declaration","class_declaration$2","structure_item","str_env","str_desc","rec_flag$0","mb","list$3","cltd","value_description$1","label_decl","ld_type","constructor_args$0","type_kind","type_declaration$1","typ_manifest","typ_kind","typ_cstrs","typ_params","type_declarations$1","type_extension","tyext_constructors","tyext_params","type_exception","tyexn_constructor","extension_constructor$2","ext_kind","pat_env","vto","po","package_type","pack_fields","binding_op","bop_exp","signature$0","sig_final_env","sig_items","signature_item$0","sig_env","sig_desc","tdl","class_description","functor_parameter","mtype","module_type$0","mty_env","mty_desc","mtype2","with_constraint","open_description","open_env","open_declaration","open_expr","module_coercion","pc_env","module_expr","mod_env","mod_desc","mexp2","mexp1","module_binding","mb_expr","class_expr","cl_env","cl_desc","clstr","cl$1","ivars","value_bindings","clty","cl$2","class_type$1","cltyp_env","cltyp_desc","csg","class_signature","csig_fields","csig_self","class_type_field","ctf_desc","ct$0","ct$1","ct2","ct1","ctyp_desc","ctyp_env","pack","class_structure","cstr_fields","cstr_self","row_field$0","rf_desc","object_field$0","of_desc","class_field_kind","class_field","cf_desc","c_rhs","c_guard","c_lhs","value_binding","vb_expr","vb_pat","saved_types","value_deps","add_saved_type","get_saved_types","set_saved_types","record_value_dependency","vd1","vd2","sdiff","negate_mark","mark_positive","value_descriptions","vd2$0","pc","type_declarations$2","decl2$0","expand_modtype_path","expand_module_alias","kind_of_field_desc","field_desc","compare$77","item_ident_name","is_runtime_component","equal_module_paths","equal_modtype_paths","simplify_structure_coercion","id_pos_list","retrieve_functor_params","res$2","res$3","mark_error_as_unrecoverable","check_modtype_equiv","in_eq","mty1","greater_than","signature_components","old_env","paired","sigi2","sigi1","shape_modified","valdecl2","valdecl1","item$5","present_at_runtime","shape_map","present_at_runtime$0","shape_map$5","item$6","tydec2","tydec1","id1$0","item$7","item$8","shape_map$0","ext2$0","id1$1","item$9","item$10","item$2","shape_map$2","pres2","pres1","id1$2","orig_shape","item$21","strengthened_modtypes","shape_map$6","item$11","shape_map$7","item$14","item$12","present_at_runtime$1","item$13","info2$0","info1","id1$3","info2","mty2$0","mty2$1","mty1$0","item$15","item$1","shape_map$1","item$16","id1$4","reason$0","item$17","item$3","shape_map$3","item$18","info2$1","info1$0","id1$5","item$19","item$20","item$4","shape_map$4","deep_modifications","runtime_coercions","signatures","sig1","sig2","exported_len1","runtime_len1","comps1","nextpos","rl$0","runtime_len2","exported_len2","pair_components","item2","name2$0","unpaired$1","item1","subst$1","functor_param$0","param1","param2","cc_arg","id2$0","try_modtypes","mty1$1","mty1$2","subst$0","res_shape","res_shape$0","shape_var","res_shape$1","cc_res","final_res_shape","final_shape","final_res_shape$0","cc_res$0","final_shape$0","got_res","got_params","expected_res","expected_params","res2$0","p2$3","mty1$3","mty2$2","can_alias","check_modtype_inclusion_raw","check_functor_application_in_p","lid_whole_app","prepare_arg","smd","mty_f","lid_app","param_name","weight$1","keep_expansible_param","expand_params","update$3","weight$2","desc1","update$4","param_name$0","modtypes_with_shape","modtypes$0","path_of_context","argname","context_mty","cxt","alt_pp","pp$23","either$1","first_non_id","transposition_under","coerc","transposition","runtime_item","find$13","path$2","mt$4","mt$1","mt$3","ctx$2","mt$2","ctx$1","mt$0","pp_item","pp$24","ctx_printer","buffer$0","is_big","show_loc","show_locs","loc2","loc1","ppx","tmty","elide_if_app","modtype$1","functor_param$1","ua","pp$25","definition","short_mty","qualified_param","definition_of_argument","param_id","pretty_params","prepare_patch","add_shorthand","side","g$0","incompatible","subcase","expansion_token","with_context","dwith_context","dwith_context_and_elision","subcase_list","core","diff$2","symptom","missing_field","module_types","eq_module_types","interface_mismatch","core_module_type_symptom","functor_params","actual","expected$1","functor_suberrors","functor_arg_diff","module_type$4","eqmode","module_type_symptom$0","before$0","signature$1","module_type$1","module_type_symptom","sgs","mts","before$1","mts$0","before$2","mty_diff","functor_app_diff","pp_orig_name","err_msgs","cmts","main$0","register$0","may_print_app","params$1","transl_modtype_longident","transl_modtype","create_package_mty","fake","type_variables","pre_univars","used_variables","reset_type_variables","narrow","gl","widen","validate_name","new_global_var","newvar$0","valid_tyvar_name","styp","transl_type_param","new_pre_univar","make_poly_univars","check_poly_univars","instance_poly_univars","transl_fields","policy","hfields","add_typed_field","add_field","transl_type","ty_init","transl_type_aux","ctyp","ctyp_type","stl","ctys","stl$0","stl$1","unify_param","stl$2","ty$5","ty$6","ty$8","ty$7","fields$2","mkfield","rf_loc","rf_attributes","present$0","ty_tl","nm$0","tfields","fields$3","make_row","ty$9","st$0","new_univars","ty$10","ty_list","ty_list$0","ty$11","ptys","path$3","ty$12","make_fixed_univars","globalize_used_variables","transl_simple_type","uvs","transl_simple_type_delayed","add_name","provided","lab2","lab1","is_cons","pretty_vals","pretty_rest","pretty_arg","vs$0","pretty_car","pretty_cdr","lvs","filtered_lvs","elision_mark","pretty_lvals","vs$1","pretty_or","lbl$0","top_pretty","omegas","omega_list","of_initial","cstr_descr","row_desc","row_desc$0","cst_descr","deconstruct","largs","cstr_row","has_arg","type_row","arity$1","to_omega_pattern","mkloc","lid_loc","arg_opt","omega$0","make_pat","extra_pat","all_coherent","hp1","hp2","first_column","simplified_matrix","is_absent","is_absent_pat","const_compare","records_args","r1$1","r1$2","r1$3","r1$4","compat$0","qs","compats","ps2","op2","ocompat$0","qs$0","qs$1","compat","q2","q1","oq","ocompat","ps$1","equal$36","clean_copy","get_constructor_type_path","simple_match","record_arg","ph","simple_match_args","discr","lbls$0","lbls$1","get_field","discr_pat","pss","rows","read_args","do_set_args","erase_mutable","omegas$0","omega","omegas$1","omegas$2","args$2","set_args","simplify_head_pat","add_column","simplify_first_col","build_specialized_submatrix","extend_row","filter_rec","build_specialized_submatrices","extend_group","insert_constr","q0","insert_omega","initial_constr_group","constr_groups","omega_tails","hp","full_match","should_extend","pat_of_constr","ex_pat","orify_many","pats_of_type","get_variant_constructors","compare$78","complete_constrs","used_constrs","used_constrs$0","others","nonconst","build_other_constrs","build_other_constant","build_other","all_chars","find_other","imax","try_chars","make_other_pat","other_pats","p_res","tag$1","all_lengths","has_instance","lps","has_instances","satisfiable","pss$0","pss$1","qs$2","pss$2","qargs","hq","q0$0","qs$3","pss$3","list_satisfying_vectors","wild","default_matrix","for_constrs","witnesses","do_match","remove_first_column","specialize_and_exhaust","sub_witnesses","p_witnesses","p_row","try_omega","constr_mat","exhaust","try_non_omega$0","try_non_omega","ok$0","partial_constrs","make_rows","remove$9","push_no_or","push_or","push_no_or_column","simplify_first_usefulness_col","make_vector","extract_elements","do_rec","every_satisfiables","pss$4","qs$4","pss$5","qs$5","pss$6","qs1","qs2","r_loc","u2$0","u2$1","le_pat","le_pats","get_mins","le","select_rec","p0","lub$1","lubs","lub","lub_rec","orlub","pressure_variants","tdefs","initial_matrix","initial_only_guarded","mkpat$0","name_counter$0","fresh","typed","cstr_lid","p_opt","subpatterns","pb","pa","contains_extension","do_check_partial","casel","pattern","counter_examples","add_path","collect_paths_from_pat","simplify_first_amb_col","varsets","simpl","head_bound_variables","head_bound_variables$0","head_bound_variables$1","head_bound_variables$2","stable_inter","sv1","sv2","sv","reduce$0","matrix_stable_vars","non_default","submatrices","submat_stable","get_varsets","rows_varsets","stables_in_varsets","check_ambiguous_bindings","cases","check_case","case$1","expr_iter","exp$10","heads","exp_env","exp_extra","exp_desc","cases$0","exp$1","cases$1","exp$2","expo","extended_expression","exp$3","exp2","exp1","expo$0","exp2$0","exp1$0","exp2$1","exp1$1","exp2$2","exp1$2","exp3","exp2$3","exp1$3","exp$4","exp$5","exp$6","exp$7","exp$8","exp$9","mexpr$0","id_exp","id_mod","stable","ambiguous","pps","compute_property","property","required","props","props$0","decls$0","props$1","req","new_prop","compute_property_noreq","get_variance","compute_variance","compute_variance_rec","vari$0","vari$1","compute_same","cvari","cv","weak","make$4","compute_variance_type","check_injectivity","required$0","tvl","ij","fvl","fvl$0","tvl2","vt","concr","for_constr","ld_mutable","compute_variance_gadt","ret_type_opt","fv2","fv1","fv2$0","fv","compute_variance_decl","mn","ftl","mn$0","tll$0","varl","check_variance_extension","compute_decl","eq$1","li1","li2","merge$5","default$3","compute","update_decl","transl_variance","variance_of_params","variance_of_sdecl","sdecl","update_class_decls","cldecls","obj_abbr","obj_id","cltydef","fuel","fuel$0","fuel$1","get_unboxed_type_representatio","compute_decl$0","argrepr","eq$2","merge$6","default$4","compute$0","update_decl$0","check$1","written_by_user","property$0","compare$79","symbol$180","empty$23","immediate_subtypes_object_row","free_variables$0","empty$24","of_opt","merge$7","map1","ms1","ms2","guard","poison","unsafe","safe","find$14","check_type","hyps$0","hyps$1","best_safe","in_map$0","in_map","m_map","hyps","alpha","tys$3","msig","on_param","m_param","tys$2","tys$0","class_ty","tys$1","class_subtys","add_subtype","field_types","on_subtype","best_msig","msig_of_context","decl_loc","parameters","handle_equation","param_instance","set_ind","instance_exis","mode_signature_rev","mode_signature","check_existential","evar","compute_decl$1","eq$3","ts1","merge$8","default$5","compute$1","update_decl$1","type_separability","check$2","property$1","get_unboxed_from_attributes","boxed","add_type$3","update_type","temp_env","is_fixed_type","sd","sty$1","sty$0","set_private_row","make_params","make_param","transl_labels","transl_constructor_arguments","make_constructor","sargs","sret_type","sret_type$0","targs","tret_type","univars$0","targs$0","transl_declaration","tparams","unboxed_attr","bad","unboxed_default$0","unbox$0","unboxed_default","unbox","tkind","scstrs","all_constrs","make_cstr","scstr","tcstr","tcstrs","tkind$0","no_row","man","tman","generalize_decl","check_constraints_rec","check_constraints_labels","pld","check_coherence","dpath","check_well_founded","to_check","parents$0","fini","rec_ok","parents$1","arg_exn","ty0$0","check_well_founded_decl","check_recursion","orig_env","check_regular","cpath","prev_exp","prev_expansions","params0","check_duplicates","sdecl_list","pcd","name_recursion","check_redefined_unit","add_types_to_env","transl_type_decl","fixed_types","sdecls","ids_list","needed","scds","current_slot","warn_unused","ids_slots","old_callback","transl_declaration$0","name_sdecl","tdecls","id_loc_list","foldf","pl_index","styl","styl$0","sr","final_decls","typext_params","sext","svars","ret_type$0","cdescr","cstr_res","ret_type$1","ret_type$2","cstr_type_path$0","cstr_type_params","cstr_types","ext_types","transl_extension_constructor","is_rebind","styext","type_variance","ttype_params","newenv","tyext","transl_type_extension","transl_exception","transl_type_exception","contructor","get_native_repr_attribute","global_repr","make_native_repr","this_iterator","parse_native_repr_attributes","repr_arg","repr_res","repr_args","transl_value_decl","valdecl","typ$0","native_repr_res$0","native_repr_args$0","old_style_float","old_style_noalloc","native_name","noalloc_attribute","noalloc_attribute$0","old_style_noalloc$0","noalloc","native_repr_res","native_repr_args","tydecl","all_unboxable_types","transl_with_constraint","fixed_row_path","sig_decl","sig_decl$0","arity_ok","tparam","type_unboxed_default","new_sig_decl","new_sig_decl$0","new_type_variance","new_type_immediate","new_type_separability","new_sig_decl$1","explain_unbound_gen","ti","explain_unbound","tys_of_constr_args","report_error$7","expansions","defined_as","used_as","pp_expansion","pp_expansions","trivial","pp_evar","scrape_ty","scrape$0","is_function_type","is_base_type","base_ty_path","is_immediate","maybe_pointer_type","maybe_pointer","classify$1","array_type_kind","elt_ty","array_kind","bigarray_decode_type","dfl","mod_id","bigarray_type_kind_and_layout","layout_type","elt_type","value_kind","function_return_value_kind","classify_lazy_argument","is_ref","is_abstracted_arg","classify_path","classify_expression","add_value_binding$0","add_value_binding","equal$37","rank$2","join$8","compose$0","equal$38","find$15","empty$25","join$9","join_list","compose$1","unguarded","remove$10","remove_list","remove_pat","remove_patlist","join$10","empty$26","symbol$181","inner_mode","outer_mode","symbol$182","binder","is_destructuring_pattern","pat$2","m_pat","m_env","pth","extension_constructor$3","class_structure$0","class_field$0","class_expr$0","expression","ce$3","value_bindings$0","ce$4","ce$5","expression$5","case_env","app_mode","pat_modes","pat_envs","env_e","case_env$0","exprs","exprs$0","pth$0","access_constructor","field_mode","field_def","exprs$1","array_mode","ifnot","ifso","cond","cond$0","body$1","pth$1","pth$2","self_path","pth$3","pth$4","mexp","module_binding$0","ext_id","lazy_mode","clsstrct","mexp$0","modexp$0","body$2","binding_op$0","pth$5","open_declaration$0","ext_ids","mb_id","mbs","m_bindings","mids","binding","mid$0","mM","judg_E","class_id","class_ids","ci_expr","included_ids","coe","coe$0","coe$1","bound_env","all_bound_pats","outer_env","binding_env","e_i","x_i","mbody_i","rhs_env_i","mdef_ij","x_j","mutual_modes","env_i","mdef","transitive_deps$0","transitive_deps","mdef_i","bindings_env","binding_env$0","bound_ids","judg_E$0","judg_E$1","bop","class_field_kind$0","cfk","cf","cfk$0","label_name$0","wrong_kind_sort_of_constructor","type_module","type_open","type_open_decl","type_package","type_object","rp","case$2","type_constant","constant$0","constant_or_raise","type_option$0","mkexp$0","exp_type","exp_loc","option_none","cnone","option_some","texp","csome","extract_option_type","extract_concrete_record","extract_concrete_variant","extract_label_names","unify_exp_types","expected_ty","gadt_equations_level$0","get_gadt_equations_level$0","nothing_equated","unify_pat_types_return_equated","refine","unify_pat_types","unify_pat","has_variants","finalize_variants","pattern_variables","pattern_force","allow_modules","module_variables","reset_pattern","allow","enter_variable","is_module","is_as_variable","pv_id","sort_pattern_variables","build_as_type","build_as_type$0","as_ty","ppl","do_label","refinable","solve_Ppat_record_field","label_lid","record_ty","expand_path","compare_type_path","tpath1","tpath2","get_constr_type_path","get_type_path","lookup_from_type","nd","valid_names","unique","ambiguous_types","tpath","others$0","trees","disambiguate_by_type","lbl_tpath","warn_if_ambiguous","warn_non_principal","warn_out_of_scope","path_s","warn_if_disambiguated_name","force_error","disambiguate","expected_type","candidates_in_scope","principal","tpath0","tpl","tp0","lbl$2","lbl$3","lbl$1","lbl$4","lbl$5","lbl$6","wrap_disambiguate","wrong_name","get_name","get_type","lookup_all_from_type","in_env","map_fold_cont","type_label_a_list","type_lbl_a","lid_a_list","labels$0","lbl_a_list$0","lid_a_list$0","lid_a","w_pr","w_amb","w_scope","w_scope_ty","lbl_a_list","labels$1","check_ids","check_closed","amb","fst3","lbl_a_list$1","get_name$0","get_type$0","lookup_all_from_type$0","add_valid","in_env$0","has_literal_pattern","check_scope_escape","save_state","set_state$1","find_valid_alternative","no_explosion","enter_nonsplit_or","pure","category","as_comp_pattern","type_pat_aux","no_existentials","sp","expected_ty$4","type_pat","solve_expected","rp$0","rp$1","rvp","construction_not_used_in_count","inside_nonsplit_or","inside_nonsplit_or$0","must_backtrack_on_gadt","explosion_fuel","constrs$0","ppat$0","ppat","constrs$1","sp$0","explosion","explosion_fuel$0","sq","ty_var","cst$0","gloc$0","spl","expected_tys","spl_ann","sarg","srt","constrs$2","candidates","must_backtrack_on_gadt$0","exs","sp$4","existential_styp","sarg$0","sp$1","sp$2","spl$0","sp$3","expected_ty$0","unify_res","refine$0","name_list","ty_args$0","force$0","ids$0","existential_ctyp","existential_ctyp$0","ty_args$1","ty_args$2","check_non_escaping","sarg$1","expected_ty$3","pat_type","lid_sp_list","expected_type$0","p0$0","record_ty$0","expected_type$1","type_label_pat","make_record_pat","label1","defined","check_defined","labels$2","spl$1","ty_elt","expected_ty$1","sp2","sp1","must_split","split_or","type_pat_result","inside_nonsplit_or$1","inside_nonsplit_or$2","initial_pattern_variables","initial_module_variables","equation_level","outter_lev","type_pat_rec","p1_variables","p1_module_variables","p2_variables","pv_loc","pv_type","p1_vs","p2_vs","unify_vars","p1_vs$0","p2_vs$0","alpha_env","lloc","force$1","expected_ty$2","make_row$0","gloc","row$2","pats$2","pat0","sp1$0","nv","p_exn","p$7","closed_env","partial_pred","explode","typed_p","check_partial","check_unused","refute","spat","refute$0","sfs","sfs$0","pattern$0","iter_pattern_variables_type","add_pattern_variables","check_as","pv_attributes","pv_as_var","type_self_pattern","spat$0","delayed_checks","add_delayed_check","is_nonexpansive$0","pat_exp_list","is_nonexpansive","is_nonexpansive_opt","is_nonexpansive_opt$0","cl_decl","is_nonexpansive_mod$0","is_nonexpansive_mod","id_mod_list","mexp$1","maybe_expansive","check_recursive_bindings","valbinds","idlist","is_prim","funct","prim_name","approx_type","sty$2","type_approx","sexp$5","sty2","sty1","approx_ty_opt","list_labels","ty_fun$0","ty_fun","ls$1","generalize_and_check_univars","ty_expected","exp_ty","check_partial_application","statement","check_statement","doit","self_coercion","contains_variant_either","exists_ppat","contains_polymorphic_variant","may_contain_gadts","proper_exp_loc","name_pattern","name_cases","unify_exp","tfc","is_inferred","check_apply_prim_type","fr","with_explanation","recarg","is_recarg","type_binding_op_ident","cl_num","type_function","in_function","loc_fun","ty_expected_explained","arg_label","caselist","loc_fun$0","separate","unif_err","type_cases","not_nolabel_function","type_andops","sands","let_sarg","rev_sands","sop","op_desc","op_path","op_type","ty_result","ty_rest_fun","ty_op","let_arg","type_expect","andop","existential_context","spat_sexp_list","check_strict","is_fake_let","spatl","type_pat$0","pat_list","pvs","unpacks","new_env$0","attrs_list","is_recursive","sexp_is_fun","rec_needed","warn_about_unused_bindings","pat_slot_list","some_used","check_strict$0","exp_list","type_unpacks","pvs$0","pvb","pat_extra","ty_res_explained","partial_flag","patterns","contains_polyvars","erase_either","may_contain_gadts$0","needs_exhaust_check","outer_level","take_partial_instance","pattern_force$0","half_typed_cases","ext_env","typed_pat","does_contain_gadt","contains_gadt","do_copy_types$1","do_copy_types$0","ty_arg$1","unify_pats","pat_ty","add_row","epss","vpss","ep","vp","exn_pss","val_pss","pat_vars","in_function$0","ext_env$0","ext_env$1","unpacks$0","scond","do_init","ty_arg_check","add_case","exns","exn_cases","val_cases","unused_check","branch_env","sbody","unpack","tunpacks","md_shape","modl","extended_env","exp_attributes","type_statement","type_exp","type_application","result_type","omitted","eliminated_optional_arguments","omitted_parameters","type_unknown_arg","typed_args","ty_fun$1","warned","is_ignore","ty_fun0$1","ty_fun0","sargs$0","ty_fun0$0","ty_fun$2","may_warn","optional","use_arg$0","use_arg","type_argument","eliminate_optional_arg$0","eliminate_optional_arg","remaining_sargs","sargs$1","remaining_sargs$0","commuted","result_ty","ty_expected$0","no_labels","ty_res0","may_coerce","safe_expect","texp$0","var_pair","eta_var","eta_pat","let_var","texp$1","type_label_exp","type_label_access","srecord","type_expect$0","with_explanation$0","rue","cl_num$0","cl_num$1","fmt6_path","is_format","mk_exp_loc","pexp_desc","mk_lid_loc","mk_constr","mk_cst","mk_int","mk_string","mk_char","mk_precision","mk_side","mk_padding","mk_fmtty","sub_fmtty2","mk_int_opt","n_opt","lid_loc$0","mk_counter","cnt","mk_iconv","mk_fmt","iconv$3","iconv$4","iconv$5","iconv$6","pad_opt$9","pad_opt$10","ni","org","org$0","fmting$0","mk_format","width_opt$0","format_parsetree","sbody$0","sval","sbody$1","default_loc","scases","smatch","sbody$2","spat$1","sfunct","lower_args","seen$0","seen$1","type_sfunct","actual_sfunct","funct$0","actual_sfunct$0","caselist$0","caselist$1","sbody$3","sexpl","sarg$2","type_construct","sarg$3","ty_expected0","row0","sarg$4","opt_sexp","lid_sexp_list","opt_exp","expected_opath","opt_exp_opath","ty_record","lbl_exp_list","matching_label","ty_exp$0","unify_kept","ty_res1","ty_arg1","ty_res2","ty_arg2","lbl_exp","label_definitions","label_definitions$0","opt_exp$0","label_definitions$1","present_indices","label_names","missing_labels","num_fields","lbl_repres","lbl_all","snewval","srecord$0","ty_record$0","label_loc","sargl","to_unify$0","argl","sifnot","sifso","sifnot$0","ifso$0","sexp2","sexp1","sbody$4","scond$0","sbody$5","shigh","slow","txt$0","body$3","sarg$5","sarg$6","cty$3","cty$2","cty$4","force$2","valid_methods$0","typ$1","typ$2","meths_ref","ty$15","typ$3","meth$0","cl_num$2","meths$1","valid_methods$1","typ$4","self_path$0","object_type","ty_meth","ty$13","collect_fields","meth_kind","valid_methods","ty$14","cl_path","ty$16","snewval$0","ty$17","cl_num$3","path$4","newval$0","path_self","path_self$0","type_override","modifs","sbody$6","smodl","ty$18","scope$1","new_env$1","body$4","sbody$7","cd$0","body$5","cond$1","ty$19","to_unify$1","sty$3","sbody$8","sty$4","sty$5","cty$5","cty$6","ty$20","ty$21","meths$2","desc$1","sbody$9","ty$22","scope$2","new_env$2","body$6","ety","modl$0","tv$0","newenv$0","od$0","sbody$10","slet","spat_acc$0","ty_acc","spat_acc$1","ty_acc$0","sands$0","spat_acc","ty_acc$1","let_loc","spat_params","ty_func_result","ty_func","ty_andops","scase","desc$2","cd$1","path$5","previous_saved_types","spellcheck$1","unbound_name","type_clash_of_trace","report_literal_type_constraint","const_str","report_expr_type_clash_hints","report_pattern_type_clash_hint","report_type_expected_explanati","expl$0","because","expl_str","report_unification_error$0","valid_idents","sub$0","extra_info","print_label","extra_info$0","eorp","type_name$0","txt3","valid_vars","tr_unif","tr_sub","tr_sub$0","tr_unif$0","keep_first","explanation$2","explanation$3","second_long","reason_str","explanation$4","explanation$5","sort$0","type_expect$1","type_exp$0","type_argument$0","kind_of_final","type_open_descr","unbound_class","extract_constraints","update_class_signature","warn_implicit_public","implicitly_declared","implicitly_public","implicitly_declared$0","implicitly_declared$1","implicitly_declared$2","meths$3","implicitly_public$0","implicitly_public$1","meths$4","implicit_declared","implicit_public","complete_class_signature","complete_class_type","check_virtual","constructor_type","raise_add_method_failure","raise_add_instance_variable_fa","raise_inherit_class_signature_","add_method$0","add_instance_variable$0","inherit_class_signature$0","inherit_class_type","unify_delayed_method_type","type_constraint","val_env","make_method","mkid","delayed_meth_specs","self_scope","scty","cltyp","pcsig","clsig","class_signature$0","scty$0","clty$0","clty$1","psign","self_cty","ctf","mkctf_with_attrs","sparent","returned_cty","new_variables","class_type$2","enter_ancestor_val","enter_self_val","enter_instance_var_val","add_instance_var_met","met_env","class_fields_second_pass","cfs","met_env$4","attributes","super_meths","inherited_vars","met_env$0","met_env$1","attributes$0","already_declared","met_env$2","attributes$1","already_declared$0","override$0","met_env$3","attributes$2","desc$3","attributes$3","warning_state","sdefinition","override$1","label$2","meth_type","attributes$4","desc$4","attributes$5","warning_state$0","sexpr","unit_type","attributes$6","attribute","desc$5","met_env$5","rev_cfs","class_expr_aux","val_env$1","scl","concrs","cl_str","class_structure$1","sfun","class_expr$1","scl$0","val_uid","val_env$0","pv$0","scl$1","remaining_sargs$1","omitted$0","sarg0","scl$2","sdefs","defs","vals$0","scl$3","cl$3","context$0","concrs$0","vals$1","pod","used_slot","new_val_env","new_met_env","cl$4","final$0","par_env","self_loc","self_pat_vars","self_pat","par_env$0","class_fields_first_pass","self_var_kind","concrete_meths","concrete_vals","local_meths","local_vals","init_acc","rev_fields","with_attrs","new_concrete_meths","new_concrete_vals","over_meths","over_vals","concrete_vals$0","concrete_meths$0","inherited_vars$0","par_env$1","super$1","par_env$2","val_env$2","rev_fields$0","local_vals$0","expr$0","local_meths$0","sexpr$0","var_option","approx_declaration","approx_description","temp_abbrev","define_class","dummy_class","constr_type","cl_ty","cl_params","cl_id","obj_ty","obj_params","ty_id","ci_params","coercion_locs","obj_type","obj_params$0","cl_type","cl_params$0","constr$0","cty_variance","cltydef$0","cl_ty$0","cl_params$1","extract_type_decls","merge_type_decls","check_coercions","id_loc","obj_ab","cl_ab","type_classes","approx","cls$0","dummy_cty","class_num","class_declaration$3","class_description$0","class_type_declarations","type_object$0","approx_class","non_virtual_string_of_kind","mets","missings","mets$0","print_reason","mut2$0","mut1$0","path_concat","extract_sig","extract_sig_open","type_open$0","used_slot$0","toplevel$0","ovf","toplevel","unused","warn_shadow_id","warn_shadow_lc","shadowed","cda2","cda1","type_open_descr$0","sod","type_module_type_of_fwd","check_recmod_typedecls","recmod_ids","check_type_decl","row_id","fresh_row_id","sub$1","fresh_row_id$0","fresh_row_id$1","iter_path_apply","path_is_strict_prefix","ident2","ident1","iterator_with_env","mty_body","env_before","check_usage_of_module_types","check_usage_after_substitution","unpackable_modtype","referenced_path","mty_functor","mty_param","sig_item","aliased_path","iterator$0","iterator$1","extract_next_modules","id_mty_l","check_well_formed_module$0","check_signature","params_are_constrained","merge_constraint","initial_env","destructive_substitution","real_ids","split_row_id","srow","merge_signature","namelist","before_group","current$0","commit$0","patch_item","before_group$0","replace_by","outer_sig_env","sg_for_env","ghosts$0","decl_row","id_row","initial_env$0","sig_env$0","tdecl$0","after_ghosts$0","row_id$0","before_ghosts$0","decl_row$0","ghosts$1","after_ghosts","before_ghosts","sig_env$2","newmd$0","mdiff","namelist$0","sig_env$1","newsg","newmd","previous_mty","replacement","how_to_extend_subst","real_path","sub$2","sub$3","map_rec","map_rec_type","map_rec_type_with_row_types","map_ext","approx_modtype_info","sinfo","approx_sig","ssg","ssg$0","srem","approx_module_declaration","pms","sdecls$0","pmd","scope$3","newenv$1","info$0","scope$4","sincl","smty","scope$5","newenv$2","sdecls$1","sres","smod","create$64","check$3","to_be_removed","shadowed_id","check_value","check_type$0","check_module","check_modtype","check_typext","check_class","check_class_type","classify$2","check_sig_item","check_unpackable_modtypes","component","simplify","simplify_item","user_loc","user_id","user_kind","component$0","removed_item_id","removed_item_loc","removed_item_kind","shadower_loc","shadower_id","hiding_error","err_loc","component$1","has_remove_aliases_attribute","transl_modtype_longident$0","mkmty$0","mksig$0","transl_modtype_decl","transl_modtype$0","transl_modtype_functor_arg","transl_sig","sdesc","tdesc","final_env","trem","final_env$0","trem$0","final_env$1","trem$1","final_env$2","trem$2","newenv$3","final_env$3","trem$3","newenv$4","newenv$5","final_env$4","trem$4","newenv$6","final_env$5","trem$5","transl_recmodule_modtypes","newenv$7","decls$1","final_env$6","trem$6","pmtd","newenv$8","final_env$7","rem$7","trem$7","pmtd$0","mtd$0","newenv$9","tmty$0","final_env$8","rem$8","trem$8","newenv$10","final_env$9","rem$9","trem$9","tmty$1","newenv$11","final_env$10","rem$10","trem$10","newenv$12","final_env$11","rem$11","trem$11","sg$2","typedtree","newenv$13","classes$0","final_env$12","rem$12","trem$12","sg$3","typedtree$0","final_env$13","rem$13","trem$13","sarg_opt","t_arg","init_sg","rev_tcstrs","with_info","smty$0","l$6","with_info$0","final_sg","make_env","id_shape","env_c","map_mtys","md_uid","dcl1","dcl2","dcl2$0","tmd","path_of_module","nongen_modtype","enrich_module_type","anchor","package_constraints","modtype_of_package","package_subtype$0","wrap_constraint","explicit","coercion","wrap_constraint_with_shape","simplify_app_summary","app_view","type_one_application","funct_body","funct_shape","md_f","apply_loc","mty_res","mty_f$0","mty_appl","mty_res$0","type_module_aux","sstr","names$0","type_str_item","outer_scope","type_module$0","md_shape$0","sbind","sbind$0","id_opt","mdecl","subst_and_strengthen","first_time","bindings1","mty_actual","mty_actual$0","check_inclusion","mty_decl","mty_decl$0","bindings2","type_open_decl$0","smodl$0","modl_shape","type_struct","pstr","sig_rem","str_rem","finalenv","funct_body$0","funct_shape_param$0","body_shape","strengthen$1","arg_shape","sttn","open_descr","visibility","et","mp","open_descr$0","type_module_alias","type_module$1","type_module_type_of","extend_path","type_package$0","types$0","modules$0","types$1","modules$1","fl$1","type_open_decl$1","type_open_descr$1","main$1","intf_name","intf_name$0","shadowed_item_loc","shadowed_item_kind","shadowed_item_id","shadowed_item_kind$0","user_loc$0","user_kind$0","user_id$0","opened_item_kind","opened_item_id","opened_item_kind$0","cons$3","scopes","enter_anonymous_function","enter_module_definition","string_of_scopes","of_location","to_location","const_int","const_unit","max_arity","lfunction","lenvs","attr$1","make_key","tr_sw","tr_opt","tr_rec","tr_recs","ap","ex$0","ex$1","ex$2","ex$3","ex$4","ex$5","sw","sw$0","es$1","name_lambda","iter_opt$0","free_variables$1","free_variables_list","failaction","set$1","set$2","raise_count","next_raise_count","is_guarded","patch_guarded","lam","ev","lam$0","transl_address","transl_path","transl_module_path","transl_value_path","transl_extension_path","transl_class_path","transl_prim","mod_name","pers","update_env","input_lam","freshen_bound_variables","bind_many","subst_opt","subst_case","subst_list","evt","find_in_old","update_free","env_updates","bind_with_value_kind","bind$17","struct_const","sc1","sconsts","floats","array_kind$0","boxed_integer_name","value_kind$0","bi","return_kind","field_kind","print_boxed_integer","print_bigarray","record_rep","block_shape","primitive","bi$5","bi$6","bi$7","bi$8","bi$9","bi$10","bi$11","layout$0","unsafe$0","unsafe$1","unsafe$2","unsafe$3","unsafe$4","unsafe$5","unsafe$6","unsafe$7","unsafe$8","unsafe$9","unsafe$10","unsafe$11","unsafe$12","unsafe$13","unsafe$14","unsafe$15","const_name","bi$12","ptr","ptr$0","instr$0","init$4","bi$0","bi$1","bi1","bi$2","bi$3","bi$4","function_attribute","apply_tailcall_attribute","apply_inlined_attribute","apply_specialised_attribute","lams","pr_params","id_arg_list","spc","lams$0","larg","switch$1","lams$1","lhandler","lbody","lhandler$0","lbody$0","lelse","lif","lcond","lbody$1","lcond$0","largs$0","expr$1","let_kind","get_act","too_much","less_tests","less2tests","add_test","coupe","coupe_inter","i$5","lcases","act2","i$4","got_it","act","act0","make_one","make_rec","same_act","ok_inter","enum$0","best_cost","cm","opt_count","cright","cmr","with_sep","rlow","rhigh","best_cost$0","outside","cmij","cij","with_inter","ihigh","ilow","rlow$0","rhigh$0","best_cost$1","outside$0","high$0","low$0","coutside","cmo","cmij$0","cij$0","heuristic","divide","act1","cinter","cinter$0","make_if_test","do_make_if_out","ifno","do_make_if_in","c_test","actions","ifnot$0","mk_ifno","mk_ifso","mk_ifno$0","mk_ifso$0","ifnot$1","ifso$1","ifnot$2","ifso$2","ifnot$3","ifso$3","ifnot$4","ifso$4","do_zyva","old_ok","min_clusters","get_min","ntests","ntests$0","act3","h3","l3","n_clusters","bidon","get_index$0","ir$1","j$2","ir","act$1","get_index$1","get_index","act$0","kk","acts","act$2","ir$0","acts$0","clusters","abstract_shared","handlers","actions$0","oh","zyva","actions$1","hs","test_sequence","mk_store","mustshare","store","shared","get_shared","may_compat","may_compats","all_record_args","expand_record_head","bind_alias","head_loc","map_on_row","map_on_rows","simpl_under_orpat","all_lbls","head$1","add_omega_column","rev_split_at","matcher","discr$0","yes","no","yesif","ncols","lshift","lforget","rshift","combine$4","empty$27","is_empty$10","lshift$0","rshift$0","rshift_num","shifted","combine$5","specialize","non_empty","select_columns","lub_row","transfer","lub_with_ctx","lub$0","union$4","qss","flatten_pat_line","flatten_matrix","default$6","cons$4","matrix","raise_num","specialize$0","filter_rec$0","filter_rec_or","specialized","matches","filter_one","specialize$1","remove$11","empty$28","is_empty$11","singleton$1","union$5","pss2","pss1","merge$9","envs","unions","envs$0","envs$1","map$37","compare_key$1","make_exit","as_simple_exit","make_catch_delayed","raw_action","same_actions","key0_opt","safe_before","act_p","act_q","key2","key1","half_simplify_nonempty","continue$1","stop$0","full_view","orpat","what_is_cases","skip_any","can_group","pat_cstr","omega_like","simple_omega_like","equiv_pat","extract_equiv_head","safe_below","as_matrix","split_no_or","group_discr","insert_split","yes$0","precompile_group","precompile_var","do_not_precompile","nexts","def$0","idef","do_split","not_e","rev_no$1","rev_ors$1","ors","nexts$1","def$1","do_cases","compat_matcher","pm_fv","patbound_action_vars$0","or_num","new_patl","patbound_action_vars","aliases","split_explode","fresh_clause","arg_id","rem_vars","pat_id","action_vars$2","action_vars$1","fresh_id","action_vars$3","renaming_env$1","alpha_pat$0","argo","fresh_pat","fresh_action","new_cases","rem_handlers","rem_cases","new_to_catch","new_ord","matrix$0","rargs","var_args","var_cls","var_def","rebuild_matrix","pmh","rfirst","rnexts","split_and_precompile_half_simp","make_matching","get_expr_args","add_in_div","make_matching_fun","eq_key","patl_action","division","cells","get_key","get_pat_args","divide_line","make_ctx","submatrix","get_pat_args_var","get_expr_args_var","divide_constant","get_key_constr","get_pat_args_constr","divide_var","get_pat_args_lazy","prim_obj_tag","get_mod_field","mod_ident","code_force_lazy_block","inline_lazy_force","idarg","varg","tag_var","force_fun","record_matching_line","patv","get_key_array","get_pat_args_array","handle_shared","ohs","share_actions_tree","handle_shared$0","sw$1","uniq_lambda_list","sw2","sort_lambda_list","do_tests_fail","tst","do_tests_nofail","make_test_sequence","lt_tst","const_lambda_list","const_lambda_list$0","const_lambda_list$1","list2","list1","make_prim","make_offset","bind$18","make_const","make_isout","make_isin","make_is_nonzero","arg_as_test","make_if","make_switch","sort_int_lambda_list","as_interval","do_store","fail_rec","cur_low","act_i","nofail_rec","cur_act","act_index","store$0","i_rec","inters","call_switcher","int_lambda_list","edges","list_as_pat","mk_failaction_neg","split_cases","tag_lambda_list","split_rec","cstr_tag","nonconsts","call_switcher_variant_constr","event_branch","lam$1","lam$2","compile_orhandlers","compile_fun","lambda1","total1","to_catch","mat","total_i","handler_i","compile_test","to_match","c_rec","totals","new_discrs","c_rem","c_div","approx_present","vv","lower_bind","pcond","pso","pnot","comp_exit","comp_match_handlers","comp_fun","first_match","next_matchs","first_match$0","next_matchs$0","next_matchs$1","first_match$1","first_lam","total_rem","ctx_i","do_compile_matching","combine_handlers","compile_match","pmh$0","total$0","first_arg","compile_no_test","descr_lambda_list","tag_lambda","local_jumps$0","fail$5","nonconsts$0","consts$1","fail$6","nonconsts$1","consts$2","tests","nonconst_lambda","lambda1$0","ncases","nconstrs","sig_complete","local_jumps","fails","fail_opt","constr_of_pat","cstr_pat","fail_pats","to_test$0","to_test","p_ctx","later","jumps","klist","klist$0","jumps$0","jmps","fail$3","fail$4","descr_lambda_list$0","consts$0","fail$2","hs$0","i_max","cstr1","cstr2","make_field_accesses","binding_kind","first_pos","make_args","int_lambda_list$0","access","num_constr","test_int_or_block","if_int","if_block","one_action","lam_const","lam_nonconst","pato","len_lambda_list","up_ctx","this_ctx","this_match","compile_match_nonempty","is_lazy_pat","is_record_with_mutable_field","check_partial$0","pat_act_list","check_total","failer","exn_lam","toplevel_handler","compile_matching","for_function","for_trywith","simple_for_let","map_return","map_cases","l2$2","l1$2","l2$3","l1$3","lthen","l2$4","l1$4","flatten_pm","flatten_precompiled","param_to_var","bind_opt","for_multiple_match","paraml","v_paraml","paraml$0","pm1","pm1_half","idl","flat_next","flat_nexts","oo_prim","share","cache_required","wrapping","top_env","method_ids","oo_wrap","lambda$0","is_inline_attribute","is_inlined_attribute","is_specialise_attribute","is_specialised_attribute","is_local_attribute","is_poll_attribute","find_attribute","other_attributes","inline_attribute","get_payload","get_from_exp","get_optional_payload","get_id_from_exp","get_int_from_exp","get_bool_from_exp","parse_id_payload","parse_inline_attribute","parse_specialise_attribute","get_inline_attribute","check_local_inline","check_poll_inline","check_poll_local","lfunction_with_attr","add_inline_attribute","inline","get_and_remove_inlined_attribu","inlined","get_and_remove_specialised_att","specialised","get_tailcall_attribute","is_tailcall_attribute","tailcalls","tailcall_attribute","check_attribute_on_module","add_function_attributes","attr$7","specialise","attr$2","local","attr$3","is_tmc_attribute","attr$4","payload$0","poll","attr$5","attr$6","used_primitives","prim_sys_argv","primitives_table","lookup_primitive","lookup_primitive_and_mark_used","glb_array_type","specialize_primitive","has_constant_constructor","param_tys","useful","knd","array_type","arity$2","array_type$0","arity$3","array_type$1","arity$4","array_type$2","p1$3","arity$5","array_type$3","p1$4","arity$6","p1$5","arity$7","p1$6","caml_equal$0","caml_string_equal$0","caml_bytes_equal$0","caml_notequal$0","caml_string_notequal$0","caml_bytes_notequal","caml_lessequal$0","caml_string_lessequal$0","caml_bytes_lessequal$0","caml_lessthan$0","caml_string_lessthan$0","caml_bytes_lessthan$0","caml_greaterequal$0","caml_string_greaterequal$0","caml_bytes_greaterequal","caml_greaterthan$0","caml_string_greaterthan$0","caml_bytes_greaterthan","caml_compare$0","caml_string_compare$0","caml_bytes_compare$0","comparison_primitive","comparison_kind","lambda_of_loc","cnum","scope_name","caml_restore_raw_backtrace$0","try_ids","add_exception_ident","remove_exception_ident","lambda_of_prim","arg_exps","vexn","raise_arg","obj$0","meth$1","obj$1","prim$0","prim$1","prim$2","transl_primitive","lambda_primitive_needs_event_a","transl_primitive_application","report_error$8","prim_name$0","transl_module","rootpath","transl_object","prim_fresh_oo_id","transl_extension_constructor$0","extract_constant","extract_float","wrap_bindings","binds$0","trivial_pat","use_lhs","bindings$0","use_lhs$0","cases$2","bindings$1","cases$3","cases$4","cases$5","bindings$2","pure_case","event_before","event_function","assert_failed","cut","iter_exn_names","transl_ident","transl_case_try","transl_guard","transl_cases_try","pure_module","transl_exp$0","transl_exp1$0","in_new_scope","eval_once","transl_exp0$0","transl_exp0","pat_expr_list","transl_exp","transl_let","scopes$0","transl_function","oargs$0","prim_type","transl_list","prim_exp","funct$2","tailcall$0","funct$3","inlined$0","specialised$0","transl_apply","oargs","tailcall","funct$1","pat_expr_list$0","transl_match","pat_expr_list$1","transl_list_with_shape","ll$0","is_const","no_init","copy_id","update_field","cont","init_expr$0","init_id","field_kind$0","ll$2","lam$4","init_expr","targ","expr_list","ll$1","imm_array","imm_array$0","expr2","expr1","self$0","path_self$1","self$1","transl_setinstvar","path_self$2","self$2","cpy","mod_scopes","defining_expr","lam$3","modl$1","partial$1","body$7","transl_letop","oid","body$8","in_structure","transl_case","vb_loc","vb_attributes","transl_bound_exp","lam_bds","transl","mk_body","nraise","catch_ids","ids_with_kinds","catch_ids$0","collect_const","pat_ids","fresh_ids","rev_sublets","add_ids","push_sublet","should_introduce_scope","transl_scoped_exp","transl_exp1","transl_tupled_function","other_cases","transl_curried_function","max_arity$0","ldps","transl_with_shape","lapply","lobj","lmet","lobj$0","lmet$0","build_apply","optional$0","args$3","handle","id_arg","rewrite_case","static_handlers","exn_pat","val_pat","pe","static_raise","ids_full","ids_kinds","vids","val_case","pe$0","exn_case","static_catch","scrutinees","val_ids","static_exception_id","lvars","classic","val_id","prev_lam","left_id","right_id","report_error$9","lfunction$0","ap$0","mkappl","lsequence","lfield","transl_label","transl_meth_list","set_inst_var","transl_vals","bind_super","cl_init","name_pattern$0","build_object_init","cl_table","inh_init","obj_init","obj_init$0","inh_init$0","path_lam","has_init","obj_init$1","inh_init$1","obj_init$2","obj_init$3","inh_init$2","build","oexprs","obj_init$4","inh_init$3","obj_init$5","inh_init$4","output_methods","bind_id_as_val","build_class_init","msubst","cl_init$0","cl_init$1","over","values$0","met_code","cl_init$2","methl","nvals","getter$0","cl_init$3","cl$5","cl$6","cl_init$4","vals$2","vals$3","cl$7","narrow_args","path_lam$0","inh","methids","valids","cl_init$5","cl_init$6","cl_init$7","inh_init$5","cl$8","build_class_lets","vf","cl_loc","path_lam$1","path_lam$2","path_lam$3","check_constraint","transl_class_rebind_0","transl_class_rebind","obj_init0","new_init","builtin_meths","const_path$0","const_path","enter","args$4","met$0","args$5","builtin_meths$0","builtin","transl_class","vflag","top_env$0","llets","new_ids","meth_ids","new_ids$0","fv$0","fv$1","e2$4","e1$4","new_ids$1","fv$2","new_ids_meths","no_env_update","new_ids_init","env1$0","copy_env","pub_meths$0","rev_map","ltable","concrete","cached","lenvs$0","menv","menv$0","linh_envs","def_ids","inh_paths","inh_keys","lset","lupdate_cache","lcheck_cache","lenv","report_error$10","functor_path","field_path","wrap_id_pos_list","apply_coercion","oldid","newid","restr","pos_cc_list","carg","cc_res$1","cc_arg$0","pc_type","pc_desc","compose_coercions","ids2","pc2","ids1","primitive_declarations","mod_prim","undefined_location","init_shape","init_shape_struct","init_v","not_a_function","subid","init_shape_mod","minfo","transl_structure","mk_lam_let","ext_fields","val_loc","subscopes","module_body","transl_module$0","module_body$0","size$3","module_body$1","ext_fields$0","size$4","mb_name","id_or_ignore_loc","id_or_ignore_loc$0","num_bindings","emit_binding","cycle","patch_forwards","bind_strict","rhs$0","bind_inits","ids$1","rebind_idents","newfields","size$5","cl_list","class_bindings","size$6","ids$2","rebind_idents$0","size$7","size$9","ids$3","id_pos_list$0","size$10","body$9","cc$0","res_coercion","body_path","functor_params_rev","attr2","res_coercion$0","arg_coercion","res_coercion$1","arg_coercion$0","ccarg","get_and_remove","mod_expr","mod_attributes","mc","mtc","inner_attr","mod_desc$0","inlined_attribute","ccarg$0","cc$1","print_cycle","explanation_submsg","unsafe_info","arguments$0","print_msg","submgs","arguments$1","print_msg$0","submgs$0","report_error$11","report_error$12","cmd$0","map$38","raise_errorf","fixity_of_string","first_is","last_is","needs_parens","needs_spaces","protect_ident","view_expr","is_simple_construct","under_semi","ctxt","list$4","fu","option$0","print_longident$0","longident_loc","constant$1","mutable_flag","virtual_flag","nonrec_flag","direction_flag","private_flag","constant_string","tyvar_loc","module_type$5","mt1","module_type$2","module_type1","mt2$0","type_declaration$2","li$0","li$1","ls$2","li2$0","li$2","module_type1$0","signature_item$1","module_expr$0","extension","sugar_expr","label_x_expression_param","simple_expr","expression2","eo$1","l$7","string_x_expression","case_list","e0","label_exp","extension_constructor$4","binding_op$1","expression_under_ifthenelse","class_structure$2","expression2$0","simple_expr$0","longident_x_expression","df","cto1","pattern$6","pattern1$0","pattern_list_helper","pat2","pat1","simple_pattern","pattern1","simple_pattern$0","longident_x_pattern","with_paren","simple_name","constructor_declaration","core_type1","record_declaration","constructor_declaration$0","type_record_field","type_param","structure_item$0","item_attributes","value_description$2","type_def_list","type_extension$0","exception_declaration","me$1","pmb","class_constraint","class_type$3","class_expr$2","class_params_def","class_type_declaration_list","floating_attribute","item_extension","binding$0","pp_print_pexp_function","tyvars_str","tyvars","args_tyvars","gadt_pattern","gadt_exp","tyvars$0","e_ct","e_tyvars","pt_ct","pt_tyvars","tyvars$1","exported","so","ovf$0","ovf$1","mf","vf$0","pf","type_with_label","print_indexop","path_prefix","print_index","indices","rem_args","other_args","i3","i1$0","i1$1","core_field_type","field_var","first_is_inherit","type_variant_helper","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","x1$1","copy_rec_flag","copy_arg_label","copy_constructor_arguments","copy_core_type","copy_label_declaration","copy_extension_constructor","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_override","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","copy_class_field","pmty_attributes","pmty_loc","pmty_desc","copy_with_constraint","pmod_attributes","pmod_loc","pmod_desc","copy_expression","copy_binding_op","copy_expression_desc","copy_value_binding","copy_case","x1$7","x2$1","x1$8","x2$2","x1$9","x1$10","x1$11","x0$16","x3$0","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","copy_value_description","pval_prim","copy_variance","copy_injectivity","copy_private_flag","copy_type_extension","ptyext_private","copy_type_exception","copy_module_type_declaration","copy_include_infos","copy_module_binding","pstr_desc","copy_type_declaration","copy_class_declaration","copy_class_type_declaration","copy_virtual_flag","copy_class_infos","pci_params","pci_virt","copy_class_expr","copy_open_description","pcty_attributes","pcty_loc","pcty_desc","copy_class_type_field","pcl_attributes","pcl_loc","pcl_desc","copy_mutable_flag","copy_class_field_kind","pcf_attributes","pcf_loc","pcf_desc","ptype_private","copy_constructor_declaration","copy_module_declaration","psig_loc","psig_desc","copy_class_description","pctf_attributes","pctf_loc","pctf_desc","pld_mutable","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$1","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","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","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","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","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","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","migration_identity","compose$2","migration_functions","is_undefined","immediate_migration","A","direction","funs","B","To","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$0","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","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","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","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","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","loc_ghost","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","all$4","lookup$1","drv","compare$80","equal$39","protectx$0","add$26","add_exn$3","find_opt$1","of_alist$5","alist$0","f$10","read_all_into","map$41","fold_right$6","symbol$183","concat$4","is_empty$12","filter_map$9","concat_map$2","assoc_opt","iter$32","is_some$2","map$42","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","raise_errorf$0","enter_module","enter_value$0","module_name$30","enter_opt","self_7","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","line_min","distance","spellcheck$2","registered_name","names_at_best_distance","best_distance","suggestions","rev_rest","ptyp_constr","pexp_ident","pexp_constant","pexp_let","pexp_fun","pexp_construct","pexp_variant","pexp_record","include_infos$0","ppat_any","ppat_variant","ppat_record","pstr_eval","pstr_value","value_binding$0","short_name","name$92","flatten_exn","unflatten","parse$3","map$44","pexp_tuple","ppat_tuple","pexp_apply","unapplied_type_constr_conv_wit","suffix_n","functor","functor_args","functor$0","get$12","fold_dot_suffixes","collapse_after_at","parts","parts$1","parts$0","make$5","create_set","fully_qualified_names","list$5","is_whitelisted","reserve","is_in_reserved_namespaces","ignore_checks","create$65","current_file","string_of_context","get_all_for_context","check_collisions_local","all_for_context","declared_at","check_collisions","register$1","raise_errorf$1","white_list","white_list$0","all$0","other_contexts","current_context","a_or_an","rev_others","nmeths","pstr_eval$0","restore_context","parse$4","on_error","symbol$184","symbol$185","map$45","many","rtag","get_pstr_eval","get_pstr_extension","get_psig_extension","get_attributes","get_attribute_if_is_floating_n","dummy_ext","name$93","registrar","declare","not_seen","mark_as_seen","do_mark_as_seen","get$13","longest_match","longest_match$1","longest_match$0","name$94","declare$0","convert$0","check_attribute","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","dump","parse_string","match_loop","mismatch_handler","source$0","source$1","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","convert$1","convert_inline","filter_by_context","expanders","expanders$0","split_normal_and_expect","split_normal_and_expect$0","filter$7","extension$0","attr_str_type_decl","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","rev_concat","sort_attr_group_inline","sort_attr_inline","context_free_attribute_modific","handle_attr_group_inline","expanded_items","expect_items","handle_attr_inline","expanded_item","expect_mismatch_handler","exp_tds","exp_rf","tds","extra_items","with_extra_items","exp_te","extra_items$0","expect_items$0","exp_ec","extra_items$1","expect_items$1","exp_mtd","extra_items$2","expect_items$2","original_rest","repl","pexp_attributes$1","func$0","pexp_attributes$2","expand_constant","rules","special_functions","special_functions$0","extensions","ppx_import","attr_sig_exceptions_expect","attr_sig_exceptions","map_node","ctxt$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$5","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","rules$1","new_fn","old_fn","parse_apply_list","mask$1","handle_apply","handle_dont_apply","set_cookie","shared_args","pretty","vars_of","st$2","st$1","add_dummy_user_for_values","fp","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","create$66","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","resolve_all","derivers","derivers_and_args","named_generators","actual_deriver_name","dep","dep_name","add$28","extension$1","actual_deriver","deriver","invalid_with","generator_name_of_id","f$11","mk_deriving_attr","generator_name","disable_warnings_attribute","warning","inline_doc_attr","wrap_str","hide","warnings$0","warnings$2","warnings$1","wrap_sig","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","weight_attribute","weight$3","core_type_list","label_decl_list","pattern$2","expression$1","create_list$0","salt$0","location$1","weight_attribute$0","weight$4","core_type_list$0","pattern$3","expression$2","create$67","location$2","pattern$4","expression$3","create$68","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","Field","variant$2","variant_type","clauses","Clause","clauses$0","clause","empty$30","lookup$2","of_alist$6","variance_error","create_with_variance","contravariant","param_list","injectivity","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","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","impls","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","generator_extension","observer_extension","shrinker_extension","arg0","xs$2","xs$3","v3","v_transaction","v_network","v_patch","transaction_field","network_field","patch_field","patch_value","network_value","transaction_value","transaction","of_string_exn","is_digit_string","of_string_opt","proposed_protocol_version_opt","set_proposed_opt","t_opt","get_proposed_opt","compatible_with_daemon","monster_int","biggest_int","least_int","length_nat","make_nat","a_2","a_1","b_2","copy_nat","off_set","is_zero_nat","is_nat_int","int_of_nat","nat_of_int","power_base_max","max_power_10_power_in_int","raw_string_of_digit","leading_digits","unadjusted_string_of_nat","len_nat","len_copy","copy1","copy2","rest_digit","string_of_nat","zero_big_int","unit_big_int","num_digits_big_int","num_bits$5","lz","compare$81","equal$40","symbol$186","symbol$187","size_bi1","size_bi2","of_int$7","symbol$188","symbol$189","size_res","quomod_big_int","bi1_negatif","size_r","not_null_mod","new_r","symbol$190","symbol$191","monster_big_int","to_int_exn$1","to_string$41","sys_big_int_of_string_aux","sgn","power_base","pint","pmax","current_len","possible_len","digits_read","erase_len","sys_big_int_of_string_base","of_string$43","shift_left$6","size_bi","ndigits","shift_right_towards_zero_big_i","shift_right$6","log_and","size_a","size_b","log_or","or_aux","two_to_the_i","compare$82","is_integer_string","char_is_digit","of_string_base","of_string_no_underscores","group$74","bin_shape_t$72","bin_size_t$28","bin_write_t$30","bin_read_t$59","bin_read_t$60","arg_1$0","to_binable$6","of_binable$6","t_of_sexp$52","sexp_of_t$68","bin_size_t$29","bin_write_t$31","bin_read_t$61","bin_read_t$62","bin_shape_t$73","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$5","bits$3","extra_bytes","num_bytes","hash$46","to_string$43","char_is_hex_digit","of_hex_string_no_underscores","of_string$45","module_name$32","func$11","func$12","of_binable$7","write","simple$1","sync","set_sync_implementation","simple$2","read$0","write$0","var_to_bits","equal$41","rhs1","rhs0","lhs1","lhs0","of_interval","canonicalize","a4","a3","disjoint_union_exn","of_intervals_exn","is$0","invariant$11","gen_from","min_size","gen_disjoint_pair","y0","y3","cvar_of_sexp","of_f","sexp_of_cvar","of_index","var$7","bind$1","return$2","unhandled","run$2","req$1","create_single","request","bind$19","return$19","run$3","map2$4","read_var","read$1","value_of_fields","var_to_fields","field_vars","map$46","symbol_bind$6","symbol_map$4","bind$20","return$20","map$47","join$11","ignore_m$0","all$6","all_unit$0","run$4","rc$0","value$5","case$3","sexp_of_basic","of_basic","unhandled$0","sexp_of_t$69","t_of_sexp$53","to_basic$0","map$48","get_value","override_label","label_opt","basic","equal$42","boolean$0","r1cs","annotation","unit$0","create$69","get$14","emplace_back","length$25","dummy_vector","get$15","T","make$6","num_inputs","next_auxiliary","system","eval_constraints","log_constraint","with_witness","is_running","eval_constraints$0","my_id","get_variable_value","store_field_elt","alloc_var","as_prover","set_as_prover","set_stack","set_handler","constraint_count","assert_equal","assert_all","assert_square","assert_r1cs","assert","with_label","handle_as_prover","exists_handle","request_witness","mk_lazy","create$70","stack_to_string","eval_constraints_ref","run$5","return$21","map$49","bind$21","symbol_bind$7","symbol_map$5","bind$22","return$22","map$50","join$12","ignore_m$1","all$7","all_unit$1","field_vec_id","pack_field_vec","field_vec","run_and_check_exn","get_one","final_id","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","next_input","primary_input","input_typ$0","return_typ$0","return_typ","input_typ","alloc_input","constraint_system_auxiliary","size_in_field_elements","var_of_fields","retvar","return_typ$1","input_typ$1","checked","run_computation","finish_computation","retvar$0","auxiliary_input_size","constraint_system","builder","generate_public_input","value_to_fields","store_field_elt$0","receive_public_input","input_var","output_var","first_auxiliary","auxiliary_input","finish_witness_generation","auxiliary_output_data","res_fields","output_fields","res_field","output_field","true_output","cont0","k0","generate_auxiliary_input","generate_witness_conv","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_exn$0","snarkless","transport","there","back","transport_var","auxes","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","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","to_field","of_field","to_bits","ith_bit","if$0","then","else$0","t_of_sexp$54","non_empty_tree_of_sexp","tree_of_sexp","implied_root","entry_hash","addr0","path0","let_syntax_001","fetch_and_update_req","prev_path","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$0","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","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","assert$0","exists$1","join$0","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_unchecked","num_true","any$0","any$1","all$1","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","unpack_flagged","lo_bigint","hi_bigint","gen_uniform","parity","square$0","sqrt","quadratic_nonresidue","sqrt_check","is_square","typf","answer","alpha_packed","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","scale$1","scale$2","terms$1","to_constant_and_terms","neg_one","linear_combination","terms","var_indices","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","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","request$0","provider","custom_printf_002","bind$2","return$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","bind$3","return$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","in_prover","in_checked_computation","as_stateful","make_checked","size_in_bits","of_int","sqrt$0","is_square$0","size_in_bits$0","random$0","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","equal$5","eval_as_prover","in_prover_block","of_int$2","one$2","mul$2","inv$2","square$2","sqrt$2","is_square$2","size_in_bits$1","print$1","random$1","negate$1","symbol$19","symbol$20","unpack$2","project$1","parity$2","run_prover","mark_active","counters","mark_active_deferred","inject_wrapper","finalize_is_running","cached_state","constraint_system_manual","cached_active_counters","run_circuit","circuit","return_var","generate_witness_manual","as_prover_manual","size_to_witness","old_as_prover","values_to_witness","values_to_witness$0","request_manual","unit_request","prover_block","this_functor_id","run_checked","to_int$6","of_int$9","add$29","eq$4","create$71","N","pi","t_plus_n","compare$83","lte_exn","eq$5","eq_exn","num_commitments_without_degree","to_nat","contr","singleton$2","func$13","length$26","func$14","hhead_off","xss$0","tls","hds","mapn","nth$6","idx$0","idx$1","zip","to_list$9","to_array$4","init$27","map$51","of_list$7","of_list_and_length_exn","of_array_and_length_exn","fold$18","for_all$9","foldi$4","reduce_exn$1","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","of_list_exn","there$0","back$0","append$5","adds","adds$0","rev$1","split$6","transpose","tails","trim_front","extend_front_exn","extend_exn","extended","extend_front","bin_shape_t$74","bin_size_t$30","bin_write_t$32","bin_read_t$63","compare$84","hash_fold_t$38","equal$43","to_yojson$1","t_of_sexp$55","sexp_of_t$70","bin_shape_t$75","bin_size_t$31","bin_write_t$33","bin_read_t$64","bin_read_t$65","compare$85","hash_fold_t$39","equal$44","to_yojson$2","of_yojson$1","t_of_sexp$56","sexp_of_t$71","compare$86","hash_fold_t$40","equal$45","to_yojson$3","of_yojson$2","t_of_sexp$57","sexp_of_t$72","bin_shape_t$76","bin_size_t$32","bin_write_t$34","bin_read_t$66","compare$87","hash_fold_t$41","equal$46","to_yojson$4","of_yojson$3","t_of_sexp$58","sexp_of_t$73","compare$88","hash_fold_t$42","equal$47","to_yojson$5","of_yojson$4","t_of_sexp$59","sexp_of_t$74","to_list$10","bin_shape_t$77","bin_size_t$33","bin_write_t$35","bin_read_t$67","compare$89","hash_fold_t$43","equal$48","to_yojson$6","of_yojson$5","t_of_sexp$60","sexp_of_t$75","compare$90","hash_fold_t$44","equal$49","to_yojson$7","of_yojson$6","t_of_sexp$61","sexp_of_t$76","bin_shape_t$78","bin_size_t$34","bin_write_t$36","bin_read_t$68","compare$91","hash_fold_t$45","equal$50","to_yojson$8","of_yojson$7","t_of_sexp$62","sexp_of_t$77","to_yojson$9","of_yojson$8","bin_shape_t$79","bin_size_t$35","bin_write_t$37","bin_read_t$69","compare$92","hash_fold_t$46","equal$51","to_yojson$10","of_yojson$9","t_of_sexp$63","sexp_of_t$78","compare$93","equal$52","t_of_sexp$64","sexp_of_t$79","of_list_exn$0","bin_shape_t$80","bin_size_t$36","bin_write_t$38","bin_read_t$70","compare$94","hash_fold_t$47","equal$53","to_yojson$11","of_yojson$10","t_of_sexp$65","sexp_of_t$80","compare$95","hash_fold_t$48","equal$54","to_yojson$12","of_yojson$11","t_of_sexp$66","sexp_of_t$81","bin_shape_t$81","bin_size_t$37","bin_write_t$39","bin_read_t$71","compare$96","hash_fold_t$49","equal$55","to_yojson$13","of_yojson$12","t_of_sexp$67","sexp_of_t$82","compare$97","hash_fold_t$50","equal$56","to_yojson$14","of_yojson$13","t_of_sexp$68","sexp_of_t$83","F","to_yojson$15","poly_f","symbol$204","group$75","bin_shape_t$82","bin_size_t$38","size_of_f","bin_write_t$40","write_f","bin_writer_t$38","bin_writer_f","bin_read_t$72","bin_read_t$73","bin_reader_t$38","bin_reader_f","bin_t$38","bin_f","t_of_sexp$69","sexp_of_t$84","compare$98","cmp_f","equal$57","hash_fold_t$51","hash_fold_f","a0","to_yojson$16","symbol$205","t_of_sexp$70","sexp_of_t$85","compare$99","hash_fold_t$52","map$52","map$53","create$72","equal$58","to_yojson$17","symbol$206","group$76","bin_shape_t$83","bin_size_t$39","bin_write_t$41","bin_writer_t$39","bin_read_t$74","bin_read_t$75","bin_reader_t$39","bin_t$39","versioned$0","t_of_sexp$71","sexp_of_t$86","compare$100","b_020","a_019","equal$59","a_021","b_022","b_024","a_023","hash_fold_t$53","to_yojson$18","symbol$207","t_of_sexp$72","sexp_of_t$87","compare$101","a_025","b_026","b_028","a_027","hash_fold_t$54","func$15","map$54","create$73","of_field$0","to_field$0","equal$60","f$12","maxes","just","nothing$0","to_option_unsafe","value_exn$1","of_option","symbol$208","func$16","constant_layout_typ","bool_typ","a_typ","dummy_var","bool_typ$0","bool_typ$1","group$77","bin_shape_t$84","t_of_sexp$73","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","rot_value","xor_value","foreign_field_mul_value","foreign_field_add_value","range_check1_value","range_check0_value","to_hlist","runtime_tables","rot","foreign_field_mul","foreign_field_add","range_check1","range_check0","of_hlist","of_full","to_full","lookup_pattern_range_check","table_width_at_least_2","table_width_at_least_1","lookups_per_row_4","lookups_per_row_3","to_data","map$55","to_yojson$19","fields$4","fields$5","fields$6","fields$7","fields$8","fields$9","fields$10","x$10","fields$11","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","symbol$209","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","xs$18","x$16","xs$17","x$15","xs$16","x$14","xs$15","xs$14","xs$25","x$23","xs$24","x$22","xs$23","x$21","xs$22","x$20","xs$21","x$19","xs$20","x$18","group$78","bin_shape_t$85","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$8","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$42","bin_read_t$76","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$74","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","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","sexp_of_t$88","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","compare$102","a_013","b_014","a_015","b_016","a_033","b_034","a_035","b_036","n$19","n$20","a_045","b_046","n$21","a_047","b_048","n$22","hash_fold_t$55","hash_fold_a","hsv$1","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","equal$61","a_057","b_058","a_059","b_060","a_061","b_062","a_063","b_064","a_065","b_066","a_067","b_068","a_069","b_070","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","t_of_sexp$75","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","to_hlist$1","of_hlist$1","field$1","map$56","to_list$11","always_present","optional_gates","to_absorption_sequence","to_in_circuit","map$57","to_list$12","group$79","to_hlist$2","evals","public_input","of_hlist$2","to_hlist$3","of_hlist$3","f$13","group$80","f_multi","to_hlist$4","ft_eval1","of_hlist$4","to_hlist$5","of_hlist$5","typ$5","Impl","num_chunks","uses_lookups","lookups_per_row_3$0","lookups_per_row_4$0","evals$0","to_yojson$20","poly_g","poly_fq","symbol$210","group$81","bin_shape_t$86","fq","bin_size_t$41","size_of_g","size_of_fq","bin_write_t$43","write_g","write_fq","bin_read_t$77","of_g","of_fq","v_lr","v_z_1","v_z_2","v_delta","v_challenge_polynomial_commitm","t_of_sexp$76","lr_field","z_1_field","z_2_field","delta_field","challenge_polynomial_commitmen","challenge_polynomial_commitmen$0","delta_value","z_2_value","z_1_value","lr_value","sexp_of_t$89","compare$103","cmp_g","cmp_fq","a_245","b_246","a_247","b_248","t_250","t_249","t_252","t_251","hash_fold_t$56","hash_fold_g","hash_fold_fq","equal$62","a_253","b_254","a_255","b_256","t_258","t_257","t_260","t_259","to_hlist$6","z_2","z_1","of_hlist$6","group$82","sexp_of_t$90","of_fqv","v_ft_eval1","v_evals","v_proof","arg$31","bnds$29","arg$24","bnds$30","arg$25","bnds$24","arg$26","bnds$25","arg$27","bnds$26","arg$28","bnds$27","arg$29","bnds$28","arg$30","bnds$31","compare$104","cmp_fqv","a_301","b_302","cmp_fq$0","a_305","b_306","cmp_g$0","a_303","b_304","n$27","a_263","b_264","t_266","t_265","t_268","t_267","n$23","n$24","n$25","n$26","a_307","b_308","t_310","t_309","t_312","t_311","n$28","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","a_111","b_112","a_113","b_114","a_115","b_116","a_117","b_118","a_119","b_120","a_121","b_122","a_123","b_124","a_125","b_126","a_127","b_128","a_129","b_130","a_131","b_132","to_yojson$21","symbol$211","group$83","bin_shape_t$87","bin_size_t$42","bin_write_t$44","bin_read_t$78","t_of_sexp$77","sexp_of_t$91","compare$105","a_341","b_342","a_343","b_344","hash_fold_t$57","equal$63","a_345","b_346","a_347","b_348","to_yojson$22","symbol$212","compare$106","a_349","b_350","a_351","b_352","equal$64","a_353","b_354","a_355","b_356","group$84","bin_shape_t$88","to_hlist$7","aggreg","sorted_5th_column","of_hlist$7","to_hlist$8","of_hlist$8","group$85","bin_shape_t$89","to_hlist$9","t_comm","z_comm","w_comm","of_hlist$9","to_hlist$10","of_hlist$10","typ$7","commitment_lengths","w_lens","wo","fqv","group$86","t_of_sexp$78","of_g$0","field_sexps$1","messages_field","openings_field","proof_field","evals_field","ft_eval1_field","ft_eval1_value","evals_value","proof_value","w_comm_field","z_comm_field","t_comm_field","aggreg_field","runtime_field","runtime_value","aggreg_value","t_comm_value","z_comm_value","w_comm_value","openings_value","messages_value","t_of_sexp$79","field_sexps$2","duplicates$2","extra$2","tail$2","sorted_5th_column_field","sorted_5th_column_value","equal$65","a_483","b_484","cmp_g$1","a_485","b_486","a_439","b_440","a_441","b_442","a_443","b_444","a_445","b_446","a_447","b_448","a_449","b_450","a_451","b_452","a_383","b_384","a_385","b_386","a_387","b_388","cmp_fqv$0","a_491","b_492","cmp_fq$1","a_489","b_490","a_317","b_318","a_487","b_488","a_271","b_272","t_274","t_273","t_276","t_275","a_319","b_320","t_322","t_321","t_324","t_323","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","a_149","b_150","a_151","b_152","a_153","b_154","a_155","b_156","a_157","b_158","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_171","b_172","group$87","bin_shape_t$90","comm","bin_size_t$43","size_of_comm","bin_write_t$45","write_comm","bin_read_t$79","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$80","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","endomul_scalar_comm","emul_comm","mul_comm","complete_add_comm","psm_comm","generic_comm","coefficients_comm","sigma_comm","of_hlist$11","map$58","typ$8","func$17","f_opt","lookup_selector_ffmul","lookup_selector_range_check","lookup_selector_xor","lookup_selector_lookup","runtime_tables_selector","lookup_table_ids","lookup_table_comm","rot_comm","foreign_field_mul_comm","foreign_field_add_comm","range_check1_comm","range_check0_comm","xor_comm","combine_split_commitments","scale_and_add","xi","reduce_without_degree_bound","reduce_with_degree_bound","without_degree_bound","with_degree_bound","flat","combine_split_evaluations","mul_and_add","evals0","fx","to_list$13","to_vector","of_vector","of_list_and_length_exn$0","of_sexpable","of_binable$8","bin_shape_t$91","bin_size_t$44","bin_write_t$46","bin_read_t$80","of_binable$9","of_char_exn","to_int$7","decode","encode","byte$0","charify","hexified","to_u4","map$59","round_constants","mds","pasta_p_legacy","pasta_p_kimchi","pasta_q_kimchi","make$7","sponge_state","sponge_state_of_sexp","sexp_of_sponge_state","rate","absorb","squeeze","operation","sponge","fe","to_blocks","field_elems","num_blocks","create_block","global_pos","first_half_rounds_full","block_cipher","sbox","constant_offset","second_half_rounds_full","not_implemented","to_binable$7","of_binable$10","empty$31","log$1","internal","empty_quartiles","allocation_times","now$0","get_lifetime_ms","mean","lifetimes","q3_offset","q3","q4","compute_statistics","run_test","time_offsets","expected_quartiles","comparator$0","comparator$1","message$2","message$3","comparator$3","table$0","attach_finalizer","object_id","info_opt","data_opt","statistics","json","block_on_async_exn","to_deferred","map$60","bind$23","return$23","symbol_bind$8","symbol_map$6","bind$24","return$24","map$61","join$13","get$16","t_of_sexp$81","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$62","n_next","n_prev","ss","accs","to_yojson$23","symbol$213","group$88","bin_shape_t$92","bin_size_t$45","bin_write_t$47","bin_read_t$81","v_inner","t_of_sexp$82","inner_field","inner_value","sexp_of_t$92","compare$107","equal$66","hash_fold_t$58","to_yojson$24","of_yojson$14","t_of_sexp$83","sexp_of_t$93","compare$108","equal$67","hash_fold_t$59","typ$9","map$63","y_squared","t_004","t_003","t_005","t_010","t_012","t_011","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","unshifted","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$89","v_challenges","v_commitment","challenges_field","commitment_field","commitment_value","challenges_value","hash_fold_array","poly_fqv","poly_g$0","arg1$2","arg0$2","arg2$1","arg1$1","arg0$1","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_openings","a_455","b_456","a_391","b_392","a_393","b_394","a_395","b_396","a_397","b_398","a_399","b_400","a_401","b_402","a_403","b_404","a_363","b_364","a_365","b_366","a_281","b_282","a_457","b_458","a_283","b_284","t_286","t_285","t_288","t_287","t_of_sexp$2","hash_fold_fqv","a_465","b_466","a_407","b_408","a_409","b_410","a_411","b_412","a_413","b_414","a_415","b_416","a_417","b_418","a_419","b_420","a_369","b_370","a_371","b_372","a_293","b_294","a_467","b_468","a_295","b_296","t_298","t_297","t_300","t_299","map_creator","messages","openings","to_latest$0","fields$30","fields$43","fields$31","fields$25","fields$26","fields$27","fields$28","fields$29","fields$32","fields$44","fields$38","fields$33","fields$34","fields$35","fields$36","fields$37","fields$39","fields$40","fields$41","fields$42","fields$45","arg1$3","arg0$3","xs$26","xs$27","arg3$1","arg2$2","arg3$0","a_475","b_476","a_423","b_424","a_425","b_426","a_427","b_428","a_429","b_430","a_431","b_432","a_433","b_434","a_435","b_436","a_375","b_376","a_377","b_378","a_379","b_380","a_477","b_478","t_of_sexp$3","sexp_of_t$3","v_sorted_5th_column","hsv$33","hsv$29","hsv$30","hsv$31","hsv$32","hsv$24","hsv$25","hsv$26","hsv$27","hsv$28","map_creator$0","create$1","compare$3","map_creator$1","sexp_of_t$4","fq_array_to_vec","vec","opening_proof_of_backend_exn","gpair","g2","g1","eval_of_backend","evals_to_tuple","zeta_omega","zeta","gs","of_backend_with_public_evals","eval_to_backend","vec_to_array","V","evals_of_tuple","chal_polys","pcwo","lr$0","challenges","to_backend$0","to_backend_with_public_evals","public_evals","to_backend_with_public_evals$0","extract_challenges_and_commitm","commitments","pk","primary","auxiliary","prev_comms","prev_chals","create_async","batch_verify","logger","vks_and_v","batch_verify$0","prev_challenge","pi$0","create_with_public_evals","scalar_challenge","beta","joint_combiner_chal","joint_combiner","digest_before_evaluations","p_eval_1","p_eval_2","opening_prechallenges","permutation_cols","map$64","s3","yr","xr","n_acc","yp","xp","yt","xt","map$65","x7","x6","x5","a8","b0","n8","n0","all_tag_versions","bin_read_all_tagged_to_latest","domain_generator","t_of_sexp$84","compare$109","compare$110","cmp_row","to_rust_wire","col","t_of_sexp$85","of_v","field_sexps$12","l_field","r_field","o_field","c_field","duplicates$12","extra$12","tail$7","field_sexp$60","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$59","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$58","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$57","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$56","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","field_sexps$14","id_field$0","data_field","duplicates$14","extra$14","tail$9","field_sexp$55","field_sexp$50","field_sexp$51","fvalue$43","field_sexp$52","fvalue$44","data_value","id_value$0","field_sexps$13","id_field","first_column_field","duplicates$13","extra$13","tail$8","field_sexp$54","field_sexp$47","field_sexp$48","fvalue$41","field_sexp$49","fvalue$42","first_column_value","id_value","kind_field","values_field","coeffs_field","field_sexp$53","coeffs_value","values_value","kind_value","sexp_of_t$94","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$32","bnds$33","bnds$34","arg$32","bnds$35","arg$33","bnds$36","arg$34","bnds$37","arg$35","bnds$38","arg$36","bnds$39","arg$37","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_data","bnds$149","arg$146","bnds$150","arg$147","bnds$151","v_first_column","v_id$0","arg$148","bnds$152","arg$149","bnds$153","v_coeffs","v_values","v_kind","arg$150","bnds$154","arg$151","bnds$155","arg$152","bnds$156","map$66","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","cr","vl$0","vo$0","compare$111","hash_fold_t$60","a0$0","hash$47","t_of_sexp$86","sexp_of_t$95","get_concatenated_fixed_lookup_","flts","flt","get_concatenated_runtime_looku","rt_cfgs","rt_cfg","finalize_fixed_lookup_tables","fixed_lt_rev","finalize_runtime_lookup_tables","rt_cfgs_rev","t_018","t_017","t_020","t_019","compute_witness","external_values","internal_values","num_rows","custom_printf_029","i_after_input","cols","row_idx","col_idx","map_runtime_tables","cfgs","rt_idx","compute_value","vidx","id_int32","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","get_concatenated_fixed_lookup_$0","get_concatenated_runtime_looku$0","wire","vars_for_perm","finalize_and_get_gates","runtime_tables_cfg$0","gates_rev","fixed_lookup_tables","runtime_tables_cfg","rust_gates","pub_selectors","pub_input_gate_specs_rev","public_var","col_field","col_value","row_value","v_row","equivalence_classes","pos_map","update_gate_with_permutation_i","public_gates","public_gates$0","absolute_row","gate","gates$0","relative_row","add_gates","wired_to","wired_to$0","wires","md5_digest","num_constraints","to_json","add_generic_constraint","coeffs2","o2","coeffs$0","red","terms$0","terms_list","lx","go$0","lx$0","s1x1_plus_s2x2","reduce_to_v","xo","xo$0","x3$1","x3$2","ratio","ratio$0","red_pr","l_s","r_s","coeff","add_round_state","s5","s4","reduce_curve_point","x3$3","curr_row","add_endoscale_round","add_endoscale_scalar_round","red_w0","red_w1","red_w2","red_w3","red_w4","red_w5","red_w6","vars$2","lookup1","lookup2","lookup3","vars$3","coeff$0","v2$2","vars_curr","vars_next","vars$4","vars_curr$0","vars_next$0","vars_curr$1","urs_info","degree","set_urs_info","urs$0","urs$1","runtime_table_cfgs","prev_challenges$0","prev_challenges$1","array_to_vector","vk_commitments","full_vk_commitments","to_list$14","of_list$8","group3","pt","pt$0","tuples","string_bits","test_bit","to_bytes$0","bit","of_bytes$0","hash$48","hash_fold_t$61","to_yojson$25","of_yojson$15","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$90","bin_shape_t$93","group$91","bin_shape_t$94","bin_size_t$46","bin_write_t$48","bin_read_t$82","of_bytes$1","to_bytes$1","of_decimal_string","to_string$44","test_bit$0","div$1","compare$112","num_limbs","bytes_per_limb","to_hex","to_hex_string","of_hex_string","of_numeral","double$1","one$8","symbol$214","double$2","one$9","to_affine_exn$0","of_affine$0","symbol$215","make$8","unshifted$0","make$9","sponge_params","to_field$1","of_field$1","with_lagrange","domain_size","vks","create_aux$0","backend_create","computed_witness","create$74","to_binable$8","of_binable$11","create$75","of_data$0","to_field$2","of_field$2","with_lagrange$0","create_aux$1","create_async$0","create$76","to_binable$9","of_binable$12","create$77","create_with_public_evals$0","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$92","bin_shape_t$97","group$93","bin_shape_t$98","group$94","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$216","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","wrap$2","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","remaining_length","remaining_bits","packed_field_elements","pack_to_fields$0","return$25","bind$25","map$67","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","normalized","v_bitstrings","v_field_elements","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","packed_fields$2","input_bitstrings$1","packed_fields$3","input_bitstrings$2","of_vector_unsafe","group$95","bin_shape_t$99","bin_write_t$51","bin_read_t$87","t_of_sexp$88","sexp_of_t$97","hash_fold_proofs_verified","to_int$8","of_int_exn$4","to_input$0","to_input$1","one_hot","typ$10","group$96","bin_shape_t$100","group$97","bin_shape_t$101","bin_read_t$88","group$98","bin_shape_t$102","bin_size_t$49","bin_write_t$52","bin_read_t$89","group$99","bin_shape_t$103","group$100","bin_shape_t$104","t_of_sexp$89","sexp_of_t$98","compare$115","hash_fold_t$62","hash$49","equal$68","group$101","bin_shape_t$105","path$6","to_bits$0","to_yojson$26","symbol$217","of_yojson$16","yojson","to_hex$3","of_hex","sexp_of_t$99","t_of_sexp$90","to_yojson$27","symbol$218","group$102","bin_shape_t$106","path$7","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$103","bin_shape_t$107","challenge","bin_size_t$50","size_of_challenge","bin_write_t$53","write_challenge","bin_read_t$90","of_challenge","v_prechallenge","to_yojson$28","poly_challenge","of_yojson$17","t_of_sexp$91","prechallenge_field","prechallenge_value","sexp_of_t$100","compare$116","cmp_challenge","hash_fold_t$63","hash_fold_challenge","equal$69","prechallenge","typ$11","chal","to_yojson$29","symbol$219","group$104","digest$0","size_of_digest","write_digest","bin_writer_t$42","bin_read_t$91","of_digest","bin_reader_t$42","bin_t$42","version$11","versioned$1","compare$117","of_digest$0","of_digest$1","hash_fold_digest","hash$50","equal$70","path$8","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","pack$1","typ$13","etyp$0","bp_challenge","group$105","to_hlist$13","zeta_to_domain_size","zeta_to_srs_length","of_hlist$13","to_minimal","group$106","to_hlist$14","branch_data","bulletproof_challenges","combined_inner_product","plonk","of_hlist$14","group$107","map_challenges","scalar","group$108","bin_shape_t$108","bin_size_t$51","size_of_g1","size_of_bulletproof_challenges","bin_write_t$54","write_g1","write_bulletproof_challenges","bin_read_t$92","of_g1","of_bulletproof_challenges","v_old_bulletproof_challenges","to_field_elements","g1_to_field_elements","old_bulletproof_challenges","scalar_challenge$0","group$109","to_hlist$15","messages_for_next_wrap_proof","sponge_digest_before_evaluatio","deferred_values","of_hlist$15","bulletproof_challenges$0","bool$2","fp$0","scalar_challenge$1","challenge$0","group$110","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$111","f8","f7","f6","f5","maybe_constant","feature_flags_spec","to_data$0","option_map","messages_for_next_step_proof","of_data$1","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$14","to_hlist$16","unfinalized_proofs","of_hlist$16","to_data$2","of_data$3","per_proof","hash_fold_t$64","hash$51","compare$118","t_of_sexp$92","sexp_of_t$101","hash_fold_t$65","hash$52","compare$119","t_of_sexp$93","sexp_of_t$102","equal$71","rhs0$0","lhs0$0","rhs0$1","lhs0$1","rhs0$2","lhs0$2","rhs0$3","lhs0$3","hash_fold_t$66","a0$1","a0$2","a0$3","hash$53","compare$120","t_of_sexp$94","sexp_of_t$103","constant_term","if_feature","unnormalized_lagrange_basis","vanishes_on_zero_knowledge_and","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","index_terms","constant_term$0","index_terms$0","pow2pow","shifts$0","zetaw","rounds","features","all_feature_flags","endo","field_of_hex","zk_rows","srs_length_log2","get_eval","omega_to_minus_1","omega_to_minus_2","next_term","omega_to_intermediate_powers","omega_to_zk_plus_1","omega_to_zk","omega_to_zk_minus_1","zk_polynomial","zeta_to_n_minus_1","feature","lazy_flag","omega_to_zk_plus_1$0","w_to_i","omega_pow","perm_alpha0","ft_eval0","e0_s","zkp","zeta1m1","p_eval0","zeta1","p_eval0$0","w_n","ft_eval0$0","ft_eval0$1","nominator","ft_eval0$2","derive_plonk","w0$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","version_byte$18","checksum_len","version_string","compute_checksum","ctx0","ctx1","ctx2","first_hash","ctx3","second_hash","checksum","decode_exn","decoded","error_str","check_encoding","to_base58_check","of_base58_check","of_base58_check_exn","to_base64","of_base64","b64","ay","ax","x_squared","x_squared$0","ay$0","ax$0","bx","bx$0","by","cx","cx$0","cy","assert_on_curve","typ_unchecked$0","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","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$121","to_yojson$30","of_yojson$18","sexp_of_t$104","t_of_sexp$95","compare$122","sexpifier$0","v_identifier","v_type","compare$123","to_int","compare$124","t_of_sexp$96","state_hash_field","blockchain_length_field","global_slot_since_genesis_fiel","global_slot_since_genesis_valu","blockchain_length_value","state_hash_value","sexp_of_t$105","v_global_slot_since_genesis","v_blockchain_length","v_state_hash","compare$125","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","header_version","to_yojson$31","compare$126","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$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$112","bin_shape_t$109","path$9","group$113","bin_shape_t$110","path$10","group$114","bin_shape_t$111","compare$127","a_265","b_266","t_016","t_015","t_078","t_077","t_080","t_079","t_084","t_083","t_086","t_085","t_088","t_087","t_090","t_089","t_094","t_093","t_096","t_095","t_098","t_097","t_100","t_099","t_102","t_101","t_104","t_103","t_106","t_105","t_108","t_107","t_110","t_109","t_116","t_115","t_118","t_117","t_120","t_119","a_273","b_274","a_267","b_268","t_270","t_269","t_272","t_271","sexp_of_t$106","v_bulletproof","v_evaluations","v_commitments","v1$11","v1$12","v1$13","v1$14","equal$72","a_275","b_276","t_024","t_023","t_026","t_025","t_028","t_027","t_029","t_034","t_126","t_125","t_128","t_127","t_132","t_131","t_134","t_133","t_136","t_135","t_138","t_137","t_142","t_141","t_144","t_143","t_146","t_145","t_148","t_147","t_150","t_149","t_152","t_151","t_154","t_153","t_156","t_155","t_158","t_157","t_160","t_159","t_162","t_161","t_164","t_163","t_166","t_165","t_168","t_167","a_277","b_278","t_280","t_279","t_282","t_281","path$11","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$6","to_field_checked","bits_msb","nybbles_per_row","nybbles_by_row","to_field_checked$0","to_field_constant","r_2i1","seal$0","rounds_rev","n_acc_prev","xq1","yq1","s1_squared","xq2","yq2","s3_squared","endo_inv","gy","gx","endo_to_field","base$0","scalar$0","endo_to_field$0","Impl$0","forbidden_shifted_values","two_to_n","neg_two_to_n","representatives","generate$0","keypair","forbidden_shifted_values$0","other_mod","check$5","x_eq","b_eq","typ$15","forbidden_shifted_values$1","typ$16","t0$0","check$7","typ_unchecked$1","typ$17","input$1","high_entropy_bits","to_the_alpha","add_assign","apply_affine_map","constants","dotv","underlying","last_squeezed","squeeze_field","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","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","reduce_chunks","sigma_comm_last","sigma_comm_last$0","f_comm","chunked_t_comm","combined_evaluation","fx$0","fx$1","needs_final_permute_if_empty","of_sponge","add_in","i_equals_0","i_equals_j","cond_permute","permute","permuted","consume_pairs","pos_after","add_in_y_after_perm","add_in_y_before_perm","num_pairs","empty_imput","should_permute","consume_all_pending","pos_after$0","recombine","original_sponge","xs_curr","next_index_curr","curr_i","add_fast","check_finite","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","default$8","one$10","default$9","hash$54","ro","tock","tick","scalar_chal","evals_combined","dummy_chals","challenges_computed","challenges_computed$0","group$115","bin_shape_t$112","bpcs","bin_size_t$52","size_of_s","size_of_challenge_polynomial_c","size_of_bpcs","bin_write_t$55","write_s","write_challenge_polynomial_com","write_bpcs","bin_read_t$93","of_s","of_challenge_polynomial_commit","of_bpcs","v_app_state","prepare","group$116","bin_shape_t$113","bin_read_t$94","path$12","t_of_sexp$97","sexp_of_t$107","hash_fold_t$67","f$14","read_step_circuit_field_elemen","prover_fe","sponge_params$0","one$11","group_size_in_bits","constant$4","typ$18","inv_exn","symbol$220","symbol$221","symbol$222","negate$2","inv_exn$0","symbol$223","symbol$224","symbol$225","equal$73","t_of_sexp$98","sexp_of_t$108","scale$3","zero$10","symbol$226","negate$3","to_affine_exn$1","of_affine$1","typ$19","typ_unchecked$2","constant$5","symbol$227","double$3","scale$4","to_field_elements$0","scale_inv","negate$4","one$12","if$3","max$25","hash_fold_vk","group$117","bin_shape_t$114","bin_size_t$53","bin_write_t$56","bin_read_t$95","bin_read_t$96","v_max_proofs_verified","v_actual_wrap_domain_size","v_wrap_index","path$13","versioned$2","func$18","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$13","bin_size_t$54","bin_write_t$57","bin_read_t$97","bin_read_t$98","bin_shape_t$115","bin_writer_t$43","bin_reader_t$43","bin_t$43","path$14","g$1","to_hlist$17","of_hlist$17","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$118","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$58","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$99","of_messages_for_next_wrap_proo","of_messages_for_next_step_proo","bin_read_t$100","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","of_f_multi$0","of_f_multi","v_public_input","v_evals$0","v_prev_evals","v_ft_eval1$0","sexp_of_t$110","of_bp_chals","of_challenge$0","most_recent_width","g0","tick_arr","lengths","poly_messages_for_next_step_pr","poly_messages_for_next_wrap_pr","arg1$4","arg0$4","arg1$5","arg0$5","arg1$6","arg0$6","arg1$7","arg0$7","poly_f_multi$0","poly_f_multi","fields$46","poly_bool","poly_scalar_challenge","fields$47","xs$51","xs$52","arg2$5","arg1$10","arg0$10","xs$53","x$32","xs$35","xs$36","xs$38","x$24","xs$37","xs$30","xs$31","xs$34","xs$29","state$35","xs$28","state$33","arg5$0","arg4$0","xs$33","xs$32","xs$54","x$33","xs$45","xs$46","arg2$4","arg1$9","arg0$9","xs$50","x$31","xs$49","x$30","xs$39","xs$40","arg2$3","xs$43","x$27","xs$42","x$26","xs$41","x$25","arg1$8","arg0$8","xs$48","x$29","xs$44","xs$47","x$28","xs$55","x$34","poly_f_multi$1","cmp_messages_for_next_step_pro","a_173","b_174","a_179","b_180","a_181","b_182","a_183","b_184","cmp_messages_for_next_wrap_pro","cmp_scalar_challenge","cmp_f_multi","t_194","t_193","t_196","t_195","a_197","b_198","t_200","t_199","t_202","t_201","app_state_field","old_bulletproof_challenges_fie","old_bulletproof_challenges_val","app_state_value","statement_field","prev_evals_field","of_challenge$1","of_scalar_challenge$0","proof_state_field","messages_for_next_step_proof_f","deferred_values_field","messages_for_next_wrap_proof_f","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","messages_for_next_step_proof_v","proof_state_value","sexp$6","commitments_field","evaluations_field","ft_eval1_field$0","bulletproof_field","bulletproof_value","ft_eval1_value$0","evaluations_value","commitments_value","sexp$7","evals_field$0","of_f_multi$1","public_input_field","public_input_value","evals_value$0","prev_evals_value","statement_value","hsv$43","hash_fold_messages_for_next_st","hash_fold_messages_for_next_wr","hash_fold_scalar_challenge","hsv$42","hash_fold_f_multi$0","hash_fold_f_multi","e0$0","e0$1","e0$2","e0$3","e0$4","hsv$34","e1$5","e0$5","hsv$35","hsv$36","e1$6","e0$6","hsv$37","hsv$38","e1$7","e0$7","hsv$39","hsv$40","hsv$41","a_195","b_196","a_201","b_202","a_207","b_208","a_209","b_210","a_211","b_212","a_187","b_188","t_208","t_207","t_210","t_209","t_214","t_213","t_216","t_215","prev_evals","statement$0","prev_evals$0","to_yojson_full","group$119","bin_shape_t$117","bin_size_t$56","bin_write_t$59","bin_read_t$101","bin_read_t$102","path$15","of_yojson$19","to_yojson$32","sexp_of_t$111","t_of_sexp$100","hash$56","hash_fold_t$69","equal$75","compare$129","of_repr$0","to_repr$0","versioned$3","to_binable$11","of_binable$14","path$16","of_yojson$20","to_yojson$33","to_yojson_full$0","sexp_of_t$112","t_of_sexp$101","hash$57","hash_fold_t$70","equal$76","compare$130","group$120","bin_shape_t$118","bin_size_t$57","bin_write_t$60","bin_read_t$103","bin_read_t$104","path$17","of_yojson$21","to_yojson$34","sexp_of_t$113","t_of_sexp$102","hash$58","hash_fold_t$71","equal$77","compare$131","of_repr$1","to_repr$1","versioned$4","to_binable$12","of_binable$15","path$18","read_wrap_circuit_field_elemen","sponge_params$1","squeeze_field$0","one$13","group_size_in_bits$0","constant$6","typ$21","if$4","scale$5","inv_exn$1","symbol$228","symbol$229","symbol$230","negate$5","negate$6","square$3","inv_exn$2","symbol$231","symbol$232","symbol$233","assert_square$2","assert_r1cs$2","equal$79","t_of_sexp$104","sexp_of_t$115","scale$6","random$2","zero$11","symbol$234","negate$7","to_affine_exn$2","of_affine$2","multiscale_known$0","typ$22","typ_unchecked$3","constant$7","symbol$235","double$4","scale$7","to_field_elements$1","scale_inv$0","negate$8","g$2","if$5","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","nones","maybes","none_sum","just_sum","just_is_yes","b_g","maybe_sum","maybe_is_yes","is_yes","no_2","maybe_2","yes_2","no_1","maybe_1","yes_1","b_x","lagrange","domains","which_branch","pts","scaled_lagrange","lagrange_with_correction","actual_shift","field2pow","two_to_actual_shift","base_and_correction","h_precomp","finite","assert_finite","batch","without_bound","with_bound","reduce_point","point","base_point","point$0","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","j1","zeta_1","gamma_1","beta_1","alpha_1","zeta_0","gamma_0","beta_0","alpha_0","j1$0","j1$1","var_to_fields$0","assert_eq_plonk","index_to_field_elements","g_opt","simulate_optional_sponge_with_","sponge_state_before","state_before","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","correction","x_hat","x_hat$0","runtime$1","runtime$2","runtime$3","b_runtime","runtime_comm","runtime$0","compute_joint_combiner","absorb_sorted_1","absorb_sorted_2_to_4","absorb_sorted_5","z$2","sponge2$0","joint_combiner_if_true$0","sponge2","joint_combiner_if_true","joint_combiner$2","compute_lookup_table_comm","second_column","has_runtime","second_column_with_runtime","has_runtime$0","sum$1","second_with_runtime","rest_rev","comm$0","scaled_acc","comm$1","has_comm","scaled_acc$0","has_acc","comm$2","scaled_acc$1","comm$3","has_comm$0","scaled_acc$2","acc_with_comm","joint_combiner$0","joint_combiner$1","lookup_table_comm$0","lookup_table_comm$1","b_lookup_table_comm","lookup_sorted_minus_1","aggreg$0","sponge$0","sponge_before_evaluations","sigma_comm_init","ft_comm$0","len_1_add","len_1","len_2_add","len_2","len_3_add","len_4_add","len_5_add","len_5","len_6_add","len_6","append_chain","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","xi_actual","r_actual","xi_actual$0","xi$0","xi_correct","plonk_minimal","zeta_n","zetaw_n","combined_evals","evals2","evals1","ft","sg_evals$0","actual_combined_inner_product","combined_inner_product_correct","challenge_poly","b_actual","b_correct","plonk_checks_passed","to_hlist$18","of_hlist$18","to_hlist$19","of_hlist$19","shift$0","typ$23","create$82","find$17","lookup_compiled","other_id","lookup_side_loaded","set_ephemeral","eph","prover","ephemeral","add_exn$4","print_fp","add_opt","constant_part$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","corr","sponge_after_index","receive","domain$0","z_comm$0","t_comm$0","vanishing_polynomial","should_square","side_loaded_domain","max_n","vanishing_polynomial$0","pow2_pow","squeeze_challenge$0","domain_for_compiled","unique_domains","which_log2","lookups_per_row_2","actual_width_mask","opt_sponge","a_002","b_003","a_006","b_007","a_008","b_009","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","unfinalized","bulletproof_challenges_actual","bulletproof_success","hash_messages_for_next_step_pr$1","verify$0","to_hlist$20","prev_challenge_polynomial_comm","prev_proof_evals","wrap_proof","of_hlist$20","to_hlist$21","of_hlist$21","shift$1","dummy$1","one_chal","typ$24","dummy$2","create$83","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","lookup_table_comm3","lookup_table_comm2","lookup_table_comm1","lookup_table_comm0","lookup_pattern_xor","table_width_3","assert_consistent","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","ret_conv_inv","constraint_builder","range_check_table_used","combined_lookup_table_length","lookup_table_length_log2","group$121","bin_shape_t$119","path$19","group$122","bin_shape_t$120","bin_size_t$58","bin_write_t$61","bin_read_t$105","bin_read_t$106","v_constraints","path$20","poly_polyComm","poly_comm","poly_polyComm$0","arg8$0","arg7$0","arg6$0","versioned$5","of_repr$2","to_binable$13","of_binable$16","path$21","f_debug","num_choices","choices_length","num_choices$0","dummy_step_domains","dummy_step_widths","dummy_step_keys","compare$133","right_026","left_025","right_014","left_013","right_022","left_021","right_004","left_003","right_030","left_029","right_006","left_005","right_008","left_007","right_012","left_011","t_of_sexp$105","t_of_sexp$106","sexp_of_t$116","or_infinity_to_yojson","poly_comm_to_yojson","poly_caml_g","verifier_index_to_yojson","poly_fr","poly_srs","poly_poly_comm","step_verification_key_to_yojso","wrap_verification_key_to_yojso","get_proof","verification_key","for_vk","set_proof","is_env_var_set_requesting_erro","constant_term$1","index_terms$1","tick_rounds","AB","challenge_polys","which_eval","expand_deferred","tick_field","plonk0","step_domain","tick_plonk_minimal","tick_combined_evals","tick_domain","tick_env","challenges_digest","lookup_final_terms","xi_chal","r_chal","actual_proofs_verified","combined_inner_product_actual","to_shifted","verify_heterogenous","chunking_data","expected_num_chunks","non_chunking","expected_domain_size","deferred_values$0","least_wrap_domain","match$2","actual_wrap_domain","accumulator_check","batch_verify_inputs","A_value","prepared_statement","dlog_check","comm_chals","verify_promise","a_value","create$84","wrap_domains$0","proofs_verifieds","auxiliary_typ","var_to_field_elements","value_to_field_elements","chain_to","rule","self_width","extract_lengths","len_ms","len_ns","branches$0","local_branches_length","local_signature_length","heights","widths","requests","output_typ","opt_wrap_key","compiled","wrap_key","known_wrap_keys","ld$0","ds$0","feature_flags_and_num_chunks","ns1","ns2","ln1","ln2","feature_flags_and_num_chunkss","feature_flags_and_num_chunkss$0","ln2$0","ln1$0","ns2$0","ns1$0","dummy_scalar_challenge","constant_typ","bool_typ_of_flag","prev_proof_typs","output_typ$0","auxiliary_var","ret_var","previous_proof_statements","ret_value","auxiliary_value","prevs","unfinalized_proofs_unextended","actual_wrap_domains","stmts","stmts$0","stmt","proofs$0","proof_witnesses","datas","messages_for_next_wrap_proofs","unfinalizeds","actual_wrap_domains$0","must_verify","unfinalizeds$0","messages_for_next_wrap_proofs$0","datas$0","proof_witnesses$0","pw","actual_wrap_domain$0","actual_wrap_domain$1","sponge_digest","prev_messages_for_next_step_pr","verified","self_data","optional_wrap_keys","optional_wrap_keys$0","optional_wrap_key","zk_rows$0","num_chunks$0","wrap_key$0","previous_proof_statement","proof_must_verify","public_input$1","previous_proof_statements$0","own_domains","step$0","proof_cache","next_state","Maxes","prevs_length","self_dlog_plonk_index","self_dlog_vk","prev_vars_length","prev_values_length","expand_proof","dlog_vk","dlog_index","Local_max_proofs_verified","deferred_values_computed","x_hat_1","zeta$0","alpha$0","zetaw$0","prechals","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","prev_proofs","return_value","unfinalized_proofs$0","unfinalized_proofs_extended","extract_from_proofs","Extract","prevs$0","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","wrap_vk$1","wrap_vk$0","domain_index","to_fold_in","next_proof","next_statement","conv_inv","next_statement_hashed","auxiliary_inputs","create_proof","proof_cache$0","proof_json","to_string$45","to_string$46","storable","header_read","vk_storable","read_or_generate","k_p","k_v","s_p","s_v","dirty","header_version_field","constraint_constants_field","length_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","identifying_hash_value","constraint_system_hash_value","length_value","constraint_constants_value","header_version_value","v_identifying_hash","v_constraint_system_hash","v_constraint_constants","v_header_version","t_022","to_string$47","to_string$48","storable$0","vk_storable$0","read_or_generate$0","vk$0","symbol$236","generate_or_load","pad_messages_for_next_wrap_pro","messages_len","maxes_len","maxes$0","maxes$1","default$10","promise_all","compile_with_wrap_main_overrid","disk_keys$0","override_wrap_domain","override_wrap_main","Branches","constraint_constants","storables","a_value_to_fields","a_var_to_fields","a_value_to_fields$0","a_var_to_fields$0","conv_irs","wrap_vk_storable","wrap_storable","step_vk_storable","step_storable","snark_keys_header","constraint_system_hash","constraint_constants$0","constraint_constants$1","prev_varss_length","prev_varss_n","padded","enabled","chain_to$0","step_data","all_step_domains","lock","cache_handle","accum_dirty","disk_keys","cs_hash","existing_lock","unlock","ks","step_keypairs","step_vks","step_keypairs$0","wrap_main$0","wrap_main$1","wrap_requests","self_id","disk_key_prover","wrap_disk_key","wrap_pk","computed_domain_size","ks$0","step_vk","step_pk","proof$0","tweak_statement","tweak_statement$0","which_index","prev_statement_with_hashes","x_hat_evals","shift_value","next_statement$0","next_accumulator","provers","cache_handle$0","typ$6","verify_promise$0","wrap_main_dummy_override","dummy_id","binable","of_compiled_promise","of_compiled","in_circuit","permanent","srs_precomputation","compile_promise","compile","identifier","proof_module","adjust_provers","compile_async","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","lazy_step_vk","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$2","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","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$19","cons$5","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$108","sexp_of_t$118","hash_fold_t$73","compare$134","t_of_sexp$109","sexp_of_t$119","bin_size_t$59","bin_write_t$62","bin_read_t$107","bin_read_t$108","empty$32","equal$81","typ$25","t_of_sexp$110","sexp_of_t$120","add$31","typ$26","negate$9","constant$10","if$8","double$5","scale$8","sum$4","make_checked$1","params$3","block_cipher$1","add_assign$1","copy$10","to_bits$1","update$5","hash$60","pow2$1","to_bits$2","params$4","hash$61","pack_input","pack_input$0","prefix_to_field","params$5","rounds_full$0","initial_ark$0","rounds_partial$0","to_the_alpha$1","hash$62","salt$1","pack_input$1","to_the_alpha$2","seal$1","add_assign$2","apply_affine_map$0","copy$11","params$6","scan_state_transaction_capacit","t$9","length_in_bytes$1","padding_char","create$85","protocol_state","protocol_state_body","account","side_loaded_vk","zkapp_account","zkapp_payload","zkapp_body_mainnet","zkapp_body_testnet","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$0","checkpoint_list","zkapp_precondition","zkapp_precondition_account","zkapp_precondition_protocol_st","account_update_account_precond","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","raise$1","to_option$0","array_length","export$0","jsoo_exports","symbol$237","lookup$3","of_js","salt$2","salt$3","salt_legacy","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$123","bin_shape_t$121","group$124","field$4","group$125","create$86","bin_read_t$109","v_x","v_is_odd","bin_size_t$60","bin_write_t$63","to_hlist$22","of_hlist$22","gen$2","group$126","bin_shape_t$122","path$22","version$12","group$127","group$128","bin_shape_t$123","create$87","bin_read_t$110","bin_read_t$111","bin_reader_t$44","bin_size_t$61","bin_write_t$64","bin_writer_t$44","bin_t$44","group$129","public_key","size_of_public_key","write_public_key","bin_writer_t$45","bin_read_t$112","of_public_key","bin_reader_t$45","bin_t$45","version$13","equal_key","compare_key$2","hash_fold_t$74","hash$63","to_yojson$37","of_yojson$24","of_public_key$0","of_public_key$1","hash_fold_t$75","uncompressed","path$23","group$130","bin_shape_typ$0","group$131","public_key$0","create$88","bin_read_t$113","key_to_string","compress$1","empty$33","to_input$3","to_input_legacy","typ$27","var_of_t","equal$82","odd_eq","to_input$4","decompress","y_parity","decompress_exn","compare$135","hash_fold_t$76","of_yojson$25","compressed","to_yojson$38","sexp_of_t$122","t_of_sexp$112","path$24","group$132","bin_shape_t_tagged$0","create$89","bin_read_t$114","bin_size_t$62","bin_write_t$65","group$133","bin_shape_t$124","bin_size_t$63","bin_write_t$66","bin_writer_t$46","bin_read_t$115","bin_read_t$116","bin_reader_t$46","bin_t$46","compare$136","version$14","t_of_sexp$113","upperbound","path$25","group$134","bin_shape_typ$1","bin_size_typ","bin_write_typ","bin_read_typ","group$135","bin_shape_t_tagged$1","create$90","bin_read_t$117","bin_read_t$118","bin_reader_t$47","bin_size_t$64","bin_write_t$67","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","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$136","bin_shape_t$125","path$26","t_of_sexp$114","public_key_field","private_key_field","private_key_value","public_key_value","sexp_of_t$123","v_private_key","v_public_key","compare$137","pk2","pk1","of_private_key_exn","gen$3","t_of_sexp$115","sexp_of_t$124","compare$138","group$137","bin_shape_t$126","path$27","t_of_sexp$116","sexp_of_t$125","gen$4","to_field$3","typ$28","one_half","is_pos","constant$11","pos$68","if$9","to_yojson$39","poly_hash","poly_account","group$138","bin_size_t$65","size_of_hash","size_of_account","bin_write_t$68","write_hash","write_account","bin_read_t$119","of_account","arg_1$1","arg_2","arg_3","t_of_sexp$117","sexp_of_t$126","to_yojson$40","of_yojson$26","equal$83","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$118","sexp_of_t$127","hash$66","group$139","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_impl","replace_self","tree0","build_tail_f","prev_r","prev_l","mself","traverse_through_nodes","bottom_to_hash_node_path","bottom_el","tail_r","tail_l","account_id","h_r","h_l","add_wide_path_unsafe","h_r$0","h_l$0","find_index_exn","aid","custom_printf_041","custom_printf_042","acct","go_right","expected_kind","custom_printf_043","v_favorite_number","a_046","b_047","name_field","favorite_number_field","favorite_number_value","name_value","data_hash","favorite_number","prune_hash_branches","let_syntax_053","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","pk$0","group$140","bin_shape_t$128","group$141","bin_shape_typ$2","group$142","bin_shape_t$129","path$28","of_yojson$27","to_yojson$41","t_of_sexp$119","sexp_of_t$128","hash_fold_t$77","func$20","compare$139","equal$84","version$15","bin_size_t$66","bin_write_t$69","bin_read_t$120","bin_read_t$121","path$29","group$143","bin_shape_t_tagged$2","create$91","bin_read_typ$0","bin_read_typ$1","bin_size_typ$0","bin_write_typ$0","to_yojson$42","of_yojson$28","t_of_sexp$120","sexp_of_t$129","hash_fold_t$78","hash$67","hashable$3","add$32","sub$9","div$2","max_value$3","logand$1","logor$1","logxor$1","shift_left$7","shift_right$7","of_int$10","to_int$9","of_ms$0","to_ms$0","of_string$46","to_string$49","zero$12","one$14","lognot$6","succ$9","pred$9","compare$140","equal$85","max$26","min$25","pp$28","symbol$238","symbol$239","symbol$240","symbol$241","symbol$242","to_uint64","of_uint64","group$144","bin_shape_t$130","group$145","bin_shape_typ$3","group$146","bin_shape_t$131","path$30","of_yojson$29","to_yojson$43","t_of_sexp$121","sexp_of_t$130","hash_fold_t$79","func$21","compare$141","equal$86","bin_size_t$67","bin_write_t$70","bin_read_t$122","bin_read_t$123","path$31","group$147","bin_shape_t_tagged$3","create$92","to_yojson$44","of_yojson$30","t_of_sexp$122","sexp_of_t$131","length_in_bits$0","hash_fold_t$80","hash$68","hashable$4","add$33","sub$10","div$3","max_int$3","logand$2","logor$2","logxor$2","shift_left$8","shift_right$8","of_int$11","to_int$10","of_int64$3","to_int64$4","of_string$47","to_string$50","zero$13","one$15","lognot$7","succ$10","pred$10","compare$142","equal$87","max$27","min$26","pp$29","symbol$243","symbol$244","symbol$245","symbol$246","symbol$247","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","read_version$0","max_value","current$5","u32_1","u32_2","zero$14","symbol$248","diff_or_zero","u32_slot","u32_span","u32_sum","to_uint32$0","of_uint32$0","zero$15","equal$88","zero$16","succ$11","group$148","bin_shape_t$132","t_fields_annots","t_toplevel_annots","t_of_sexp$123","of_magnitude","of_sgn","magnitude_field","sgn_field","sgn_value","magnitude_value","sexp_of_t$132","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","create_preserve_zero_sign","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_044","custom_printf_045","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","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","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","sub_flagged$1","scale_exn","sexp_of_fee","sexp_of_weight","sub_flagged_checked","u_checked","m_checked","scan_state_transaction_capacit$0","union$6","diff$4","single$0","empty$34","csingle","cseq","cadd","cupper","clower","calpha","cdigit","calnum","eRR","menhir_discard","menhir_errorcase","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_","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","tok$11","tok$12","menhir_goto_option_type_condit","tok$7","menhir_env$5","tok$8","tok$9","menhir_env$6","tok$10","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","symbol_bind$9","map$68","symbol_map$7","find$18","map$69","map_s","map_p","enum_value","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","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","io_field","abstract_field","subscription_field","enum$1","non_null$0","union$0","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","reducer","types_of_schema","args_to_list","no_abstracts","enum_value$0","input_value","interfaces","arg_list","schema$0","subs","add_built_in_fields","schema_field","matches_type_condition","type_condition","abstract$0","should_include_field","directives","eval_directive","alias_or_name","merge_selections","matching","selection_sets","selection_set","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","lifted_value","src$1","data_to_json","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","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$133","v_doc","of_annots","t_fields_annots$0","sexpifier$2","v_deprecated","v_skip","compare$143","of_annots$0","annots","under_to_camel","prefix_us","ws$0","name_under_to_camel","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$26","map$70","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","merge_acc","force_breaks1","force_breaks2","force_breaks1$0","force_breaks","children","new_children","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$149","bin_shape_t$133","t_fields_annots$1","t_toplevel_annots$1","t_of_sexp$124","of_h","hash_field","hash_value","sexp_of_t$134","v_hash","hash$69","data$3","hash$70","data$4","sexp_of_t$135","compare$144","cmp_h","hash$71","map$71","to_key$0","to_entry","to_doc_entry","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","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","query_top_level","json_to_string_gql","arg_query","out_query","in_schema","out_schema","run_query","unwrap","verification_key_with_hash","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_fun","field_fun","compile_acc$3","field_gen","compile_acc$4","nothing_gen","compile_acc$5","public_key_gen","group$150","bin_shape_t$134","bin_writer_t$48","bin_reader_t$48","bin_t$48","version$16","func$22","path$32","group$151","bin_shape_typ$4","group$152","bin_shape_t$135","create$93","bin_read_t$124","bin_read_t$125","bin_reader_t$49","bin_size_t$68","bin_write_t$71","bin_writer_t$49","bin_t$49","to_decimal_string","to_bytes","curr$0","var_to_hash_packed","var_of_hash_packed","var_to_field","group$153","bin_shape_t$136","bin_writer_t$50","bin_reader_t$50","bin_t$50","hash$72","path$33","group$154","bin_shape_t$137","bin_read_t$126","bin_read_t$127","bin_reader_t$51","bin_size_t$69","bin_write_t$72","bin_writer_t$51","bin_t$51","equal$89","to_string$51","of_string$48","group$155","bin_shape_t$138","bin_read_t$128","bin_size_t$70","bin_write_t$73","t_of_sexp$125","sexp_of_t$136","to_yojson$45","symbol$249","group$156","bin_shape_t$139","bin_read_t$129","bin_read_t$130","v_transaction_capacity_log_2","bin_reader_t$52","bin_size_t$71","bin_write_t$74","bin_writer_t$52","bin_t$52","t_of_sexp$126","transaction_capacity_log_2_fie","transaction_capacity_log_2_val","sexp_of_t$137","equal$90","compare$145","to_snark_keys_header","blockchain_length","state_hash","genesis_timestamp_of_string","of_time","to_time","validate_time","time_str","genesis_timestamp_to_string","compare$146","poly_length","poly_delta","poly_genesis_state_timestamp","group$157","bin_shape_t$140","sexp_of_t$138","of_length","of_delta","of_genesis_state_timestamp","v_genesis_state_timestamp","v_grace_period_slots","v_slots_per_sub_window","v_slots_per_epoch","v_k","to_hlist$23","grace_period_slots","slots_per_sub_window","slots_per_epoch","of_hlist$23","compare$147","group$158","bin_shape_t$141","path$34","compare$148","symbol$250","sexp_of_t$139","v_minimum_user_command_fee","v_zkapp_cmd_limit_hardcap","v_max_action_elements","v_max_event_elements","v_zkapp_transaction_cost_limit","v_zkapp_signed_pair_update_cos","v_zkapp_signed_single_update_c","v_zkapp_proof_update_cost","v_num_accounts","v_txpool_max_size","v_protocol","group$159","bin_shape_t$142","bin_read_t$131","bin_read_t$132","bin_reader_t$53","bin_size_t$72","bin_write_t$75","bin_writer_t$53","bin_t$53","hash$73","tps_goal_x10","max_user_commands_per_block","pending_coinbase_depth","hash_typ","time_offset","setting_enabled","disable_setting_offset","enable_setting_offset","set_time_offset","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","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$160","bin_read_t$133","bin_read_t$134","t_of_sexp$127","to_list$15","to_numbered_list","def2","def1","map$72","fold$19","gen$5","inner_gen","of_array$4","map_gens","gen_division_generic","dirichlet","n_float","uniform","gen_division","symbol$251","zero$18","symbol$252","symbol$253","gen_division_currency","root_gen","node_gen","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","of_public_key$2","token_id","owner","public_key$1","token_id$0","derive_token_id$1","tid2","tid1","pk_equal","tid_equal","tid_else","pk_else","tid_then","pk_then","create$94","equal$91","group$161","t_of_sexp$128","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$162","bin_shape_t$143","path$35","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$0","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$29","deriver$1","group$163","group$164","field$5","version$17","group$165","bin_shape_t_tagged$4","create$95","bin_read_t$135","bin_size_t$73","bin_write_t$76","group$166","bin_shape_t$144","bin_size_t$74","bin_write_t$77","bin_read_t$136","t_of_sexp$129","sexp_of_t$140","compare$149","hash_fold_t$81","group$167","bin_shape_t$145","bin_read_t$137","bin_read_t$138","bin_reader_t$54","bin_size_t$75","bin_write_t$78","bin_writer_t$54","bin_t$54","path$36","group$168","bin_shape_typ$5","group$169","bin_shape_t_tagged$5","create$96","bin_read_t$139","bin_size_t$76","bin_write_t$79","authorization","group$170","bin_shape_t$146","path$37","sexp_of_t$141","gen$6","dummy_signature","let_syntax_297","signature_deriver","t_fields_annots$3","t_toplevel_annots$3","signature$3","signature$4","deriver$2","signature_fun","proof_fun","proof_gen","signature_gen","to_record$0","of_record$0","deriver$3","control","typ$30","to_input$6","t_fields_annots$4","t_toplevel_annots$4","hash$74","data$5","hash$75","data$6","deriver$4","to_yojson$46","symbol$254","group$171","token$1","bin_size_t$77","bin_write_t$80","bin_read_t$140","t_of_sexp$130","sexp_of_t$142","equal$92","compare$150","hash_fold_t$82","path$38","to_yojson$47","symbol$255","group$172","bin_size_t$78","bin_write_t$81","bin_read_t$141","t_of_sexp$131","sexp_of_t$143","compare$151","hash_fold_t$83","path$39","group$173","bin_shape_typ$6","bin_size_typ$1","bin_write_typ$1","bin_read_typ$2","group$174","create$97","to_yojson$48","symbol$256","default_caller","of_string$49","equal$93","deriver$5","group$175","to_hlist$24","fee_excess_r","fee_token_r","fee_excess_l","fee_token_l","of_hlist$24","typ$31","token_typ","fee_typ","group$176","bin_shape_t$147","path$40","rebalance","fee_token_l$0","fee_token_r$0","fee_excess_l$0","zero$19","of_one_or_two","excesses","unreduced","gen_single","group$177","group$178","group$179","token_id$1","group$180","create$98","group$181","bin_shape_t$148","path$41","group$182","bin_shape_t$149","path$42","group$183","bin_shape_typ$7","group$184","bin_shape_t_tagged$6","create$99","dummy$4","to_yojson$49","of_yojson$31","t_of_sexp$132","sexp_of_t$144","equal$94","compare$152","group$185","ledger","bin_writer_t$55","bin_reader_t$55","bin_t$55","hash$76","path$43","group$186","controller","write_controller","of_controller","of_controller$0","of_controller$1","hash_fold_controller","path$44","sexp_of_t$145","gen_for_proof_authorization","gen_for_signature_authorizatio","gen_for_none_given_authorizati","to_string$52","of_string$50","to_hlist$25","signature_sufficient","signature_necessary","of_hlist$25","to_input$7","encode$0","decode$1","to_input$8","t$10","typ$32","to_input$9","check$10","group$187","to_hlist$26","set_timing","set_voting_for","increment_nonce","set_token_symbol","edit_action_state","set_zkapp_uri","set_verification_key","set_permissions","set_delegate","send","edit_state","of_hlist$26","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","txn_version","group$188","bin_shape_t$150","bin_size_t$79","bin_write_t$82","bin_read_t$142","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$133","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","sexp_of_t$146","compare$153","t_021","hash_fold_t$84","path$45","to_input$11","typ$33","to_input$12","t1$9","empty$35","auth_required","txn_version$0","auth$0","t_fields_annots$6","t_toplevel_annots$6","deriver$6","transaction_version","txn_version_fun","auth_fun","auth_gen","txn_version_gen","to_record$1","of_record$1","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$189","bin_shape_t$151","path$46","group$190","bin_shape_typ$8","group$191","bin_shape_t$152","path$47","group$192","bin_shape_typ$9","group$193","bin_shape_t_tagged$7","create$100","generator_013","to_yojson$50","group$194","bin_shape_t$153","t_of_sexp$134","sexp_of_t$147","path$48","sexp_of_t$148","compare$154","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$195","bin_shape_t$154","path$49","to_yojson$51","group$196","bin_shape_t$155","path$50","to_display","empty$36","of_single_failure","is_empty$14","add$34","describe","group$197","bin_shape_t$156","path$51","min$27","max$28","of_enum","equal$95","gen$7","equal$96","of_t","test_mask","payment","stake_delegation","fee_transfer","coinbase$2","typ$34","to_hlist$27","is_user_command","is_coinbase","is_fee_transfer","is_stake_delegation","is_payment","of_hlist$27","typ$35","equal$97","payment$0","stake_delegation$0","fee_transfer$0","coinbase$3","to_bits_t","to_bits_var","bool_var","bit3","bit2","bit1","acc3","add_if_true","base_typ","typ$36","unpacked_t_of_t","t_of_unpacked_t","unpacked","bits_t_of_t","t_of_bits_t","unpacked_typ","test_predicate","checked$0","one_of","one$16","default$11","group$198","group$199","group$200","global_slot","nonce","token_id$2","public_key$2","group$201","create$101","to_hlist$28","valid_until","fee_payer_pk","of_hlist$28","symbol$257","group$202","bin_shape_t$157","bin_size_t$80","bin_write_t$83","bin_writer_t$56","bin_read_t$143","bin_read_t$144","v_fee","v_fee_payer_pk","v_nonce","v_valid_until","v_memo","bin_reader_t$56","bin_t$56","t_of_sexp$135","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$149","hash_fold_t$85","path$52","group$203","bin_shape_t$158","bin_size_t$81","bin_write_t$84","bin_read_t$145","v_fee_token","t_of_sexp$136","fee_token_field","fee_token_value","sexp_of_t$150","hash_fold_t$86","path$53","group$204","bin_shape_typ$10","group$205","create$102","let_syntax_073","gen$8","group$206","bin_shape_t$159","bin_size_t$82","bin_write_t$85","bin_read_t$146","v_receiver_pk","v_amount","v_new_delegate","t_of_sexp$137","new_delegate_field","new_delegate_value","receiver_pk_field","amount_field","amount_value","receiver_pk_value","sexp_of_t$151","hash_fold_t$87","path$54","group$207","bin_shape_t$160","bin_size_t$83","bin_write_t$86","bin_read_t$147","v_source_pk","v_token_id","v_delegator","t_of_sexp$138","delegator_field","delegator_value","source_pk_field","token_id_field","token_id_value","source_pk_value","sexp_of_t$152","hash_fold_t$88","path$55","group$208","bin_shape_typ$11","group$209","bin_shape_t_tagged$8","create$103","to_yojson$52","poly_common","poly_body","symbol$258","group$210","bin_shape_t$161","bin_size_t$84","size_of_common","size_of_body","bin_write_t$87","write_common","write_body","bin_read_t$148","of_common","of_body","v_common","v_body","t_of_sexp$139","common_field","body_field","body_value","common_value","sexp_of_t$153","hash_fold_t$89","hash_fold_common","hash_fold_body","compare$155","cmp_common","cmp_body","group$211","common$0","group$212","create$104","to_hlist$29","of_hlist$29","group$213","bin_shape_t$162","bin_size_t$85","bin_write_t$88","bin_read_t$149","t_of_sexp$140","sexp_of_t$154","hash_fold_t$90","path$56","group$214","bin_shape_t$163","bin_size_t$86","bin_write_t$89","bin_read_t$150","t_of_sexp$141","sexp_of_t$155","hash_fold_t$91","path$57","group$215","bin_shape_typ$12","group$216","bin_shape_t_tagged$9","create$105","bin_read_t$151","read_version$6","read_version$5","read_version$3","read_version$2","read_version$4","read_version$1","bin_size_t$87","bin_write_t$90","create$106","fee$0","fee_payer","nonce$0","receiver","new_delegate","max_amount","receiver_pk","generator_012","t_to_hlist","source_pk","t_of_hlist","typ$37","to_hlist$30","fee_token","of_hlist$30","typ$38","of_user_command_payload","max_amount_without_overflow","poly_payload","poly_pk","poly_signature","size_of_payload","size_of_pk","size_of_signature","write_payload","write_pk","write_signature","bin_writer_payload","bin_writer_pk","bin_writer_signature","of_payload","of_pk","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","b_094","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","fee_payer$0","fee_excess","receiver$0","valid_until$0","sign_payload","kp","fake_sign","gen_inner","fee_range","create_body","min_fee","min_fee$0","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","hash_fold_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","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$217","bin_shape_t$164","bin_writer_t$57","bin_reader_t$57","bin_t$57","hash$77","path$58","empty$38","group$218","bin_shape_t$165","bin_writer_t$58","bin_reader_t$58","bin_t$58","hash$78","path$59","group$219","bin_shape_t$166","path$60","group$220","bin_shape_t$167","to_hlist$31","of_hlist$31","to_input$13","of_option$0","to_option$1","map$73","typ$39","option_typ","lazy_option_typ","group$221","bin_shape_t$168","bin_size_t$88","bin_write_t$91","bin_read_t$152","t_of_sexp$142","sexp_of_t$156","compare$156","hash_fold_t$92","t_of_sexp$143","sexp_of_t$157","map$74","to_option$2","of_option$1","is_set","is_keep","deriver$8","gen$9","gen_a","typ$40","optional_typ","to_input$14","to_input$15","group$222","bin_shape_t$169","bin_size_t$89","bin_write_t$92","bin_read_t$153","t_of_sexp$144","sexp_of_t$158","compare$157","hash_fold_t$93","sexp_of_t$159","compare$158","gen$10","to_option$3","of_option$2","deriver_base","deriver$9","to_input$16","typ$41","ignore","group$223","bin_shape_t$170","path$61","to_hlist$32","of_hlist$32","encode$1","decode$2","invalid_public_key","digest_vk","dummy_vk_hash","t_of_sexp$145","sexp_of_t$160","equal$98","hash_fold_t$94","to_binable$14","of_binable$17","path$62","group$224","bin_shape_t$171","bin_size_t$90","bin_write_t$93","bin_read_t$154","typ$42","group$225","t_of_sexp$146","path$63","to_input$17","deriver$10","t_of_sexp$147","sexp_of_t$161","hash$79","empty_hash","push_hash","push_event","push_to_data_as_hash","events","pop_from_data_as_hash","events$0","typ$43","to_input$18","deriver$11","hash$80","typ$44","var_to_input$1","to_input$19","deriver$12","empty$39","max_length$1","check$11","t_of_sexp$148","to_binable$15","of_binable$18","path$64","group$226","t_of_sexp$149","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$33","proved_state","last_action_slot","action_state","zkapp_version","of_hlist$33","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$7","t_toplevel_annots$7","group$227","bin_shape_t$172","bin_size_t$91","bin_write_t$94","bin_read_t$155","v_verification_key","v_zkapp_version","v_action_state","v_last_action_slot","v_proved_state","v_zkapp_uri","t_of_sexp$150","sexp_of_t$162","path$65","zkapp_uri_non_preimage","hash_zkapp_uri_opt","zkapp_uri_opt","hash$81","typ$45","zkapp_uri_to_input","digest$4","default_digest","action_state_deriver","list_5","gen_uri","app_state$2","seq_state","group$228","bin_shape_t$173","bin_writer_t$59","bin_reader_t$59","bin_t$59","hash$82","path$66","max_length$2","check$12","t_of_sexp$151","to_binable$16","of_binable$19","path$67","num_bits$7","to_field$4","byte_index","to_input$20","of_field$4","typ$46","typ$47","var_to_input$2","zkapp","permissions","timing","voting_for","delegate","receipt_chain_hash","nonce$1","balance$1","token_symbol","token_id$3","public_key$3","zkapp$0","permissions$0","timing$0","voting_for$0","delegate$0","receipt_chain_hash$0","nonce$2","balance$2","token_symbol$0","token_id$4","public_key$4","to_hlist$34","of_hlist$34","t_fields_annots$8","t_toplevel_annots$8","group$229","bin_shape_t$174","path$68","group$230","bin_shape_t$175","bin_size_t$92","bin_write_t$95","bin_read_t$156","bin_read_t$157","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","path$69","check$13","to_yojson$53","poly_field","poly_controller","poly_amount","of_yojson$32","arg10$0","arg9$0","arg6$1","arg5$1","arg4$2","arg3$2","arg4$1","x$37","x$36","x$35","value_of_sexp","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","equal$99","cmp_amount","path$70","to_hlist$35","of_hlist$35","zkapp$1","permissions$1","timing$1","voting_for$1","delegate$1","receipt_chain_hash$1","nonce$3","balance$3","token_symbol$1","token_id$5","public_key$5","zkapp$2","permissions$2","timing$2","voting_for$2","delegate$2","receipt_chain_hash$2","nonce$4","balance$4","token_symbol$2","token_id$6","public_key$6","hash_zkapp_account_opt","delegate_opt","digest$5","typ$48","account$0","zkapp$3","typ$49","hash$83","create$107","min_balance_at_slot","min_balance_past_cliff","global_slot_u32","cliff_time_u32","vesting_period_u32","num_periods","vesting_decrement","has_permission","has_permission_to_send","has_permission_to_receive","gen_with_constrained_balance","vesting_end","gen_any_vesting_range","let_syntax_082","vesting_slots","vesting_periods_count","max_cliff_amt","to_vest","vi","group$231","bin_shape_t$176","ledger_hash","t_of_sexp$152","of_ledger_hash","total_currency_field","total_currency_value","sexp_of_t$163","v_total_currency","compare$159","cmp_ledger_hash","t_fields_annots$9","t_toplevel_annots$9","to_hlist$36","total_currency","of_hlist$36","hash$84","total_currency$0","hash$85","total_currency_fun","total_currency_gen","group$232","bin_shape_t$177","t_of_sexp$153","sexp_of_t$164","path$71","group$233","bin_shape_t$178","bin_writer_t$60","bin_reader_t$60","bin_t$60","hash$86","path$72","group$234","bin_shape_t$179","epoch_ledger","start_checkpoint","lock_checkpoint","t_of_sexp$154","of_epoch_ledger","of_epoch_seed","of_start_checkpoint","of_lock_checkpoint","ledger_field","seed_field","start_checkpoint_field","lock_checkpoint_field","epoch_length_field","epoch_length_value","lock_checkpoint_value","start_checkpoint_value","seed_value","ledger_value","sexp_of_t$165","v_epoch_length","v_lock_checkpoint","v_start_checkpoint","v_seed","v_ledger","compare$160","cmp_epoch_ledger","cmp_epoch_seed","cmp_start_checkpoint","cmp_lock_checkpoint","cmp_length","t_fields_annots$10","t_toplevel_annots$10","to_hlist$37","epoch_length","of_hlist$37","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$235","bin_shape_t$180","t_of_sexp$155","sexp_of_t$166","compare$161","a_022","a_018","a_016","path$73","merge$10","if$10","merge$11","f$15","group$236","bin_shape_t$181","t_fields_annots$11","t_toplevel_annots$11","to_hlist$38","of_hlist$38","to_input$21","deriver$13","upper_fun","lower_fun","lower_gen","upper_gen","v_upper","v_lower","run$7","length$29","balance$5","global_slot$0","group$237","bin_shape_t$182","bin_size_t$93","bin_write_t$96","bin_read_t$158","t_of_sexp$156","lower_field","upper_field","upper_value","lower_value","sexp_of_t$167","hash_fold_t$95","compare$162","cmp_a$0","compare$163","deriver$14","range_max","range_uint32","range_uint64","nonce$5","balance$6","amount$1","length$30","deriver$15","v_foo","gen$11","compare_a","to_input$22","to_input$23","to_input_checked","typ$50","check$14","run$8","init$28","action_state$1","boolean$1","receipt_chain_hash$3","frozen_ledger_hash","token_id$7","epoch_seed$0","public_key$7","to_input$24","check$15","typ$51","receipt_chain_hash$4","balance$7","nonce$6","group$238","account$1","t_of_sexp$157","is_new_field","is_new_value","sexp_of_t$168","v_is_new","path$74","t_fields_annots$12","t_toplevel_annots$12","to_hlist$39","is_new","of_hlist$39","sexp_of_t$169","compare$164","a_133","b_134","proved_state$1","action_state$2","state$67","delegate$3","receipt_chain_hash$5","nonce$7","balance$8","is_new$0","proved_state$2","action_state$3","state$68","delegate$4","receipt_chain_hash$6","nonce$8","balance$9","gen$12","accept","nonce$9","deriver$16","is_new_fun","proved_state_fun","action_state_fun","state_fun","delegate_fun","receipt_chain_hash_fun","nonce_fun","balance_fun","balance_gen","nonce_gen","receipt_chain_hash_gen","delegate_gen","state_gen","action_state_gen","proved_state_gen","is_new_gen","to_input$25","to_hlist$40","of_hlist$40","group$239","bin_shape_t$183","size_of_epoch_data","write_epoch_data","of_epoch_data","t_of_sexp$158","of_epoch_data$0","hash_fold_epoch_data","compare$165","a_191","b_192","a_193","b_194","a_189","b_190","a_185","b_186","a_175","b_176","a_177","b_178","path$75","deriver$17","a_203","b_204","max_epoch_length","min_epoch_length","gen$13","to_input$26","to_input$27","group$240","bin_shape_t$184","snarked_ledger_hash","epoch_data","to_hlist$41","next_epoch_data","staking_epoch_data","min_window_density","of_hlist$41","t_of_sexp$159","of_snarked_ledger_hash","of_global_slot","snarked_ledger_hash_field","min_window_density_field","staking_epoch_data_field","next_epoch_data_field","next_epoch_data_value","staking_epoch_data_value","min_window_density_value","snarked_ledger_hash_value","t_fields_annots$13","t_toplevel_annots$13","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$241","protocol_state$1","t_of_sexp$160","sexp_of_t$170","v_next_epoch_data","v_staking_epoch_data","v_min_window_density","v_snarked_ledger_hash","compare$166","a_233","b_234","cmp_epoch_data","a_251","b_252","a_239","b_240","a_241","b_242","a_237","b_238","a_249","b_250","path$76","deriver$18","snarked_ledger_hash$1","max_min_window_density","gen$14","to_input$28","group$242","bin_shape_t$185","path$77","epoch_data_deriver","frozen_ledger_hash$0","state_hash$0","epoch_seed$1","length$31","amount$2","global_slot$1","typ$52","t1$10","a_313","b_314","group$243","bin_shape_t$186","path$78","gen$15","typ$53","group$244","bin_shape_t$187","path$79","to_hlist$42","user","of_hlist$42","group$245","account_transition","group$246","path$80","group$247","group$248","bin_shape_t$188","path$81","group$249","bin_shape_t$189","path$82","to_hlist$43","verification_key_hash","is_proved","is_signed","of_hlist$43","t_fields_annots$14","t_toplevel_annots$14","verification_key_hash$0","is_proved$0","is_signed$0","to_hlist$44","of_hlist$44","typ$54","deriver$19","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$20","typ$55","group$250","bin_shape_t$190","path$83","let_syntax_268","t_fields_annots$15","t_toplevel_annots$15","to_hlist$45","inherit_from_parent","parents_own_token","of_hlist$45","inherit_from_parent$0","parents_own_token$0","typ$56","sum_squared","typ$57","to_input$29","to_variant","of_variant","deriver$21","inherit_from_parent_fun","parents_own_token_fun","parents_own_token_gen","inherit_from_parent_gen","deriver$22","may_use_token","typ$58","group$251","bin_shape_t$191","bin_size_t$94","bin_write_t$97","bin_read_t$159","t_of_sexp$161","sexp_of_t$171","hash_fold_t$96","path$84","t_fields_annots$16","t_toplevel_annots$16","t_of_sexp$162","sexp_of_t$172","to_hlist$46","of_hlist$46","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$47","of_hlist$47","to_input$31","typ$59","deriver$23","group$252","bin_shape_t$192","path$85","t_fields_annots$17","t_toplevel_annots$17","voting_for$3","timing$3","token_symbol$3","zkapp_uri$3","permissions$3","verification_key$1","delegate$5","app_state$3","voting_for$4","timing$4","token_symbol$4","zkapp_uri$4","permissions$4","verification_key$2","delegate$6","app_state$4","to_hlist$48","of_hlist$48","gen$16","permissions_auth","token_account","token_gen","uri_gen","auth_tag","auth_required_gen","set_verification_key_auth","vk$1","to_hlist$49","of_hlist$49","noop","to_input$32","deriver$24","voting_for_fun","timing_fun","token_symbol_fun","zkapp_uri_fun","permissions_fun","verification_key_fun","app_state_fun","app_state_gen","verification_key_gen","permissions_gen","zkapp_uri_gen","token_symbol_gen","timing_gen","voting_for_gen","group$253","bin_shape_t$193","path$86","precondition","gen$17","deriver$25","group$254","bin_shape_t$194","path$87","t_fields_annots$18","t_toplevel_annots$18","to_hlist$50","valid_while","of_hlist$50","account$2","network$1","valid_while$0","account$3","network$2","deriver$26","valid_while_fun","account_fun","network_fun","network_gen","account_gen","valid_while_gen","let_syntax_265","to_hlist$51","of_hlist$51","group$255","bin_shape_t$195","bin_size_t$95","bin_write_t$98","bin_read_t$160","t_of_sexp$163","sexp_of_t$173","hash_fold_t$97","compare$167","a_142","b_143","a_144","b_145","a_146","b_147","path$88","group$256","bin_shape_t$196","path$89","t_fields_annots$19","t_toplevel_annots$19","authorization_kind","implicit_account_creation_fee","use_full_commitment","preconditions","call_depth","call_data","increment_nonce$3","update$6","token_id$8","public_key$8","authorization_kind$0","may_use_token$0","implicit_account_creation_fee$0","use_full_commitment$0","preconditions$0","call_depth$0","call_data$0","increment_nonce$4","balance_change$0","update$7","token_id$9","public_key$9","deriver$27","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","token_id_fun","public_key_fun","token_id_gen","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","compile_acc$12","authorization_kind_gen","group$257","bin_shape_t$197","path$90","group$258","bin_shape_t$198","sexp_of_t$174","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","compare$168","a_206","b_207","path$91","to_hlist$52","of_hlist$52","of_graphql_repr","group$259","bin_shape_t$199","path$92","t_fields_annots$20","t_toplevel_annots$20","nonce$10","fee$1","public_key$10","nonce$11","valid_until$1","fee$2","public_key$11","let_syntax_242","gen$18","deriver$28","valid_until_fun","fee_fun","fee_gen","valid_until_gen","of_fee_payer","to_hlist$53","of_hlist$53","chain","typ$60","non_preimage","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$260","bin_shape_t$200","path$93","t_fields_annots$21","t_toplevel_annots$21","authorization$0","authorization$1","deriver$29","authorization_fun","body_fun","body_gen","authorization_gen","group$261","bin_shape_t$201","path$94","group$262","bin_shape_t$202","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","v_delegate$0","v_authorization","t_of_sexp$164","authorization_field","balance_change_field","events_field","actions_field","call_data_field","preconditions_field","use_full_commitment_field","may_use_token_field","authorization_kind_field","account_field","valid_while_field","valid_while_value","account_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$175","hash_fold_account_update","hash_fold_length","hash$87","path$95","t_of_sexp$165","sexp_of_t$176","of_graphql_repr$0","quickcheck_generator$5","digest$6","create$108","group$263","bin_shape_t$203","hash_fold_t$98","hash$88","path$96","t_fields_annots$22","t_toplevel_annots$22","authorization$2","authorization$3","let_syntax_274","deriver$30","of_fee_payer$0","balance_change$1","public_key$12","token_id$10","increment_nonce$5","group$264","bin_shape_t$204","bin_size_t$96","size_of_field","bin_write_t$99","write_field","bin_read_t$161","v_elt","v_stack_hash","t_of_sexp$166","elt_field","stack_hash_field","stack_hash_value","elt_value","sexp_of_t$177","compare$169","cmp_field","hash_fold_t$99","hash_fold_field","group$265","bin_shape_t$205","t_of_sexp$167","status_field","status_value","sexp_of_t$178","v_status","map$75","group$266","bin_size_t$97","size_of_account_update_digest","bin_write_t$100","write_account_update_digest","bin_read_t$162","of_account_update_digest","v_account_update","v_account_update_digest","v_calls","t_of_sexp$168","account_update_field","account_update_digest_field","calls_field","calls_value","account_update_digest_value","account_update_value","sexp_of_t$179","compare$170","cmp_account_update","cmp_account_update_digest","cmp_digest","hash_fold_t$100","hash_fold_account_update_diges","t_of_sexp$169","fold$21","calls","account_update","mapi_forest_with_trees","map$76","to_yojson$54","symbol$259","group$267","bin_shape_t$206","bin_size_t$98","bin_write_t$101","bin_writer_t$61","bin_read_t$163","bin_read_t$164","bin_reader_t$61","bin_t$61","t_of_sexp$170","sexp_of_t$180","compare$171","equal$100","hash_fold_t$101","func$23","versioned$6","func$24","path$97","to_yojson$55","symbol$260","hash$89","to_yojson$56","symbol$261","group$268","bin_shape_t$207","bin_size_t$99","bin_write_t$102","bin_writer_t$62","bin_read_t$165","bin_read_t$166","bin_reader_t$62","bin_t$62","t_of_sexp$171","sexp_of_t$181","compare$172","equal$101","hash_fold_t$102","func$25","versioned$7","func$26","path$98","to_yojson$57","symbol$262","hash$90","to_yojson$58","symbol$263","group$269","bin_shape_t$208","bin_size_t$100","bin_write_t$103","bin_writer_t$63","bin_read_t$167","bin_read_t$168","bin_reader_t$63","bin_t$63","t_of_sexp$172","sexp_of_t$182","compare$173","equal$102","hash_fold_t$103","func$27","versioned$8","func$28","path$99","to_yojson$59","symbol$264","hash$91","h_tl","cons$0","account_update_digest","stack_hash","group$270","bin_shape_t$209","t_of_sexp$173","sexp_of_t$183","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","hash$92","accumulate_hashes","hash_account_update","calls$0","node_hash","group$271","bin_shape_t$210","group$272","bin_shape_t$211","path$100","empty$40","group$273","bin_shape_t$212","path$101","group$274","bin_shape_t$213","path$102","version$18","t_of_sexp$174","fee_payer_field","account_updates_field","account_updates_value","fee_payer_value","sexp_of_t$184","v_account_updates","v_fee_payer","compare$174","a_224","b_225","a_230","b_231","a_093","a_228","b_229","a_226","b_227","hash_fold_t$104","group$275","bin_shape_t$214","bin_size_t$101","bin_write_t$104","bin_read_t$169","bin_read_t$170","path$103","let_syntax_275","let_syntax_273","calls_length","to_wire","forget_hashes","forget_hash","of_binable$20","path$104","group$276","bin_shape_typ$13","t_fields_annots$23","t_toplevel_annots$23","t_of_sexp$175","sexp_of_t$185","memo$2","account_updates$0","fee_payer$1","fee_payer$2","status_sym","if$11","group$277","bin_shape_t$215","path$105","create_complete","memo_hash","fee_payer_hash","group$278","bin_shape_t$216","path$106","group$279","bin_shape_t$217","t_of_sexp$176","zkapp_command_field","zkapp_command_value","sexp_of_t$186","v_zkapp_command","hash_fold_t$105","path$107","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","group$280","bin_shape_t$218","to_hlist$54","of_hlist$54","group$281","bin_shape_t$219","path$108","forest","group$282","bin_shape_t$220","t_of_sexp$177","of_u","sexp_of_t$187","compare$175","cmp_u","cmp_s","hash_fold_t$106","hash_fold_u","hash_fold_s","to_signed_command","gen_signed","group$283","bin_shape_t$221","t_of_sexp$178","sexp_of_t$188","hash_fold_t$107","path$109","group$284","bin_shape_t$222","path$110","group$285","bin_shape_t$223","t_of_sexp$179","sexp_of_t$189","hash_fold_t$108","path$111","with_random_receivers","size_args$0","a_012","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","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","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","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","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","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","a_044","t_of_sexp$12","sexp_of_t$12","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$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","hash_fold_t$7","versioned$11","hash$6","to_latest$7","equal$11","compare$9","sexp_of_t$17","func$2","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","hash_fold_t$9","sexp_of_t$20","compare$10","a_076","b_077","symbol$21","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","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","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","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$2","prev_state","symbol$22","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","symbol$23","symbol$24","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","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","set_all_mutable_fields","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","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$286","bin_shape_t$224","path$112","v_prover","prover_field","prover_value","compare$176","group$287","bin_shape_t$225","sexpifier$3","path$113","compare$177","end_time","gen$19","value_of_t","typ$61","p_var","transaction_dummy","group$288","bin_shape_t$226","path$114","group$289","bin_shape_t$227","path$115","group$290","bin_shape_t$228","t_of_sexp$180","sexp_of_t$190","compare$178","path$116","equal_account_state","group$291","bin_shape_t$229","command","t_of_sexp$181","of_command","sexp_of_t$191","compare$179","cmp_command","hash_fold_t$109","hash_fold_command","group$292","bin_shape_t$230","t_of_sexp$182","sexp_of_t$192","compare$180","hash_fold_t$110","func$29","path$117","group$293","bin_shape_t$231","t_of_sexp$183","sexp_of_t$193","compare$181","hash_fold_t$111","func$30","path$118","compare_hash","group$294","bin_shape_t$232","bin_read_t$171","bin_read_t$172","bin_reader_t$64","bin_size_t$102","bin_write_t$105","bin_writer_t$64","bin_t$64","group$295","bin_shape_t$233","bin_read_t$173","bin_read_t$174","bin_reader_t$65","bin_size_t$103","bin_write_t$106","bin_writer_t$65","bin_t$65","mk_hasher","bin_size_t$104","bin_write_t$107","bin_read_t$175","bin_read_t$176","bin_shape_t$234","bin_writer_t$66","bin_reader_t$66","bin_t$66","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$296","bin_shape_t$235","t_of_sexp$184","sexp_of_t$194","compare$182","path$119","group$297","bin_shape_t$236","t_of_sexp$185","sexp_of_t$195","compare$183","path$120","recoded","group$298","signed_amount","group$299","failure_status_tbl","bin_shape_t$237","path$121","group$300","bin_shape_t$238","path$122","t_of_sexp$186","user_command_field","user_command_value","sexp_of_t$196","v_user_command","group$301","bin_shape_t$239","path$123","t_of_sexp$187","previous_delegate_field","previous_delegate_value","new_accounts_field","new_accounts_value","sexp_of_t$197","v_new_accounts","v_previous_delegate","group$302","bin_shape_t$240","path$124","t_of_sexp$188","sexp_of_t$198","group$303","bin_shape_t$241","path$125","t_of_sexp$189","accounts_field","command_field","command_value","accounts_value","sexp_of_t$199","v_command","v_accounts","group$304","bin_shape_t$242","path$126","t_of_sexp$190","sexp_of_t$200","group$305","bin_shape_t$243","path$127","t_of_sexp$191","burned_tokens_field","burned_tokens_value","sexp_of_t$201","v_burned_tokens","group$306","bin_shape_t$244","path$128","t_of_sexp$192","coinbase_field","coinbase_value","sexp_of_t$202","v_coinbase","group$307","bin_shape_t$245","path$129","t_of_sexp$193","sexp_of_t$203","group$308","bin_shape_t$246","path$130","t_of_sexp$194","previous_hash_field","varying_field","varying_value","previous_hash_value","sexp_of_t$204","v_varying","v_previous_hash","burned_tokens","varying","new_accounts","zc","supply_increase","burned_tokens$0","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","custom_printf_005","custom_printf_006","validate_timing","error_opt","get_with_location","set_with_location","sub_account_creation_fee","custom_printf_007","custom_printf_008","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","custom_printf_009","custom_printf_010","custom_printf_011","custom_printf_012","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","pop_exn","onto","add_check","eff","global_state","local_state","new_account","local_state$0","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_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$2","to_pop$0","next_forest","current_is_empty","call_stack$0","current_forest","remainder_of_current_forest","account_update_forest","account_update$0","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","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","older_than_current_version","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","eta","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","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","symbol$265","raise_error","json_parse","typ$62","exists$12","size_in_fields","exists_one","in_prover$1","set_eval_constraints$0","enter_constraint_system","enter_generate_witness","enter_as_prover","alloc_var$0","set_as_prover$0","has_witness","get_variable_value$0","digest$7","read_var$0","assert_mul","assert_square$5","assert_boolean","compare$184","truncate_to_bits16","length_div_16","add_gate","zero$20","generic","sm","poseidon","ec_add","ec_scale","ec_endoscale","ec_endoscalar","lookup$4","rotate","add_fixed_lookup_table","add_runtime_table_config","of_js$0","prove","verify$1","public_input_vec","get_vk","get_cs_json","update$8","hash_to_group","sponge_params_checked","sponge_create","is_checked","sponge_absorb","sponge_squeeze","hashToGroup","getVerificationKey","getConstraintSystemJSON","ecAdd","ecScale","ecEndoscale","ecEndoscalar","rangeCheck0","rangeCheck1","foreignFieldAdd","foreignFieldMul","addFixedLookupTable","addRuntimeTableConfig","readVar","assertEqual","assertMul","assertSquare","assertBoolean","truncateToBits16","toJson","existsOne","inProver","asProver","inProverBlock","setEvalConstraints","enterConstraintSystem","enterGenerateWitness","enterAsProver","snarky","public_input_typ","statement_typ","input_size","output_size","inner_curve_typ","should_verifys_js","js_bool","should_verifys","public_output_size","statements","simple$3","read$2","should_write","cache_hit","write$1","or_error","map_error$1","write$5","read$5","read$6","write$6","write$3","read$3","read$4","write$4","write$2","cache_dir","can_write","nat_modules_list","nat_add_modules_list","pickles_compile","max_proofs","storables$0","to_js_provers","js_prevs","js_result","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","verify$2","load_srs_fp","load_srs_fq","dummy_verification_key","encode_verification_key","decode_verification_key","vk_or_error","to_ml_string","from_ml_string","side_loaded_create","public_input_length","public_output_length","feature_flags_js","vk_to_circuit","vk_digest","checked_vk","in_prover$2","pickles","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$31","body_deriver","of_json$0","get_network_id_of_js_string","hash_to_group$0","sign_field_element","typ$63","account_update$1","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_zkapp_command$0","hash_payment_v1","b58","serialize_common","serialize_payment","serialize_payment_v1","example_payment","hashPayment","hashPaymentV1","serializeCommon","serializePayment","serializePaymentV1","hashZkAppCommand","examplePayment","accountUpdate","transactionCommitments","zkappPublicInput","signFieldElement","dummySignature","deriveChecked","toBase58","ofBase58","publicKeyToBase58","publicKeyOfBase58","privateKeyToBase58","privateKeyOfBase58","tokenIdToBase58","tokenIdOfBase58","memoToBase58","memoHashBase58","test$0","class$1","get$19","location_of_account","set$16","next_location","get_or_create","get_or_create_account","create_new_account","empty$41","with_ledger","create_masked","default_token_id","account_id$0","create$109","deriver$32","last_action_slot_fun","zkapp_version_fun","zkapp_version_gen","last_action_slot_gen","zkapp_fun","compile_acc$13","compile_acc$14","compile_acc$15","compile_acc$16","zkapp_gen","transform","get_account","add_account","bal_u64","deriver$33","apply_json_transaction","network_json","network_state","who","application_result","static_method","method","prototype","export$1","export_global","snarky_obj"],"sources":["","/home/trivo/.opam/default/lib/core_kernel/strftime.js","/home/trivo/.opam/default/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/bindings/ocaml/jsoo_exports/overrides.js","/builtin/+marshal.js","/home/trivo/.opam/default/lib/base/base_internalhash_types/runtime.js","/builtin/+nat.js","/builtin/+jslib.js","/home/trivo/.opam/default/lib/base_bigstring/runtime.js","/builtin/+bigstring.js","/home/trivo/.opam/default/lib/bigstringaf/runtime.js","/home/trivo/.opam/default/lib/bin_prot/runtime.js","/builtin/+array.js","/builtin/+backtrace.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/bindings.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/bindings-bigint256.js","/builtin/+compare.js","/builtin/+weak.js","/builtin/+gc.js","/builtin/+format.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/node_js/node_backend.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/bindings-vector.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/trivo/.opam/default/lib/ppx_expect/collector/runtime.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/bindings-curve.js","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/js/bindings-field.js","/home/trivo/.opam/default/lib/core_kernel/runtime.js","/workspace_root/src/mina/src/lib/promise/js/promise.js","/workspace_root/src/mina/src/lib/integers_stubs_js/runtime.js","/home/trivo/.opam/default/lib/zarith_stubs_js/biginteger.js","/home/trivo/.opam/default/lib/zarith_stubs_js/runtime.js","/home/trivo/.opam/default/lib/time_now/runtime.js","/home/trivo/.opam/default/lib/ocaml/obj.ml","/workspace_root/src/mina/src/lib/pickles/limb_vector/constant.ml","/home/trivo/.opam/default/lib/ocaml/int64.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/random.ml","/home/trivo/.opam/default/lib/ocaml/lexing.ml","/home/trivo/.opam/default/lib/ocaml/camlinternalFormat.ml","/home/trivo/.opam/default/lib/ocaml/printexc.ml","/home/trivo/.opam/default/lib/ocaml/filename.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/exn.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/sign0.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/hex_lexer.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/popcount.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/int63_emul.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/backtrace.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_bench.v0.14.1/_build/default/runtime-lib/benchmark_accumulator.ml","/home/trivo/.opam/default/.opam-switch/build/bin_prot.v0.14.0/_build/default/shape/src/bin_shape.ml","/home/trivo/.opam/default/.opam-switch/build/stdio.v0.14.0/_build/default/src/in_channel.ml","/home/trivo/.opam/default/.opam-switch/build/stdio.v0.14.0/_build/default/src/out_channel.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_module_timer.v0.14.0/_build/default/runtime/ppx_module_timer_runtime.ml","/home/trivo/.opam/default/.opam-switch/build/typerep.v0.14.0/_build/default/lib/std_internal.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_expect.v0.14.2/_build/default/collector/check_backtraces.ml","/home/trivo/.opam/default/.opam-switch/build/splittable_random.v0.14.0/_build/default/src/splittable_random.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/positions.ml","/home/trivo/.opam/default/lib/core_kernel/perms.ml","/home/trivo/.opam/default/lib/core_kernel/quickcheck.ml","/home/trivo/.opam/default/lib/core_kernel/std_internal.ml","/home/trivo/.opam/default/lib/core_kernel/span_float.ml","/home/trivo/.opam/default/lib/core_kernel/tuple.ml","/home/trivo/.opam/default/lib/core_kernel/digit_string_helpers.ml","/home/trivo/.opam/default/lib/core_kernel/month.ml","/home/trivo/.opam/default/lib/core_kernel/date0.ml","/home/trivo/.opam/default/lib/core_kernel/percent.ml","/home/trivo/.opam/default/lib/core_kernel/ofday_float.ml","/home/trivo/.opam/default/lib/core_kernel/span_ns.ml","/home/trivo/.opam/default/lib/core_kernel/ofday_ns.ml","/home/trivo/.opam/default/lib/core_kernel/gc.ml","/home/trivo/.opam/default/.opam-switch/build/easy-format.1.3.2/_build/default/src/easy_format.ml","/home/trivo/.opam/default/.opam-switch/build/yojson.1.7.0/_build/default/lib/pretty.ml","/home/trivo/.opam/default/.opam-switch/build/yojson.1.7.0/_build/default/lib/read.ml","/home/trivo/.opam/default/.opam-switch/build/bigstringaf.0.5.0/_build/default/lib/bigstringaf.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_blake2b.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_blake2s.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/digestif.ml","/workspace_root/src/mina/src/lib/blake2/blake2.ml","/home/trivo/.opam/default/lib/core_kernel/tuple_pool/tuple_pool.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/validate.ml","/home/trivo/.opam/default/lib/core_kernel/thread_pool_cpu_affinity/thread_pool_cpu_affinity.ml","/home/trivo/.opam/default/lib/core_kernel/uopt/uopt.ml","/home/trivo/.opam/default/lib/core_kernel/timing_wheel/timing_wheel.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_kernel_config.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/monitor.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_kernel.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/config.mlp","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/misc.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/profile.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/warnings.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/docstrings.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/parser.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/lexer.mll","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/location.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/lexer.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/ident.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/attr_helper.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/primitive.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/shape.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/btype.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/subst.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/ctype.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/includecore.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/parmatch.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typeopt.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/printtyp.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typecore.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typeclass.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/env.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typemod.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/translcore.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/lambda.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/switch.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/matching.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/translattribute.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/translclass.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/translmod.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_412.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/pprintast.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_413.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_414.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_411.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_410.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_409.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_408.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_407.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_406.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_405.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_404.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_403.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/ast_402.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_403_402.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/ast/versions.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/stdppx/stdppx.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/ast_builder.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/name.ml","/home/trivo/.opam/default/lib/ocaml/camlinternalOO.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/deriving.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/ppx_quickcheck/expander/environment.ml","/workspace_root/src/mina/src/lib/protocol_version/protocol_version.ml","/home/trivo/.opam/default/lib/bignum/bigint/bigint.ml","/workspace_root/src/mina/src/lib/snarky/src/base/cvar.ml","/workspace_root/src/mina/src/lib/snarky/src/base/constraint.ml","/workspace_root/src/mina/src/lib/snarky/src/base/backend_extended.ml","/workspace_root/src/mina/src/lib/snarky/src/base/checked_runner.ml","/workspace_root/src/mina/src/lib/snarky/src/base/utils.ml","/workspace_root/src/mina/src/lib/snarky/src/base/merkle_tree.ml","/workspace_root/src/mina/src/lib/snarky/src/base/snark0.ml","/workspace_root/src/mina/src/lib/pickles_types/shifted_value.ml","/workspace_root/src/mina/src/lib/pickles_types/plonk_types.ml","/workspace_root/src/mina/src/lib/pickles/pickles.ml","/workspace_root/src/mina/src/lib/pickles_types/plonk_verification_key_evals.ml","/workspace_root/src/mina/src/lib/hex/hex.ml","/workspace_root/src/mina/src/lib/snarky/sponge/sponge.ml","/workspace_root/src/mina/src/lib/allocation_functor/table.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/scale_round.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/scalar_challenge.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/curve.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/plonk_dlog_proof.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/bigint.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/endoscale_round.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/endoscale_scalar_round.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/field.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/plonk_constraint_system.ml","/workspace_root/src/mina/src/lib/snarky/fold_lib/fold.ml","/workspace_root/src/mina/src/lib/snarky/snarkette/fields.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/vesta_based_plonk.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/pallas_based_plonk.ml","/workspace_root/src/mina/src/lib/random_oracle_input/random_oracle_input.ml","/workspace_root/src/mina/src/lib/pickles_base/proofs_verified.ml","/workspace_root/src/mina/src/lib/pickles_base/side_loaded_verification_key.ml","/workspace_root/src/mina/src/lib/pickles_base/domain.ml","/workspace_root/src/mina/src/lib/pickles/composition_types/branch_data.ml","/workspace_root/src/mina/src/lib/pickles/composition_types/bulletproof_challenge.ml","/workspace_root/src/mina/src/lib/pickles/composition_types/composition_types.ml","/workspace_root/src/mina/src/lib/pickles/plonk_checks/scalars.ml","/workspace_root/src/mina/src/lib/snarky/snarky_curve/snarky_curve.ml","/workspace_root/src/mina/src/lib/snark_keys_header/snark_keys_header.ml","/workspace_root/src/mina/src/lib/error_json/error_json.ml","/workspace_root/src/mina/src/lib/pickles/wrap_wire_proof.ml","/workspace_root/src/mina/src/lib/pickles/scalar_challenge.ml","/workspace_root/src/mina/src/lib/pickles/plonk_curve_ops.ml","/workspace_root/src/mina/src/lib/pickles/reduced_messages_for_next_proof_over_same_field.ml","/workspace_root/src/mina/src/lib/pickles/step_main_inputs.ml","/workspace_root/src/mina/src/lib/pickles/side_loaded_verification_key.ml","/workspace_root/src/mina/src/lib/pickles/proof.ml","/workspace_root/src/mina/src/lib/pickles/wrap_main_inputs.ml","/workspace_root/src/mina/src/lib/pickles/wrap_verifier.ml","/workspace_root/src/mina/src/lib/pickles_types/opt.ml","/workspace_root/src/mina/src/lib/pickles/step_verifier.ml","/workspace_root/src/mina/src/lib/pickles/verification_key.ml","/workspace_root/src/mina/src/lib/pickles/proof_cache.ml","/workspace_root/src/mina/src/lib/pickles/cache.ml","/workspace_root/src/mina/src/lib/snark_params/snark_params.ml","/workspace_root/src/mina/src/lib/random_oracle/permutation/external/random_oracle_permutation.ml","/workspace_root/src/mina/src/lib/random_oracle/random_oracle.ml","/workspace_root/src/mina/src/lib/node_config/node_config.ml","/workspace_root/src/mina/src/lib/non_zero_curve_point/non_zero_curve_point.ml","/workspace_root/src/mina/src/lib/signature_lib/private_key.ml","/workspace_root/src/mina/src/lib/signature_lib/schnorr.ml","/workspace_root/src/mina/src/lib/signature_lib/keypair.ml","/workspace_root/src/mina/src/lib/sgn/sgn.ml","/workspace_root/src/mina/src/lib/sparse_ledger_lib/sparse_ledger.ml","/workspace_root/src/mina/src/lib/rosetta_coding/coding.ml","/workspace_root/src/mina/src/lib/currency/signed_poly.ml","/workspace_root/src/mina/src/lib/currency/currency.ml","/workspace_root/src/mina/src/lib/node_config/for_unit_tests/node_config_for_unit_tests.ml","/home/trivo/.opam/default/.opam-switch/build/re.1.9.0/_build/default/lib/cset.ml","/home/trivo/.opam/default/.opam-switch/build/graphql_parser.0.12.2/_build/default/graphql_parser/src/parser.ml","/home/trivo/.opam/default/.opam-switch/build/graphql_parser.0.12.2/_build/default/graphql_parser/src/lexer.ml","/home/trivo/.opam/default/.opam-switch/build/graphql.0.13.0/_build/default/graphql/src/graphql_schema.ml","/workspace_root/src/mina/src/lib/fields_derivers/fields_derivers.ml","/workspace_root/src/mina/src/lib/fields_derivers_graphql/fields_derivers_graphql.ml","/workspace_root/src/mina/src/lib/fields_derivers_json/fields_derivers_json.ml","/workspace_root/src/mina/src/lib/with_hash/with_hash.ml","/workspace_root/src/mina/src/lib/fields_derivers_zkapps/fields_derivers_zkapps.ml","/workspace_root/src/mina/src/lib/data_hash_lib/state_hash.ml","/workspace_root/src/mina/src/lib/genesis_constants/genesis_constants.ml","/workspace_root/src/mina/src/lib/block_time/block_time.ml","/workspace_root/src/mina/src/lib/one_or_two/one_or_two.ml","/workspace_root/src/mina/src/lib/mina_base/account_id.ml","/workspace_root/src/mina/src/lib/mina_base/account_timing.ml","/workspace_root/src/mina/src/lib/mina_base/signature.ml","/workspace_root/src/mina/src/lib/mina_base/control.ml","/workspace_root/src/mina/src/lib/mina_base/payment_payload.ml","/workspace_root/src/mina/src/lib/mina_base/ledger_hash0.ml","/workspace_root/src/mina/src/lib/mina_base/permissions.ml","/workspace_root/src/mina/src/lib/mina_base/signed_command_memo.ml","/workspace_root/src/mina/src/lib/mina_base/stake_delegation.ml","/workspace_root/src/mina/src/lib/mina_base/transaction_status.ml","/workspace_root/src/mina/src/lib/mina_base/transaction_union_tag.ml","/workspace_root/src/mina/src/lib/mina_base/signed_command_payload.ml","/workspace_root/src/mina/src/lib/mina_base/signed_command.ml","/workspace_root/src/mina/src/lib/mina_base/receipt.ml","/workspace_root/src/mina/src/lib/mina_base/state_body_hash.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_basic.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_account.ml","/workspace_root/src/mina/src/lib/mina_base/account.ml","/workspace_root/src/mina/src/lib/mina_base/epoch_ledger.ml","/workspace_root/src/mina/src/lib/mina_base/epoch_seed.ml","/workspace_root/src/mina/src/lib/mina_base/epoch_data.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_precondition.ml","/workspace_root/src/mina/src/lib/mina_base/data_as_hash.ml","/workspace_root/src/mina/src/lib/mina_base/account_update.ml","/workspace_root/src/mina/src/lib/mina_base/with_stack_hash.ml","/workspace_root/src/mina/src/lib/mina_base/with_status.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_command.ml","/workspace_root/src/mina/src/lib/mina_base/user_command.ml","/workspace_root/src/mina/src/lib/mina_base/fee_transfer.ml","/workspace_root/src/mina/src/lib/mina_base/coinbase_fee_transfer.ml","/workspace_root/src/mina/src/lib/mina_base/coinbase.ml","/workspace_root/src/mina/src/lib/mina_base/pending_coinbase.ml","/workspace_root/src/mina/src/lib/mina_base/staged_ledger_hash.ml","/workspace_root/src/mina/src/lib/mina_base/sok_message.ml","/workspace_root/src/mina/src/lib/mina_base/protocol_constants_checked.ml","/workspace_root/src/mina/src/lib/mina_base/fee_with_prover.ml","/workspace_root/src/mina/src/lib/transaction/transaction.ml","/workspace_root/src/mina/src/lib/transaction/transaction_hash.ml","/workspace_root/src/mina/src/lib/transaction_logic/mina_transaction_logic.ml","/workspace_root/src/bindings/ocaml/lib/pickles_bindings.ml","/workspace_root/src/bindings/ocaml/lib/consistency_test.ml","/home/trivo/.opam/default/lib/ocaml/camlinternalFormatBasics.ml","/home/trivo/.opam/default/lib/ocaml/camlinternalAtomic.ml","/home/trivo/.opam/default/lib/ocaml/stdlib.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/base.ml","/home/trivo/.opam/default/lib/ocaml/stdlib.mli","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/int_intf.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/float0.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/pipe.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/int_conversions.ml","/home/trivo/.opam/default/lib/ocaml/list.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/terminfo.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/ppx_quickcheck/expander/import.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/stdlib/sys.ml.in","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/sys0.ml","/home/trivo/.opam/default/.opam-switch/build/bin_prot.v0.14.0/_build/default/src/write.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/targetint.ml","/home/trivo/.opam/default/lib/ocaml/camlinternalLazy.ml","/home/trivo/.opam/default/lib/ocaml/lazy.ml","/home/trivo/.opam/default/lib/ocaml/seq.ml","/home/trivo/.opam/default/lib/ocaml/option.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/diffing.ml","/home/trivo/.opam/default/lib/ocaml/result.ml","/home/trivo/.opam/default/lib/ocaml/char.ml","/home/trivo/.opam/default/lib/ocaml/int.ml","/home/trivo/.opam/default/lib/ocaml/bytes.ml","/home/trivo/.opam/default/lib/ocaml/string.ml","/home/trivo/.opam/default/lib/ocaml/marshal.ml","/home/trivo/.opam/default/lib/ocaml/array.ml","/home/trivo/.opam/default/lib/ocaml/int32.ml","/home/trivo/.opam/default/lib/ocaml/nativeint.ml","/home/trivo/.opam/default/lib/ocaml/parsing.ml","/home/trivo/.opam/default/lib/ocaml/set.ml","/home/trivo/.opam/default/lib/ocaml/map.ml","/home/trivo/.opam/default/lib/ocaml/stack.ml","/home/trivo/.opam/default/lib/ocaml/queue.ml","/home/trivo/.opam/default/lib/ocaml/buffer.ml","/home/trivo/.opam/default/lib/ocaml/printf.ml","/home/trivo/.opam/default/.opam-switch/build/base_bigstring.v0.14.0/_build/default/src/base_bigstring.ml","/home/trivo/.opam/default/lib/ocaml/arg.ml","/home/trivo/.opam/default/lib/core_kernel/printexc.ml","/home/trivo/.opam/default/lib/ocaml/fun.ml","/home/trivo/.opam/default/lib/ocaml/digest.ml","/home/trivo/.opam/default/lib/ocaml/random.ml","/home/trivo/.opam/default/lib/ocaml/hashtbl.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/attribute.ml","/home/trivo/.opam/default/lib/ocaml/format.ml","/home/trivo/.opam/default/.opam-switch/build/re.1.9.0/_build/default/lib/fmt.ml","/home/trivo/.opam/default/.opam-switch/build/re.1.9.0/_build/default/lib/pmark.ml","/home/trivo/.opam/default/.opam-switch/build/yojson.1.7.0/_build/default/lib/write2.ml","/home/trivo/.opam/default/lib/ocaml/scanf.ml","/home/trivo/.opam/default/lib/ocaml/callback.ml","/home/trivo/.opam/default/lib/ocaml/camlinternalMod.ml","/home/trivo/.opam/default/lib/ocaml/bigarray.ml","/home/trivo/.opam/default/.opam-switch/build/sexplib0.v0.14.0/_build/default/src/lazy_group_id.ml","/home/trivo/.opam/default/.opam-switch/build/sexplib0.v0.14.0/_build/default/src/sexp.ml","/home/trivo/.opam/default/.opam-switch/build/sexplib0.v0.14.0/_build/default/src/sexp_conv.ml","/home/trivo/.opam/default/lib/ocaml/ephemeron.ml","/home/trivo/.opam/default/.opam-switch/build/sexplib0.v0.14.0/_build/default/src/sexp_conv_error.ml","/home/trivo/.opam/default/lib/core_kernel/span_helpers.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/import0.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/printf.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/array0.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/char0.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/list0.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/hash.ml","/workspace_root/src/mina/src/lib/bounded_types/bounded_types.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/ppx_compare_lib.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/string0.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/sexp.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/sexpable.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/word_size.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/pretty_printer.ml","/home/trivo/.opam/default/lib/core_kernel/core_kernel.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/with_return.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/monad.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/comparator.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/field.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/source_code_position0.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/list1.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/result.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/container_intf.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/container.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/lazy.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/monad_intf.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/fn.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/list.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/ordering.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/applicative.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/info.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/error.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/invariant.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/maybe_bound.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/or_error.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/comparable.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/identifiable.ml","/home/trivo/.opam/default/lib/core_kernel/comparable_intf.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/unit.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/ordered_collection_common.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/binary_search.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/binary_searchable.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/bytes0.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/blit.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/option.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/either.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/indexed_container.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/sequence.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/array.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/obj_array.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/uniform_array.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/char.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/string.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/bytes.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/hex_lexer.mll","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/pow_overflow_bounds.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/int_math.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/int.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/type_equal.ml","/home/trivo/.opam/default/lib/core_kernel/univ_map.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/option_array.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/stack.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/set.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/set_intf.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/queue.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/nothing.ml","/home/trivo/.opam/default/lib/core_kernel/never_returns.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/nativeint.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/map.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/map_intf.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/int64.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/bool.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/int32.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/int63.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/hashtbl.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/hashtbl_intf.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/hashable_intf.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/avltree.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/hash_set_intf.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/hash_set.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/float.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/src/buffer.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_assert.v0.14.0/_build/default/runtime-lib/runtime.ml","/home/trivo/.opam/default/.opam-switch/build/base.v0.14.3/_build/default/md5/src/md5_lib.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/otherlibs/unix/unix.ml","/home/trivo/.opam/default/.opam-switch/build/bin_prot.v0.14.0/_build/default/src/common.ml","/workspace_root/src/mina/src/lib/pickles_types/vector.ml","/home/trivo/.opam/default/.opam-switch/build/bin_prot.v0.14.0/_build/default/src/read.ml","/home/trivo/.opam/default/.opam-switch/build/bin_prot.v0.14.0/_build/default/src/shape.ml","/home/trivo/.opam/default/.opam-switch/build/bin_prot.v0.14.0/_build/default/src/size.ml","/home/trivo/.opam/default/.opam-switch/build/bin_prot.v0.14.0/_build/default/src/type_class.ml","/home/trivo/.opam/default/.opam-switch/build/bin_prot.v0.14.0/_build/default/src/utils.ml","/home/trivo/.opam/default/.opam-switch/build/bin_prot.v0.14.0/_build/default/src/std.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_inline_test.v0.14.1/_build/default/config/inline_test_config.ml","/home/trivo/.opam/default/.opam-switch/build/time_now.v0.14.0/_build/default/src/time_now.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_inline_test.v0.14.1/_build/default/runtime-lib/runtime.ml","/home/trivo/.opam/default/.opam-switch/build/typerep.v0.14.0/_build/default/lib/typename.ml","/home/trivo/.opam/default/.opam-switch/build/typerep.v0.14.0/_build/default/lib/make_typename.ml","/home/trivo/.opam/default/.opam-switch/build/typerep.v0.14.0/_build/default/lib/variant_and_record_intf.ml","/home/trivo/.opam/default/.opam-switch/build/typerep.v0.14.0/_build/default/lib/typerep_obj.ml","/home/trivo/.opam/default/.opam-switch/build/typerep.v0.14.0/_build/default/lib/type_abstract.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_expect.v0.14.2/_build/default/common/file.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_expect.v0.14.2/_build/default/collector/expect_test_collector.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_expect.v0.14.2/_build/default/config/types/expect_test_config_types_intf.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_expect.v0.14.2/_build/default/collector/check_backtraces.mll","/home/trivo/.opam/default/.opam-switch/build/ppx_expect.v0.14.2/_build/default/config/types/expect_test_config_types.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_expect.v0.14.2/_build/default/config/expect_test_config.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/src/generator.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/src/bigarray_helpers.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/src/observer0.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/src/shrinker.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/src/test.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/src/observer.ml","/home/trivo/.opam/default/lib/core_kernel/base_for_tests/test_blit.ml","/home/trivo/.opam/default/lib/core_kernel/base_for_tests/test_binary_searchable.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/parsexp.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/automaton_stack.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/of_sexp_error.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/parse_error.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/parser_automaton_internal.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/parser_automaton.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/kind.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/automaton_helpers.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/parser.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/conv.ml","/home/trivo/.opam/default/.opam-switch/build/sexplib.v0.14.0/_build/default/src/pre_sexp.ml","/home/trivo/.opam/default/.opam-switch/build/parsexp.v0.14.2/_build/default/src/old_parser_cont_state.ml","/home/trivo/.opam/default/.opam-switch/build/sexplib.v0.14.0/_build/default/src/conv.ml","/home/trivo/.opam/default/lib/core_kernel/import.ml","/home/trivo/.opam/default/lib/core_kernel/sexpable.ml","/home/trivo/.opam/default/lib/core_kernel/binable_intf.ml","/home/trivo/.opam/default/lib/core_kernel/binable0.ml","/home/trivo/.opam/default/lib/core_kernel/printf.ml","/home/trivo/.opam/default/lib/core_kernel/comparator.ml","/home/trivo/.opam/default/lib/core_kernel/result.ml","/home/trivo/.opam/default/lib/core_kernel/container.ml","/home/trivo/.opam/default/lib/core_kernel/deprecate_pipe_bang.ml","/home/trivo/.opam/default/lib/core_kernel/fn.ml","/home/trivo/.opam/default/lib/core_kernel/ordered_collection_common.ml","/home/trivo/.opam/default/lib/core_kernel/sequence.ml","/home/trivo/.opam/default/lib/core_kernel/array.ml","/home/trivo/.opam/default/lib/core_kernel/source_code_position0.ml","/home/trivo/.opam/default/lib/core_kernel/info.ml","/home/trivo/.opam/default/lib/core_kernel/error.ml","/home/trivo/.opam/default/lib/core_kernel/t.ml","/home/trivo/.opam/default/lib/core_kernel/list0.ml","/home/trivo/.opam/default/lib/core_kernel/hashtbl.ml","/home/trivo/.opam/default/lib/core_kernel/hash_set.ml","/home/trivo/.opam/default/lib/core_kernel/or_error.ml","/home/trivo/.opam/default/lib/core_kernel/map.ml","/home/trivo/.opam/default/lib/core_kernel/set.ml","/home/trivo/.opam/default/lib/core_kernel/comparable.ml","/home/trivo/.opam/default/lib/core_kernel/doubly_linked_intf.ml","/home/trivo/.opam/default/lib/core_kernel/list.ml","/home/trivo/.opam/default/lib/core_kernel/option.ml","/home/trivo/.opam/default/lib/core_kernel/union_find.ml","/home/trivo/.opam/default/lib/core_kernel/doubly_linked.ml","/home/trivo/.opam/default/lib/core_kernel/bag.ml","/home/trivo/.opam/default/lib/core_kernel/sexp.ml","/home/trivo/.opam/default/lib/core_kernel/hash_queue.ml","/home/trivo/.opam/default/lib/core_kernel/hashable.ml","/home/trivo/.opam/default/lib/core_kernel/identifiable.ml","/home/trivo/.opam/default/lib/core_kernel/bool.ml","/home/trivo/.opam/default/lib/core_kernel/hexdump_intf.ml","/home/trivo/.opam/default/lib/core_kernel/hexdump.ml","/home/trivo/.opam/default/lib/core_kernel/string.ml","/home/trivo/.opam/default/lib/core_kernel/bytes.ml","/home/trivo/.opam/default/lib/core_kernel/char.ml","/home/trivo/.opam/default/lib/core_kernel/core_pervasives.ml","/home/trivo/.opam/default/lib/core_kernel/sign.ml","/home/trivo/.opam/default/lib/core_kernel/float.ml","/home/trivo/.opam/default/lib/core_kernel/int.ml","/home/trivo/.opam/default/lib/core_kernel/int32.ml","/workspace_root/src/mina/src/lib/unsigned_extended/unsigned_extended.ml","/home/trivo/.opam/default/lib/core_kernel/int64.ml","/home/trivo/.opam/default/lib/core_kernel/int63.ml","/home/trivo/.opam/default/lib/core_kernel/unit.ml","/home/trivo/.opam/default/lib/core_kernel/interfaces.ml","/home/trivo/.opam/default/lib/core_kernel/lazy.ml","/home/trivo/.opam/default/lib/core_kernel/nativeint.ml","/home/trivo/.opam/default/lib/core_kernel/nothing.ml","/home/trivo/.opam/default/lib/core_kernel/ordering.ml","/home/trivo/.opam/default/lib/core_kernel/ref.ml","/workspace_root/src/mina/src/lib/transaction_logic/zkapp_command_logic.ml","/home/trivo/.opam/default/lib/core_kernel/byte_units0.ml","/home/trivo/.opam/default/lib/core_kernel/bigstring.ml","/home/trivo/.opam/default/lib/core_kernel/core_bin_prot.ml","/home/trivo/.opam/default/lib/core_kernel/md5.ml","/home/trivo/.opam/default/lib/core_kernel/zone_intf.ml","/home/trivo/.opam/default/lib/core_kernel/binable.ml","/home/trivo/.opam/default/lib/core_kernel/zone.ml","/home/trivo/.opam/default/lib/core_kernel/source_code_position.ml","/home/trivo/.opam/default/lib/core_kernel/validated.ml","/home/trivo/.opam/default/lib/core_kernel/type_equal.ml","/home/trivo/.opam/default/lib/core_kernel/univ_map_intf.ml","/home/trivo/.opam/default/lib/core_kernel/unit_of_time.ml","/home/trivo/.opam/default/lib/core_kernel/unique_id.ml","/home/trivo/.opam/default/lib/core_kernel/uniform_array.ml","/home/trivo/.opam/default/lib/core_kernel/day_of_week.ml","/home/trivo/.opam/default/lib/core_kernel/ofday_helpers.ml","/home/trivo/.opam/default/lib/core_kernel/stable_internal.ml","/home/trivo/.opam/default/lib/core_kernel/float_with_finite_only_serialization.ml","/workspace_root/src/mina/src/lib/timeout_lib/timeout_lib.ml","/home/trivo/.opam/default/lib/core_kernel/time_intf.ml","/home/trivo/.opam/default/lib/core_kernel/time.ml","/home/trivo/.opam/default/lib/core_kernel/time_float0.ml","/home/trivo/.opam/default/lib/core_kernel/time_float.ml","/home/trivo/.opam/default/lib/core_kernel/time_ns.ml","/home/trivo/.opam/default/lib/core_kernel/time_ns_alternate_sexp.ml","/home/trivo/.opam/default/lib/core_kernel/set_once.ml","/home/trivo/.opam/default/lib/core_kernel/heap_block.ml","/home/trivo/.opam/default/lib/core_kernel/queue.ml","/home/trivo/.opam/default/lib/core_kernel/option_array.ml","/home/trivo/.opam/default/lib/core_kernel/memo.ml","/home/trivo/.opam/default/lib/core_kernel/deque.ml","/home/trivo/.opam/default/lib/core_kernel/debug.ml","/home/trivo/.opam/default/lib/core_kernel/bag_intf.ml","/home/trivo/.opam/default/.opam-switch/build/integers.0.4.0/_build/default/src/unsigned.ml","/home/trivo/.opam/default/.opam-switch/build/biniou.1.2.1/_build/default/src/bi_util.ml","/home/trivo/.opam/default/.opam-switch/build/biniou.1.2.1/_build/default/src/bi_outbuf.ml","/home/trivo/.opam/default/.opam-switch/build/biniou.1.2.1/_build/default/src/bi_share.ml","/home/trivo/.opam/default/.opam-switch/build/yojson.1.7.0/_build/default/lib/write.ml","/home/trivo/.opam/default/.opam-switch/build/yojson.1.7.0/_build/default/lib/common.ml","/home/trivo/.opam/default/.opam-switch/build/yojson.1.7.0/_build/default/lib/read.mll","/home/trivo/.opam/default/.opam-switch/build/yojson.1.7.0/_build/default/lib/safe.ml","/home/trivo/.opam/default/.opam-switch/build/yojson.1.7.0/_build/default/lib/util.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_deriving_yojson.3.6.1/_build/default/src/ppx_deriving_yojson_runtime.ml","/workspace_root/src/mina/src/lib/ppx_version/runtime/shapes.ml","/home/trivo/.opam/default/.opam-switch/build/angstrom.0.15.0/_build/default/lib/input.ml","/home/trivo/.opam/default/.opam-switch/build/angstrom.0.15.0/_build/default/lib/parser.ml","/home/trivo/.opam/default/.opam-switch/build/angstrom.0.15.0/_build/default/lib/angstrom.ml","/workspace_root/src/mina/src/lib/logproc_lib/interpolator.ml","/workspace_root/src/mina/src/lib/structured_log_events/structured_log_events.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/stubs/pasta_bindings.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/stubs/kimchi_bindings.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src/digestif_bi.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src/digestif_by.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/xor.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src/digestif_conv.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_md5.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_rmd160.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_sha1.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_sha256.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_sha224.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_sha3.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_sha3_512.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_sha512.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_sha384.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_sha3_224.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_sha3_256.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_sha3_384.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src-ocaml/baijiu_whirlpool.ml","/home/trivo/.opam/default/.opam-switch/build/digestif.0.9.0/_build/default/src/digestif_eq.ml","/home/trivo/.opam/default/.opam-switch/build/eqaf.0.9/_build/default/lib/eqaf.ml","/workspace_root/src/mina/src/lib/mina_wire_types/block_time.ml","/workspace_root/src/mina/src/lib/mina_wire_types/currency.ml","/workspace_root/src/mina/src/lib/mina_wire_types/pickles/pickles_composition_types.ml","/workspace_root/src/mina/src/lib/mina_wire_types/pickles/pickles.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_account_id.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_numbers.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_call_stack_digest.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_coinbase_fee_transfer.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_coinbase.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_fee_transfer.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_pending_coinbase.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_signed_command_memo.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_signed_command.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_sok_message.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_stack_frame.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_staged_ledger_hash.ml","/workspace_root/src/mina/src/lib/mina_wire_types/mina_base/mina_base_zkapp_command.ml","/workspace_root/src/mina/src/lib/mina_wire_types/protocol_version.ml","/home/trivo/.opam/default/lib/core_kernel/tuple_pool/tuple_type_intf.ml","/home/trivo/.opam/default/lib/core_kernel/tuple_pool/tuple_type.ml","/home/trivo/.opam/default/lib/core_kernel/pairing_heap/pairing_heap.ml","/home/trivo/.opam/default/lib/core_kernel/sexp_hidden_in_test/sexp_hidden_in_test.ml","/home/trivo/.opam/default/lib/core_kernel/thread_safe_queue/thread_safe_queue.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/time_ns.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/monitor0.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/debug.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/import.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/priority.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/types.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/execution_context.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/job_queue.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/tracing.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/external_job.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/job_pool.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/job_or_event.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/scheduler0.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/synchronous_time_source0.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/scheduler1.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/scheduler.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/ivar0.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred0.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/ivar.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/monad_sequence.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred1.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_std.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/ivar_filler.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/tail.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_stream.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/synchronous_time_source.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/bvar.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/time_source.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/stack_or_counter.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/throttle.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_kernel_scheduler.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/clock_ns.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_list.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_result.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_or_error.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred_queue.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/deferred.ml","/home/trivo/.opam/default/.opam-switch/build/async_kernel.v0.14.0/_build/default/src/async_gc.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/build_path_prefix_map.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/identifiable.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/numbers.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/arg_helper.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/clflags.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/includemod_errorprinter.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/local_store.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/load_path.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/driver/main_args.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/consistbl.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/lazy_backtrack.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/utils/diffing_with_keys.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/ast/ast_helper_lite.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typedtree.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/longident.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/ast_helper.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/oprint.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/pprintast.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/camlinternalMenhirLib.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/parser.mly","/home/trivo/.opam/default/lib/ocaml/uchar.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/parse.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/ast_iterator.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/parsing/builtin_attributes.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/printtyped.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/path.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/type_immediacy.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/includemod.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/types.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typedecl_separability.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/predef.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/datarepr.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/file_formats/cmi_format.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/persistent_env.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/errortrace.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/signature_group.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/includeclass.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/mtype.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/envaux.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/tast_iterator.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/file_formats/cmt_format.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typetexp.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/printpat.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/patterns.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/untypeast.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typedecl_properties.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typedecl_variance.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typedecl_unboxed.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typedecl_immediacy.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/typedecl.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/typing/rec_check.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/debuginfo.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/simplif.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/printlambda.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/translobj.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/translprim.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/lambda/tmc.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/bytecomp/symtable.ml","/home/trivo/.opam/default/.opam-switch/build/ocaml-base-compiler.4.14.0/driver/pparse.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/stdlib0.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/location.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/code_matcher.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_414_413.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_413_414.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_413_412.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_412_413.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_412_411.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_411_412.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_411_410.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_410_411.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_410_409.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_409_410.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_409_408.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_408_409.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_408_407.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_407_408.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_407_406.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_406_407.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_406_405.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_405_406.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_405_404.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_404_405.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_404_403.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_403_404.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/astlib/migrate_402_403.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/ast/import.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/ast/ast.ml","/home/trivo/.opam/default/.opam-switch/build/ppx_derivers.1.2.1/_build/default/src/ppx_derivers.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/traverse_builtins/ppxlib_traverse_builtins.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/longident.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/code_path.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/location.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/ast/location_error.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/expansion_context.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/ast_traverse.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/spellcheck.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/ast_pattern0.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/ast_builder_generated.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/caller_id.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/common.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/ast_pattern_generated.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/ast_pattern.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/extension.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/context_free.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/driver.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/merlin_helpers.ml","/home/trivo/.opam/default/.opam-switch/build/ppxlib.0.25.0/_build/default/src/ignore_unused_warning.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/ppx_quickcheck/expander/clause_syntax.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/ppx_quickcheck/expander/field_syntax.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/ppx_quickcheck/expander/ppx_shrinker_expander.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/ppx_quickcheck/expander/ppx_generator_expander.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/ppx_quickcheck/expander/ppx_observer_expander.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/ppx_quickcheck/expander/ppx_quickcheck_expander.ml","/home/trivo/.opam/default/.opam-switch/build/base_quickcheck.v0.14.1/_build/default/ppx_quickcheck/src/ppx_quickcheck.ml","/home/trivo/.opam/default/.opam-switch/build/num.1.1/src/nat.ml","/home/trivo/.opam/default/.opam-switch/build/num.1.1/src/int_misc.ml","/home/trivo/.opam/default/.opam-switch/build/num.1.1/src/big_int.ml","/workspace_root/src/mina/src/lib/snarky/snarkette/nat.ml","/home/trivo/.opam/default/.opam-switch/build/num.1.1/src/num.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/double.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/intf.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/four.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/quadruple.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/triple.ml","/workspace_root/src/mina/src/lib/snarky/tuple_lib/tuple_lib.ml","/workspace_root/src/mina/src/lib/key_cache/key_cache.ml","/workspace_root/src/mina/src/lib/snarky/bitstring_lib/bitstring.ml","/workspace_root/src/mina/src/lib/snark_bits/bits.ml","/workspace_root/src/mina/src/lib/snarky/interval_union/interval_union.ml","/workspace_root/src/mina/src/lib/snarky/src/base/handle.ml","/workspace_root/src/mina/src/lib/snarky/src/base/monad_let.ml","/workspace_root/src/mina/src/lib/snarky/src/base/request.ml","/workspace_root/src/mina/src/lib/snarky/src/base/checked.ml","/workspace_root/src/mina/src/lib/snarky/src/base/types.ml","/workspace_root/src/mina/src/lib/snarky/src/base/as_prover0.ml","/workspace_root/src/mina/src/lib/snarky/src/base/run_state.ml","/workspace_root/src/mina/src/lib/snarky/src/base/checked_intf.ml","/workspace_root/src/mina/src/lib/snarky/src/base/as_prover_ref.ml","/workspace_root/src/mina/src/lib/snarky/src/base/boolean.ml","/workspace_root/src/mina/src/lib/snarky/src/base/runners.ml","/workspace_root/src/mina/src/lib/snarky/src/base/typ.ml","/workspace_root/src/mina/src/lib/snarky/src/base/monad_sequence.ml","/workspace_root/src/mina/src/lib/snarky/src/base/enumerable.ml","/workspace_root/src/mina/src/lib/snarky/src/base/number.ml","/workspace_root/src/mina/src/lib/snarky/src/base/snark.ml","/workspace_root/src/mina/src/lib/pickles_types/nat.ml","/workspace_root/src/mina/src/lib/pickles_types/hlist0.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_state.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/basic/kimchi_pasta_basic.ml","/workspace_root/src/mina/src/lib/pickles_types/hlist.ml","/workspace_root/src/mina/src/lib/pickles_types/or_infinity.ml","/workspace_root/src/mina/src/lib/pickles/plonk_checks/plonk_checks.ml","/workspace_root/src/mina/src/lib/pickles_types/pcs_batch.ml","/workspace_root/src/mina/src/lib/pickles_types/at_most.ml","/workspace_root/src/mina/src/lib/snarky/sponge/params.ml","/workspace_root/src/mina/src/lib/snarky/sponge/constants.ml","/workspace_root/src/mina/src/lib/logger/fake/logger.ml","/workspace_root/src/mina/src/lib/allocation_functor/make.ml","/workspace_root/src/mina/src/lib/promise/js/promise.ml","/workspace_root/src/mina/src/lib/logger/context_logger/context_logger.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/poly_comm.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/plonk_dlog_oracles.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/constants.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/dlog_plonk_based_keypair.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/common/kimchi_backend_common.ml","/workspace_root/src/bindings/ocaml/lib/snarky_bindings.ml","/workspace_root/src/mina/src/lib/pickles/make_sponge.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/constraint_system/caml/vesta_constraint_system.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/constraint_system/caml/pallas_constraint_system.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/pasta/kimchi_pasta.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_backend/kimchi_backend.ml","/workspace_root/src/mina/src/lib/pickles/backend/backend.ml","/workspace_root/src/mina/src/lib/snarky/group_map/bw19.ml","/workspace_root/src/mina/src/lib/cache_dir/fake/cache_dir.ml","/workspace_root/src/mina/src/lib/snarky/group_map/group_map.ml","/home/trivo/.opam/default/.opam-switch/build/base64.3.4.0/_build/default/src/base64.ml","/workspace_root/src/mina/src/lib/snarky_group_map/checked_map.ml","/workspace_root/src/mina/src/lib/snarky_group_map/snarky_group_map.ml","/workspace_root/src/mina/src/lib/pickles_base/one_hot_vector/one_hot_vector.ml","/workspace_root/src/mina/src/lib/pickles_base/domains.ml","/workspace_root/src/mina/src/lib/pickles/limb_vector/make.ml","/workspace_root/src/mina/src/lib/pickles/limb_vector/challenge.ml","/workspace_root/src/mina/src/lib/pickles/composition_types/digest.ml","/workspace_root/src/mina/src/lib/pickles/composition_types/spec.ml","/workspace_root/src/mina/src/lib/pickles/pseudo/pseudo.ml","/workspace_root/src/mina/src/lib/base58_check/version_bytes.ml","/workspace_root/src/mina/src/lib/base58_check/base58_check.ml","/workspace_root/src/mina/src/lib/codable/codable.ml","/workspace_root/src/mina/src/lib/pickles/import.ml","/workspace_root/src/mina/src/lib/pickles/util.ml","/workspace_root/src/mina/src/lib/pickles/endo.ml","/workspace_root/src/mina/src/lib/pickles/common.ml","/workspace_root/src/mina/src/lib/pickles/impls.ml","/workspace_root/src/mina/src/lib/pickles/tick_field_sponge.ml","/workspace_root/src/mina/src/lib/pickles/dummy.ml","/workspace_root/src/mina/src/lib/pickles/wrap_main.ml","/workspace_root/src/mina/src/lib/pickles/opt_sponge.ml","/workspace_root/src/mina/src/lib/pickles/commitment_lengths.ml","/workspace_root/src/mina/src/lib/pickles/evaluation_lengths.ml","/workspace_root/src/mina/src/lib/pickles/ro.ml","/workspace_root/src/mina/src/lib/pickles/compile.ml","/workspace_root/src/mina/src/lib/pickles/sponge_inputs.ml","/workspace_root/src/mina/src/lib/pickles/tock_field_sponge.ml","/workspace_root/src/mina/src/lib/pickles/wrap_hack.ml","/workspace_root/src/mina/src/lib/pickles/wrap_proof.ml","/workspace_root/src/mina/src/lib/pickles/tag.ml","/workspace_root/src/mina/src/lib/pickles/inductive_rule.ml","/workspace_root/src/mina/src/lib/pickles/types_map.ml","/workspace_root/src/mina/src/lib/pickles/per_proof_witness.ml","/workspace_root/src/mina/src/lib/pickles/unfinalized.ml","/workspace_root/src/mina/src/lib/pickles/requests.ml","/workspace_root/src/mina/src/lib/pickles/timer.ml","/workspace_root/src/mina/src/lib/pickles/fix_domains.ml","/workspace_root/src/mina/src/lib/pickles/wrap_domains.ml","/workspace_root/src/mina/src/lib/pickles/wrap.ml","/workspace_root/src/mina/src/lib/pickles/wrap_deferred_values.ml","/workspace_root/src/mina/src/lib/pickles/verify.ml","/workspace_root/src/mina/src/lib/pickles/step_main.ml","/workspace_root/src/mina/src/lib/pickles/step_branch_data.ml","/workspace_root/src/mina/src/lib/pickles/step.ml","/workspace_root/src/mina/src/lib/pickles/dirty.ml","/workspace_root/src/mina/src/lib/pickles/cache_handle.ml","/workspace_root/src/mina/src/lib/crypto_params/group_map_params.ml","/workspace_root/src/mina/src/lib/crypto_params/crypto_params.ml","/workspace_root/src/mina/src/lib/bignum_bigint/bignum_bigint.ml","/workspace_root/src/mina/src/lib/snarky_field_extensions/field_extensions.ml","/workspace_root/src/mina/src/lib/snarky_curves/snarky_curves.ml","/workspace_root/src/mina/src/lib/mina_stdlib/list.ml","/workspace_root/src/mina/src/lib/mina_stdlib/result.ml","/workspace_root/src/mina/src/lib/mina_stdlib/nonempty_list.ml","/workspace_root/src/mina/src/lib/snark_bits/bits_intf.ml","/workspace_root/src/mina/src/lib/snark_params/snark_util.ml","/workspace_root/src/mina/src/lib/snark_params/snark_intf.ml","/workspace_root/src/mina/src/lib/data_hash_lib/data_hash.ml","/workspace_root/src/mina/src/lib/crypto/kimchi_bindings/pasta_fp_poseidon/kimchi_pasta_fp_poseidon.ml","/workspace_root/src/mina/src/lib/signature_kind/compile_config/mina_signature_kind.ml","/workspace_root/src/mina/src/lib/hash_prefixes/hash_prefixes.ml","/home/trivo/.opam/default/.opam-switch/build/js_of_ocaml-compiler.4.0.0/_build/default/lib/runtime/jsoo_runtime.ml","/home/trivo/.opam/default/.opam-switch/build/js_of_ocaml.4.0.0/_build/default/lib/js_of_ocaml/js.ml","/workspace_root/src/mina/src/lib/hash_prefix_states/hash_prefix_create/js/hash_prefix_create.ml","/workspace_root/src/mina/src/lib/hash_prefix_states/hash_prefix_states.ml","/workspace_root/src/mina/src/lib/test_util/test_util.ml","/workspace_root/src/mina/src/lib/non_zero_curve_point/compressed_poly.ml","/workspace_root/src/bindings/ocaml/lib/local_ledger.ml","/workspace_root/src/mina/src/lib/signature_lib/public_key.ml","/workspace_root/src/mina/src/lib/sparse_ledger_lib/inputs.ml","/workspace_root/src/mina/src/lib/dummy_values/dummy_values.ml","/workspace_root/src/mina/src/lib/unsigned_extended/intf.ml","/workspace_root/src/mina/src/lib/mina_numbers/nat.ml","/workspace_root/src/mina/src/lib/mina_numbers/intf.ml","/workspace_root/src/mina/src/lib/mina_numbers/zkapp_version.ml","/workspace_root/src/mina/src/lib/mina_numbers/txn_version.ml","/workspace_root/src/mina/src/lib/mina_numbers/account_nonce.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot_intf.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot_legacy.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot_span.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot_since_genesis.ml","/workspace_root/src/mina/src/lib/mina_numbers/global_slot_since_hard_fork.ml","/workspace_root/src/mina/src/lib/mina_numbers/hd_index.ml","/workspace_root/src/mina/src/lib/mina_numbers/index.ml","/workspace_root/src/mina/src/lib/mina_numbers/length.ml","/workspace_root/src/mina/src/lib/mina_numbers/mina_numbers.ml","/workspace_root/src/mina/src/lib/currency/intf.ml","/home/trivo/.opam/default/.opam-switch/build/re.1.9.0/_build/default/lib/core.ml","/home/trivo/.opam/default/.opam-switch/build/graphql_parser.0.12.2/_build/default/graphql_parser/src/parser.mly","/home/trivo/.opam/default/.opam-switch/build/graphql_parser.0.12.2/_build/default/graphql_parser/src/lexer.mll","/home/trivo/.opam/default/.opam-switch/build/graphql_parser.0.12.2/_build/default/graphql_parser/src/graphql_parser.ml","/home/trivo/.opam/default/.opam-switch/build/rresult.0.6.0/_build/src/rresult.ml","/workspace_root/src/mina/src/lib/fields_derivers_zkapps/fields_derivers_js.ml","/workspace_root/src/mina/src/lib/data_hash_lib/data_hash_intf.ml","/workspace_root/src/mina/src/lib/block_time/intf.ml","/workspace_root/src/mina/src/lib/quickcheck_lib/quickcheck_lib.ml","/workspace_root/src/mina/src/lib/mina_base/util/mina_base_util.ml","/workspace_root/src/mina/src/lib/mina_base/account_id_intf.ml","/workspace_root/src/mina/src/lib/mina_base/hash_prefix.ml","/workspace_root/src/mina/src/lib/mina_base/data_hash.ml","/workspace_root/src/mina/src/lib/mina_base/token_id.ml","/workspace_root/src/mina/src/lib/mina_base/fee_excess.ml","/workspace_root/src/mina/src/lib/mina_base/ledger_hash_intf0.ml","/workspace_root/src/mina/src/lib/mina_base/frozen_ledger_hash0.ml","/workspace_root/src/mina/src/lib/mina_base/signed_command_memo_intf.ml","/workspace_root/src/mina/src/lib/mina_base/transaction_union_payload.ml","/workspace_root/src/mina/src/lib/mina_base/signed_command_intf.ml","/workspace_root/src/mina/src/lib/mina_base/side_loaded_verification_key.ml","/workspace_root/src/mina/src/lib/mina_base/state_hash.ml","/workspace_root/src/mina/src/lib/mina_base/verification_key_wire.ml","/workspace_root/src/mina/src/lib/mina_base/ledger_hash.ml","/workspace_root/src/mina/src/lib/mina_base/ledger_hash_intf.ml","/workspace_root/src/mina/src/lib/mina_base/frozen_ledger_hash.ml","/workspace_root/src/mina/src/lib/mina_base/digest_intf.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_statement.ml","/workspace_root/src/mina/src/lib/mina_base/prover_value.ml","/workspace_root/src/mina/src/lib/mina_base/zkapp_call_forest.ml","/workspace_root/src/mina/src/lib/mina_base/fee_transfer_intf.ml","/workspace_root/src/mina/src/lib/mina_base/coinbase_fee_transfer_intf.ml","/workspace_root/src/mina/src/lib/mina_base/coinbase_intf.ml","/workspace_root/src/mina/src/lib/mina_base/pending_coinbase_intf.ml","/workspace_root/src/mina/src/lib/run_in_thread/fake/run_in_thread.ml","/workspace_root/src/mina/src/lib/mina_base/staged_ledger_hash_intf.ml","/workspace_root/src/mina/src/lib/mina_base/stack_frame.ml","/workspace_root/src/mina/src/lib/mina_base/sparse_ledger_base.ml","/workspace_root/src/mina/src/lib/mina_base/sok_message_intf.ml","/workspace_root/src/mina/src/lib/mina_base/proof.ml","/workspace_root/src/mina/src/lib/mina_base/pending_coinbase_witness.ml","/workspace_root/src/mina/src/lib/mina_base/call_stack_digest_intf.ml","/workspace_root/src/mina/src/lib/mina_base/call_stack_digest.ml","/workspace_root/src/mina/src/lib/mina_base/ledger_intf.ml","/workspace_root/src/mina/src/lib/mina_base/mina_base.ml","/workspace_root/src/bindings/ocaml/lib/util.ml","/workspace_root/src/bindings/ocaml/lib/o1js_bindings_lib.ml","/workspace_root/src/bindings/ocaml/jsoo_exports/o1js_node.ml","/home/trivo/.opam/default/lib/ocaml/std_exit.ml"],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KC/NEC;KAhJAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCzHYzmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KDgSD0mD;KE1KXC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KC2I8BC;KAANlpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KC6c1BmpC;KAnKAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KC9hBWC;KCRXC;;;;;;;;;;;;;;;;;;;;;KCZNG;KAEIC;KA8cFC;KCjdFC;;KC2FIC;;;KAsEJC;;;;;;;KCkBqBC;;;KC3BHC;KCmJGC;;;KCtSnBC;;;KAsCFC;;;KAIAC;;;KC8kBiBC;;;KC9hBXC;;;;;;KA2DAE;;;;;;KC+3CJE;;;;KATIC;;;;KAnDJC;;;;;;KAVIC;;;;;;KA/CFC;;;;;;;;KAVIC;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBZiBJ7H;uBmX+LIswB;mBAlE0B;;;;uBvYvSbl3B;;;uB0OiDjBxN;uBAaAM;uB1OrCE9O;uBAzBe+b;uBqOyafhkB;uBEjYIgnB;uBvOxCW9C;uB0OHjB5wD;uB1OGiBqwC;;;;;;uBqO6ZfI;uBADAD;uBrO5ZeG;;;;;;;;uBuOwCXihB;;;;uBACAG;;;;;;;;;uBvOzCWS;;uBuO8CnBiB;uBvO9CmBl9F;uBCoDHC;uBDpDGC;;;;;;;uBuOqFnBo9F;uBACAD;uBvOtFmBhB;;uBuO2FnBkB;uBvO3FmB5C;;;;;;uBuOiHX6C;;;;;uBvOjHWj0D;;;;;;;;uBUtBjBqnD;uBVsBiB4J;;;;uB0OkGjBjN;uBAaAI;uB1O/GiBgP;;uB0OyJjB7O;uB1OzJiBG;;;uBE6LJ74H;uBAAHF;uBF7LOolI;;;;;;;;;;uBoB0HjBk2B;uBmX6PIe;mBAhF0B;;;;qBhKrQhCt7B;qBAIQ0B;;qBGkCNxK;qBAgBAG;;qBlNeF0I;qB6M0ZI5f;;qBEzdI8f;qBG1CNrsD;qBH0CM6wC;;;;;;qBF6cJI;qBADAD;qBE5cIG;;;;;;;;qB0F+KEmb;;;;qBACAG;;;;;;;;;qB1F9KFS;;;;qBwBAQrtD;;qBxBWhB6uD;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;qB1O9IiBI;qB0OyJjBH;;;qBHkBF4J;qBAmDAV;qBGpOEptD;qBADAD;qBHkPFstD;;qBAIAW;qBAIAC;qBAGAG;qBAGAD;qBAGAD;qBAMAuB;qBAMAD;;qBnNpGE03B;qBmXiOIU;kBVjaK;mBU0aa;mBACA;mBAGxB;;mBAG6B;;mBACI;;mBACA;kCAN/B0C;mBAQ4B;;mBACA,wC/Jza5Bh1F;mB+J0a4B,qC/J1a5BA;mB+J2aqB;mBACA;mBACA,iC/JhbrBD;mB+JibyB,8BAFzBy1F;mBAEyB;;6BAOlBp1C;qCACDznF;wBAGc,oBAHdA,UADCynF,aAIyD;sBAFjC;oCAAY,mBAFpCA;uBAEP;;mBAFkB,+BALlBu1C;mBAIAC;;mBAQAC;6BAA4BhyC,YAAYC;qCAClC1tH,QACR,OAF8BytH,cACtBztH,UACoB;sBADX;;kDADyB0tH,cAAZD;sBACb;mBAIfiyC;6BAA6BjyC,YAAYC;qCACnC1tH,QACR,OAF2C0tH,cACnC1tH,UACoB;sBADX;;kDAD0B0tH,cAAZD;sBACd;mBAMF;mBAGX;;;uBAHAkyC,SA/BFV;;mBAgCF;;;uBACI;yBAlCFD,0BAgCEW;;mBACJ;6BAOQpmI;sBACR;+BADQA,SAnDNmlI,oBACAC,oBAsD6B;mBAL7BkB;mDvL4nCIxC;mBuLlnCS;gDArDbwB;mBAuDA;;;sBAtDAC;sBACAC;mBAqDA;;;;uBADE3qJ;uBADA1L;uBADI6wB;sDACJ7wB,SACA0L;;;0CADA0rJ,eACAC;uDvLinCE1C;mBuLpnCJ2C;;;;;uBAYE5rJ;uBADA1L;uBADI6wB;sDACJ7wB,SACA0L;;;0CA5BFwrJ,eAnBAJ;uDvLupCInC;mBuL3mCJ4C;;6BAQM1mI;sBACR;+BADQA,SA7DN4lI,mBACAC,mBAgE4B;mBAL5Bc;mDvLomCI7C;mBuL1lCS;gDApEbgC;mBAqEa;;;sBApEbC;sBACAJ;mBAmEa;;;;uBAAX9qJ;uBADA1L;uBADI6wB;sDACJ7wB,SACA0L;;;0CADA+rJ,eACAC;uDvLylCE/C;mBuL5lCJgD;mBAyBAC;6BAAuBvnF;sBACzB;;;0CAnBiB92E;mCAoBZ,cAFoB82E,OAlBR92E;qCACjB,OADiBA;wDAffi+J;wDAQAG;wDAfAJ;wDATAD;yDARAH;qCAiDF,OAViB59J;;;;;;;mCAoBwD,QAAI,GAC5D;mBAIjB;;sCAAuB,qBAEK;kBAI5B;oCAAuB,sBAEN;kBVpiBN;mBUuiBD;2DAAiC,QAAI;mBAG/C;;sCAAuB,8BAEY;mBAFnC,cAMQD,GACR,gBADQA,EACG;iDARTw+J;kBVziBS,kBUqjBHx+J,GACL,kBADKA,EACQ;iDAbdw+J;kBVziBS,kBU0jBHx+J,GACR,gBADQA,EACG;iDzWxjBJu+J;kB+VHI,kBU+jBHv+J,GACL,kBADKA,EACQ;iDzW7jBTu+J;kB+VHI;;6BUmkBe9yC,YAAYC;sBAE9B;2CAFkBD;uBAElB,mBAAsC,UAFRC;sBAIpC;;;2ClKxPE0qB,ckKoPkC1qB;wBAIpC;;;;6ClKxPE0qB,ckKoPsB3qB;sBAElB;uBAOc,8BATIA;uBAUJ,kCAVgBC;sBAWnC,GADCgzC,kBADAD;;;2ClK7PAroB,ckKoPkC1qB;wBAapC;;;;6ClKjQE0qB,ckKoPsB3qB;sBAiBI,sBACT5pB;wBACnB,eADmBA,OATjB48D,gBACAC,gBASoE,CAAC;;6BAWjDC,SAAUrkK;sB;+BAClC,iBADwBqkK,SAAUrkK,qBAC6B;;6BAGnDqkK;sBACZ;+BhXpdI3C;wCgXodoC1hK;iCACtC,6BAFUqkK,SAC4BrkK,OACA,EAAC;;6BAGnBqkK;sBACtB;+BhXxdI1C;wCgXwdqC3hK;iCACvC,6BAFoBqkK,SACmBrkK,OACD,EAAC;mBAG9B;kBACU;kBVhnBV;;6BUmnBD22C;sBACV;wCAAiB35C;gDACNmK;;qC;0DAMCwvC,MACR,UADQA,KACM;6EATRA;oDAYEu0E,MACR,UADQA,KACM;qCADC,+BAXFluH;qCAWE;mCAP0B;gEAHlCmK;oCAGE;;sFAQM;kBAGV,QlM7bDm9J;kBwLtMG;mBUmoBF;6BAEoBlvC,WAAWmvC,QAAQC;qCACvCC;wBACE,IAAPC,OAAO,eAFkBtvC,cACpBqvC;wBACE,eACFn9J;0BACF,yBAJsB8tH,WAI8B,QAFvDsvC,OACKp9J;0BACF,yCAA6E;wBADpE,2BAHgCk9J,SAGE,OAD9CE;wBACY,kDACoE;sBAHpE,+BADwBH;sBACxB;mBAHP;6BASoBnvC,WAAW8rC;sBAClB,sB,O5C41BhBh9B,U4C71BuB9O;sBACzB,mCADoC8rC,eAC6B;mBAV5D;6BAgCGx7J,EAAEuB,KAAKkB;qCACXy8J;wBACG;wCADHA;yBAEE,IADNC;yBAES,gBAJM18J;yBC/oBT,WD+oBIlB,KAAKkB,OChpBwCm6G;yBAN5C,gBAAc,eADnB58G;yBAEK,iBjKyRJi3I,WiKzRI,cAFLj3I;yBACK;wBACA;8BAAbxF;0BACE;4BAAe,cAHTwF,EAGY,sBADpBxF,EADI6kK;4BAEA;uDADJ7kK,EADI6kK;6BD2pB0D,iBhKjYrDpoB,WgKiY0C7uE,IADjDg3F;4BClpB6B;8BATvBp/J,ED4pB2CooE,IAAK,iBAHtD+2F;4BCtpBE,UADJ3kK;;;+BAFQwF,CD4pBkE;sBAJ7D,+BADHA;sBACG;kBAOD;kBACE;kBACA;kBV7qBL;mBU6qBK;6BAKds/J;sB,SAAAA;uBADK;qCAEI3iK;uCAKAC;gD,gBALAD,EAKAC,QALAD;gEvLq6BL0+J;wBuL75BU,IAARkE,MAAQ,WhKpZLpoB,WgK2YTmoB,eACS3iK;wBAQK,eACJ6iK;0BACR,kBhKtZOvoB,WgKoZHsoB,MACIC,eACc;wBADG;sEADrBD;;;sBALJ;;+DAJFD;sBAIE;mBAPFG;mBAoBAC;6BAAU1/J,EAAEuB,KAAKkB;;4BACJs6G,cAAND;uCACDoiD;0BACG;8CADHA;2BAEK,gBAJMz8J;2BCxoBT,WDwoBIlB,KAAKkB,OACVq6G,KAAMC;2BClpBA,gBAAc,eADnB/8G;2BAEK,iBjKoPJi3I,WiKpPI,cAFLj3I;2BACK;0BACA;gCAAbxF;4BACE;8BAAa;gDjKmPNy8I,WiKnPM,cAHPj3I;+BAGN;8BAAa;oCAAbI;gCACE;kCAA2C,gCAD7CA,EAFEi/J;kCAG4B,cAJxBr/J,EAI2B,sBAFnCxF,EADI6kK;kCAG2C;mCAA5B,0BADjBj/J,EAFEi/J;mCAGE,0BAFN7kK,EADI6kK;mCDupBe,iBhKlaVpoB,WgKiakD7mD,IADzDgvE;mCAEI,iBhKlaGnoB,WgKiagD7uE,IADvDg3F;kCC3oB+B;oCAXzBp/J;oCDupBiDooE;oCAAEgoB;oCAC1C;uCAAjB,iBAHE+uE;;kCCjpB6C,UAD7C/+J;;;8BAAa,UADf5F;;;iCAFQwF,CDwpBuB;wBAJlB,2BAA8B,iBAFjCA,EACG+8G,MAAND;wBACM;4DAtBb2iD;kBA6Bc;kBACA;kBV7sBL;mBU6sBK;;mBvWjsBXE,oC0WHU,cAAc;;6BAOvB3/J,EAAGP,EAAGmgK;sBAAY,gBAAYnjK;wB;iCrF8UV62H,kBqF9UpBtzH,EAA6D,WAAvD4/J,UAAwBnjK,IAA3BgD,EAAwE,CAAC;;6BAOxEq7J;sBAAS,gBAAYr+J;wBAAK;;;;;iDAA1Bq+J;;;;+CxJCRtvF,iBwJDQsvF;qDAAqBr+J;wB/D6I/B;;;kCACE;;;;;oDzF7IA+uE;mCyF6I2B;;mCACrB;;mCACI;;oCADJ;sCAGJ;;qDAOY,E+DzJqE,CAAC;;6BAExEq0F;sBACd,IAAQ/E;sBACR;wBADQA;;;2BAA2B,kBADrB+E,YACqB,UAA3B/E,QAA2C;sBACnD,iBADQA,OACM;mBAuEE;6BAWTgF;sBACP;wCAAiBC;iCACf;mCAAO;qCAMC;sCAJI/vF;sCAAR02B;;qDAI8C12B,MAAQ,UAJtD02B,KAI8C12B,KAAoB;sCAA9D;qDrFyOgBsjD,kBqFhPTysC,OAGH/vF;sCAIJ,eADyC02B,MAAQ,UAARA,KAHrC12B,KAGyD;sCAA7D;qDrF0OgBsjD,kBqFjPnBwsC,MAIDp5D;qCAEI,gCAFI12B;mCADF,cAMF,GAAC;kBAGI,sB1W7GV2vF;kB0WgHL;6BAAiBK;sBACf;wBAAO,kBACY;wBAEf;;0CACS,sBALEA,UAGDzgK;yBACN0gK;qCrF8NgB3sC,sBqF7N+B/zH,GAAK,UAALA,EAAgB;yBAEjD,sBAJRA;wBAIQ,sBAHd0gK,eAGAC,gBAC8C;kBbpI7C;mBa4HX;6BA6B6BxwC,WAAWywC,MAAMC;sBAC9C,gBAAYjuB;wBACE,IAARzkB,MAAQ,aADFykB;wBACE;0BAE+B,IAAMxzI,WAAN,gBAJhB+wH,WACjByiB,KAGuCxzI,EACO;wBADtD;8CrFiMsB20H,OqFjMT,UAFX5F;yBAMF;;4BACE;8BAPAA;;gCAOmB;;;iCACL,gBAVSgC,WACjByiB,KAQmBr5H;gCACX,eACoCynJ;kCAE3C,gBAbgB7wC,WAUhBmjB,OAC2C0tB,YAFpB3+J;kCAIvB,6BAOc;kCAPd,IAMIuwI;kCAAQ,UAARA,KACc;+DApBSguB,MASTrnJ,WAWE;yBAG7B;;4BACE;8BAtBA40G;;gCAsBmB;+CAC0B+yC;kCACxC,aA1BkB/wC,WACjByiB,KAuBmBr5H,IACoB2nJ,aAC8B;kDrF2KvDntC,kBqFrMoB8sC,OAwBVx+J,YAE+C;wBAH/E;oCApBEy+J,aAIAC,eAeAE,iBAMwD,CAAC;mBAzD/D;6BA4D6B9wC,WAAWowC;sBACxC,gBAAY3tB;wBACC,IAAP3sB,KAAO,UADD2sB;wBACC,eAEoCuuB,KAC3C,gBALuBhxC,WACjByiB,KAGqCuuB,IACU;wBADvD;8CrFkKsBptC,OqFlKT,UAFX9N;yBAMF;;4BACE;8BAPAA;uCAOuBk7C;gCACT,IAAP7tB,OAAO,SAVSnjB,WACjByiB,KAQiBuuB;gCACT,eACoCG;kCACvC,gBAZYnxC,WAUhBmjB,OAC2CguB;kCACvC,kBAGC,MAfWnxC,WAUhBmjB,OAC2CguB,aAIsB;+DAftCf,MASXY,WAMkD;wBAP3E,sBALEC,aAIAC,gBAU2C,CAAC;mBCpKxC;uDAAwB;mBAAxB;yC,OzYaN51C;mByYbM;6BAyDKvrH,EAAIupC,UAA0Ci4H;sBAC7D,GADmBj4H;uBAAS,QAATA,cAASypC;;2BAATyuF,OA7DjBJ;sBA8DF;uBADyD,mBAAXK,SAAWrkE;;2BAAXqkE;sBAlDxC,UAkDaD;sBAlDb;uBAGoB;;wBAwCtBr/D,OAxCsB,0BAAVz/E;;uBADd;2CALA2+I;wBAKA;;2BALAA;;6BzJjBAv1F,iByJiBAu1F;;wBA8CEl/D,OAzC6B;sBAKjC;wBAA2C;;;yBACnC,MA0CWq/D,aA3CqCE;wBAChD,SACI;wBAF+B,YAIhC,OAJsC58J;wBAItC;;;2BACQ68J;2BAAN5/J;0BACwB;;mCADxBA;;oCAAM4/J;oCACkB,sBANmBD;wBAAb;;;;;;2CnLsDrC3mC,amLtDkD2mC;;;;;;;6DnLsDlD3mC,amLXaymC;6CA/B0B;sBAZ7C;yCA2CmBA;;;0BtFgQO5tC;;mCsFnQC7xH,MAAQ,gBAG0Bw/J,UAHlCx/J,KAJvBogG,OAIyE;uBAF3E,4BAK4Cs/D;wCAA/B1hK,EACX6hK,SACM;mBA3DA;6BA8EM7hK,EAAG+hK,SAAQC,WAAiBC;+BAhBzBnmE,IAiBb9+F;wBAC8B;;iDAA2C,kBAF/DgD,EACVhD,EAC4E,EAAC;sBAjBnF,GAemB+kK;uBAhBa,QAgBbA,YAhBIN,OAASzuF;;2BAATyuF,OAlErBJ;sBAmEF,GAe2BW;uBAhBkC,UAgBlCA,cAhBuBN,SAAWrkE;;2BAAXqkE;sBAClD;6BAe4CO;uBAf5C,SADkDP;uBAClD,SADuBD;uBACvB;;mCAC6DI;4BhEm4B7D,SgEn4B6DA,YhEm4B7D,IgEn4B6DA;4BhEo4B3D;8BAAM;;2CACI;;gCADJ,mBAEM;gCgEn4BF;;;;iCAEW,iCAAT3kH;+ChEq4BG;gCgEv4BL;kDAIC;8BhE63BL;;+BgE53BUglH;+BAAPC;+BACH5B,SAKoC0B;+BAlCzB,eAkBIR;+BAhCKY,wBA2CpB9B,SADG4B;+BA1CGG,aAcVF;+BAdwBG;+BA4CpBpuI,MAFGguI;+BAEIrnE,MAFGonE;8BAzChB;yCADYI;kCAIS;6DpKgOZ9qB,WoKpOG8qB;mCAKH,eALiBC;kCAKjB;oCAGG;;qCADUE;qCAAXC;qCACC,YADDA;oCACC;0CARAJ,aAINE,eAJoBD,WAOJE;;oCACV;qCAGJ;qCAXkBE,wBA2CpBpC,SApCKmC;qCAPCJ,aAINE;qCAJoBD;qCA4CpBpuI,MArCKuuI;qCAqCE5nE,MAlCC7mD;;6CAkCR9f,MAAO2mE,SACS;;;;wCAQb;sBApBX;;uBAqBgBA;uBAAP3mE;qEAAO2mE;6BnX/Dd4yB;;;;6DmXyD0Cu0C,KAMnC9tI;mBApFC;6BAyFSn0B,EAAGyhK,OAAQC,SAASF;sBACvC,SAAI1lE,IAAE9+F;wBAAI;mDAA6B,kBADpBgD,EACbhD,EAAoC,EAAC;sBAC3C,0BADI8+F,IADkB2lE,OAAQC,SAASF,WAEsB;;6BC/HrDjhK,EAAGP;sBAAI,gBAAYhD,EAAGgF,KAAM+wF;wBAAkB,eAA9CxyF,EAA8C,WAA3CP,EAAgBhD,GAAGgF,KAAM+wF,KAAmC,CAAC;;6BACzD/yF;sBAAI,gBAAYhD,QAAW+1F,MAAQ,kBAAnC/yF,EAA2B+yF,KAAX/1F,EAA2B,CAAC;mBAWnD,iClMCFoqH;mBkMII;mBAOM;6BA4BTi5C;sBACP,gBAAYt6C,KAAM/jH,KAAM+wF;wBACT;yCAA+B,iCADtBA;yBAET,gBAFHgzB;yBAGN+8C;mCACF,SAFEtxC,0BAFYxvH,KACZogG;mCAM2DrP,KAAKkuE,IAAIj/J;0BACxC;mCAT3Bq+J,MAQ+DY,IAAIj/J,KACxC,WlMhD5BolH,ckM+C2Dr0B,QACT;wBADtB,oBlM/C5Bq0B,ckMwCkBr0B;wBrFyJxB,uBqFzJYgzB,KAGN+8C;wB3GtCsB,yB2GmChB/8C,KAGN+8C,QAKmD,CAAC;mBArC1C;6BAqDLC,QAAQC;sBACnB,oB;sBAAM;;gDAtCkBhhK,KAAM+wF;mCAAvB;;;oCACM,eAoCFgwE,QArCEr4C,IAAW1oH,KAAM+wF;oCAEjB,eAmCMiwE,SArCDr4C,IAAM3oH,KAClBkxF;mCACO,OAAP6F,MACC;qCAmCmE;mBAtD1D;6BAyDLkqE;sBAAgB,mCAAhBA,SjDu5CLtkC,UiDv5CwE;kB3XkD5E0uB;kBJ5HExV;kB0PVN;;kBsHEa;mBtHFb;mBAiCmB;;6BAEqB71I;sBAEpC,IADEohK,4BACF;sBAIC,GANmCphK,SAMrB,YAAY,yBANSA;sBAOtC,uBANIohK,4BADkCphK,KAwDV;mBA1DX;;sCAYfkhK,UA8CEC,UAcEG;mBAxEW;;uBAYfJ,UA8CEC;mBA1Da;8C;mBAAA;gCAiEbE;mBAjEa,QAYfH;mBAZe,2B;mBAAA;;uBAYfA,UA8CEC;mBA1Da,QAkHTI;mBAlHS,8B;mBAAA;oC;;mBAAA;;kBAssBhB;;kB1P5tBGzrB;kBI4HFwV;kB4WrIS;mBgB6CT;;;;;;;;;;mBCrBY;;;;;;;mBzXgDb;;;;;;uBAIe,gBAH2BqW;uBAG3B,sBAANzgK;uBAIM,kBAPW0gK;uBAOX,wBAANpxH,WALF0pG;uBASQ,kBAXH2nB;uBAWG,wBAAN3nE,WALFigD;sBAKQ,UADR6G,OAI4B;mBAfnC;;sBAgCA;;;uBAIe,gBAHyByS;uBAGzB,sBAANvyJ;uBAIM,kBAPEwyJ;uBAOF,wBAANljH,WALF0pG;sBAKQ,UADRC,OAK4B;mBA5CnC;6BAoDkB0L,UAAWmc;sB;8BAAXnc;iCAAWmc,qDACqB;mBArDlD;6BAwKYz6H;sBACX,GADWA;uBAAc,QAAdA,mBAAcypC;;2BAAdkxF,YAlJXh3H;sBAmJU;;;;8BADCg3H;;;0CAQV;mBAhLF;6BAmLS3jK,EAAG0X;sBAGA;;;6BAHAA;sBAGA;;6BAHAA;sBAGA,QAMS;mBA5LrB;6BAqMc1X,EAAEV;sBACf,GADaU;wBALb,UAKaA,WAJF;sBAKyC,wBADvCA,UAAEV,EAEuB;mBAvMvC;6BA0MYU,EAAEV,EAAG0oH;sBAChB;+BADWhoH,QAAKgoH,WAAH1oH;uBACb,WADWU,OAAKgoH;sBAChB,OAAI+7C;sBAAJ,SACIrkC;wBAIC,IACCgE,WALFhE;wBAIC,OACCgE;wBAEJ,WATS1jI,EACP+jK,YAMErgC;wBAEJ,OATS1jI;wBAST;sBAJG,OAHD0/H;sBAGC,QAOqB;mBAtN3B;6BAwP2B1/H,EAAGhC,OAAQimK,MAAOC;sBAC5C,IARiC12F,IAOJxvE,SAAHgC;sBAC1B,OAD6BhC;sBAC7B,QARiCwvE;;yBAkD/B;kCA3CwBxtE;yCAPOwtE,gBAOW02F,aAAPD;sCAAOC;;+BAPX12F;yBAa/B,IAAIw6C,UAb2Bx6C,YAOW02F;yBAM1C;kCANwBlkK;0CAAkBkkK,aAAPD,gBAM/Bj8C;;sBA0CJ,GAvD+Bx6C,QAuDjB;sBA/ChB,IAhBIluE,KAQ6BkuE;;+BAR7BluE;0BAEF,SAawBU,QAftBV;0BAEF,OAFEA;;+BA/BFwkK,SA8CwB9jK,EAAWikK,MAAOC,YAiDP;mBAzStC;6BA8SelkK,EAAGhC,QAAS,eAAZgC,EAAGhC,YAAsD;mBA9SxE;;sBA+UC;;uBADgB4U;;;wC6N9XhB44D;uB7N+XA,MADgB54D;sBAChB;4BAEWyxJ,gBAATC;;;gCAASD;gCAHKzxJ;;;;;;;;;sBAER;mBAhVT;2CAkWgB,aAAqB;mBAlWrC;6BAwXyB5S,EAAGgoH;sBAC3B,GADwBhoH,QAAGgoH;wBAT3B,GASwBhoH,YATU;wBAAU,GASpBA;0BAnBxB,UAmBwBA;0BAnBxB,WACQ;0BADR,IAEWqkK,gBAATC;0BAiBsBtkK;;iCAjBtBskK;0BAiBsBtkK,OAjBbqkK;wBAUH;4CAOgBrkK;yBAPhB,WAOgBA;wBALxB,OAKwBA,QANpBykK,aADAzlK,WACAylK;wBACJ,QAKwBzkK,QANpBykK;wBACJ,OAKwBzkK;mCAAGgoH,SAIK;sBAAU;uBACtC1oH;yBALoBU,kBAAGgoH;;;sBAIe,QAJlBhoH,QAAGgoH;sBAIe,OACtC1oH,CAEH;mBA/XF;6BAoYeU,EAAG2kK,KAAMC,aAAcC;;uBAApBC;uBAAMC;uBAAcC;sBACrC;wBAAM,gCADQhlK;wBACR;0BAGJ,IAAIhC,OAJQgC,OAAS+kK;0BAIrB,OAAI/mK;0BAAJ,SAJe8mK,OAOV,UAPO9kK,KAIRhC,SAJQgC,SAIRhC;0BAAJ;2BAIK,OARU8mK;;2BAAMC;2BAAcC;;wBAC/B,YASG,sBAVKhlK;wBAUL;0BAGJ,QAbSA,OAAS+kK;+CAAcC;;wBAC/B,YAeM,sBAhBEhlK;wBAgBF;0BAGI;mDAnBFA;2BAmBE;kCAnBqBglK,0BAAdD;2BAqBf,wBArB6BC;2BAqB7B;4BADIE;;6BADA5lK,KAnByB0lK;;;2BAAdD;2BAAcC;;wBAC/B,YA0BS,sBA3BDhlK;wBA2BC;0BAGJ,QA9BGA,OAAS+kK;0BA8BZ,OA9BG/kK;0BA8BH,OA9BGA;8BAAS+kK,iBAAcC;;wBAC/B,IAmCS3F,SApCDr/J,OAAS+kK;wBAoCZ,OAAI1F;wBAAJ,OApCMyF;0BA2CD;kCA3CCA;;2BAAMC;2BAAcC;;wBAC/B,IAuCWttJ,OAxCH1X,KAoCCq/J,WApCDr/J,SAoCCq/J;wBAGC,SAvCCyF,OAyCa,WADbptJ;wBAEJ,OAFIA,IAGqE;mBA/avF;6BAkbe1X,EAAG2kK;sBACjB,UADc3kK;sBACd;wBAEE,IADK0X;wBACL;qCAHeitJ,KAEVjtJ,IAIA,QANO1X,EAAG2kK;sBAOP,eAPI3kK,EAAG2kK,SAOiD;mBAzbnE;6BA6bM3kK,EAAErD,EAAEC;sBACX,UADSD,UACT,gBADWC,KAAFD;sBACe;sBAAxB,IACImsE,KAAO,UAFJ9oE;sBAEI;wBAEO;+CAFd8oE,KAFKnsE;yBAKQ,qBAHbmsE,MAFOlsE,IAAFD;yBAMP,sBAFI2qJ,UACAmc;;;;6CAGgB;oCAAgC;mBArcrD;6BAwcqBnlD;sBACtB,SADsBA,QAEV;sBACA,MAHUA,QAGV;;wCAAiCj5E,IAAI5oC,GAAW,OAAf4oC,MAAe,eAAX5oC,MAA2B;;+BAArE8C,EAAsE;mBA3c5E;;6BA2dc44E,IAAIjtE,MAAOw6J;sBACY;qD,OAX9BC,OAUOxtF;+BAAIjtE;+BAAOw6J,MACuB;mBA5dhD;6BAidavtF,IAAIjtE,MAAOozG;sBACvB,GADuBA,SAAXnmC,IAEP,eAFWjtE;sBAGX,SAHkBozG,QAKT,OALEpzG;sBAOZ,MAPmBozG,QAOP,kBAPJnmC,IAAIjtE,cAMP3L;sBACO,OAARowJ,eACM;mBAzdf;6BA+dY3vJ,EAAGm4E,IAAIx7E;sBACL,IAATC,GADcD,KACL,eADCw7E;sBAET,iBAFMn4E,EAAOrD,EACdC,GACa;mBAjelB;6BAoesBoD,EAAEs+G,KAAMnmC;sBAC7B;wBAAM,OADuBA,MAANmmC;;;6CAGA,IAALh/G,SAAK,gBAHFU,EAAQm4E,IAGX74E;wBADH;8BACyB;mBAvezC;6BA0e8BU,EAAE0lK,MAAOvtF;sBACtC;wBAAM,UADgCA,MAAPutF;;;6CAGR,IAALpmK,SAAK,gBAHMU,EAASm4E,IAGpB74E;wBADH;8BACyB;mB2XziBtCymK;mBAEAC;6BAMEn1J;;;;wBAJS;;;;4BACQw8D;4BAAHrtE;;;kCAAGqtE;;yBACa,sBAER;;mBAe1B44F;mBAEAC;;sB;;;;;;;;;;;;wBACsB,IAAhB5nD,cAAgB,OAAhBA;sBACD,qBAAqC;mBAG1C6nD;6BAMEt1J;;;;wBAJS;;2CACC;;0BACEw8D;0BAANixC;;;gCAAMjxC;kCAEU;mBCxCzB;kBAkDD;;;;sBAEE;wBAEI;;yBAtDL,WAqDmBjf;yBArDnB,WAqDmBA;yBArDnB,WAqDmBA;yBAjDJ,mB5X2Fdm1G,c4X9F6D6C;yBAG/C,sBAANzjK;yBAIFi5I,wBAPgCyqB,gBAEhC1qB;yBAWQ,kBAbC2qB;yBAaD,wBAANr0H,WANF2pG;yBAMQ,MADR6G;6CAyCErjJ;sBAGC,6BAAa;kBpBjEb;kBqBiCX;;;;sBAA8E;wBAE1E;;yBA5BoBosG,QA2BRp9C;yBA3BFm4G,SA2BEn4G;yBAzBY;;;sDAFdm4G;gDAAU/6D;6CA4BhBpsG;sBAGC,6BAAa;kBrBtCX;mBsB2CP;;;6BAkBY4pC,IAA2C/wB,KAAK1W;sBAC9D,GADcynC;uBAAc,QAAdA,mBAAcypC;;2BAAdkxF,Y9XiCdh3H;sB8XhCA;6BADcg3H;uBACd,MADcA;uBACd,MADcA;uBACd;sBAjBA,OAgB8DpiK;yCAf/C,aAeDoiK;;yCAbW,aAaXA;6CATK,c9X0CnBh3H;sB8X1BgB;8BAVd65H;8BAG4DjlK;;;;;8BAO9C;;8BAPyC0W;;;;oCAcxD;mBAhCC;6BAoCUjY;sBAAI,UAAJA;sB9XoNZ;sB8XpNgB;uB9XoNhB;;;;;;gCAOkB;;2CANd0mK,iCACAC;gCAIS,cALTD,kBAEAE,WACAjD,c8XxNmD;mBApCrD,kBAsCOrkJ,OAAQ,OAARA,SAAoB;mBAtC3B,cAuCKA,OAAQ,OAARA,SAAyB;mBAvC9B,gBAwCOA,OAAQ,OAARA,yBAAuC;mBAxC9C;6BAyCStf;sBAAwD,UAAxDA,MAAsB,aAAtBA;sBAAuC,UAAvCA,kBAAkE;mBAzC3E;6BAoDQgpC,IAAmChpC;sBAC7C,GADUgpC;uBAAM,QAANA,WAAMypC;;2BAAN/6D,I9XDVi1B;sB8XEA;6BAtCE65H;sBAsCF;;;;8BADU9uJ;sBACV,QADUA;sBACV,QADUA;sBAPV,OAO6C1X;+BANO,mBAMPA,GANO,QAMPA;;+BAJiB,mBAIjBA,GAJiB,QAIjBA;gCAHpC,QAGoCA;0CAWnB;mBA/DxB,qBAsEYsf,OACd,OADcA,YAGD;mBAzEX;6BA4EgBA,OAAY,uBAAZA,MAA+B;mBA5E/C;6BA+EgBA,OAAQ,WA/DxBmnJ,YA+DwB,QAAoC;mBA/E5D;6BAyFAnnJ,MAAO0nJ,OAAOC;sBAClB,gBADI3nJ;sBACJ;6BADIA;uBACJ,YADIA;sBDxFJ,OCwFkB2nJ;mCDxFdz7D;;;;;;;;;yBAoBG;0BApBHA;2BAoBG,kBAAa;;mCApBhBA;gCAyBA,IAzBAA,QCwFOw7D;oCDxFPx7D;4CA6B4B;sBC4DhC;+BADkBy7D,UAAPD;;;;wBDrDF,SCqDSC,UDrDT,kBAAa;8BAJlBC;;sBhLkcE,gBgLlcFA;sBAOJ,wBAvC4BX,SACxB/6D,QA+BA07D,gBCkE4B;mBAlG5B;6BA8GYl+H,IAAW1pB;sBAC3B,GADgB0pB,IAAQ,QAARA,aAAQypC,aAAR20F;sBAChB,IAAIppK,OADuBshB,YAAX8nJ;sBAChB,UAD2B9nJ,UACvBthB,SADuBshB,cACvBthB,OACiE;mBAhHjE,6BAmHkBshB,MAAM7iB,GAAI,WAAJA,EAAI,QAA0B;mBAnHtD;6BAoHM6iB,OAAQ,YAARA,kBAAQ,QAAgC;mBApH9C;6BAuHAA;sBACJ,IAAIkoJ,eADAloJ;sBACJ,YAAIkoJ;sBAAJ,YADIloJ;sBACJ,YADIA;sBACJ,UADIA;sBACJ;;gCAKe,mBANXA,SACAkoJ;gCAOF,mBAREloJ,SACAkoJ;;sBAQG,QAAE;mBAhIL;6BAsIAloJ,MAAM6+E,OAAKttF;sBACf,YADIyO;gCAGF,SAHEA,YAAM6+E,QAAKttF;oCAKH;mBA3IR;6BA8IYyO,MAAMrf,EAAE4Q,OACxB,SADgByO,SAAMrf,GACtB,OADwB4Q,KAEnB;mBAhJD;6BAmJmByO,MAAMrf,EAAE4Q;sBAC/B,SADuByO,SAAMrf,GAC7B,sBADuBqf,MAAMrf,EAAE4Q,MAEH;mBArJxB;6BAwJqByO;sBACzB,UADyBA;sBAGX;4BAFVuoJ;sBjLyUE,kBiLzUFA;sBAKJ,GALIA;;kCADqBvoJ;oCAMe,gBANfA;;iCACrBuoJ;sBAKyD,aACxD,QAPoBvoJ,gBAO0B;mBA/J/C;6BAkKMA,MAAO8nJ;sBACjB,I9XsKWppK,O8XvKDshB,YAAO8nJ;sB9XuKG,e8XvKV9nJ,S9XuKCthB,W8XtK0D;mBAnKjE;6BAuKAshB,MAAM6+E,OAAKttF;sBACf,uBADIyO;sBAEJ,SAFIA,SAAM6+E;sBAEV,OAFettF,KAQV;mBA/KD;6BAmLAyO,MAAMzO;sBACV,uBADIyO;sBAEJ,SAFIA;sBAEJ,OAFUzO,KAGL;mBAtLD;6BA0LAyO,MAAM6+E,OAAMttF;sBAChB,uBADIyO;sBACJ,OADIA;;yBAIC,mBAJDA,OAI4B,QAJ5BA,SAIkD,OAJtCzO;+BAaN,OAbMA;;yBAOX,mBAPDyO,OAO4B,QAP5BA,SAOkD,OAPtCzO;;yBAUsB,wBAVlCyO;yBAUkC;yBACpC,SAXEA;yBAWF,OAXczO,MAaD;mBAvMX;6BA0NiByO,MAAMzO,OAC3B,SADqByO,aACrB,OAD2BzO,KAEtB;mBA5ND;6BAiOM5Q;sBACV,SADUA;gDAGM,QAHNA;;kCAEM,OAFNA;sBAIH,QAJGA,oBAI6B;mBArOnC;6BAwOkBqf,MAAMrf,EAAE4Q;sBACsB,YAD9ByO,sBAAMrf;sBACwB,sBAD9Bqf,MAAMrf,EAAE4Q,MAEF;mBA1OxB;6BAyQAyO,MAAM6+E,OAAMttF;sBAChB,uBADIyO;sBACJ,WADIA;sBACJ,OADIA;;yBAKC,mBALDA,OAK4B,QAL5BA,SAKkD,OALtCzO;+BAOH,uBAPTyO,UAAYzO;;yBASX,uBATDyO;mCAWA,QAXAA,YAAYzO;;gCAcD,wBAdXyO,OAAYzO,OAcwB;mBAvRpC;6BA0RiByO;sBACrB;+BADqBA,2DAMlB;mBAhSC;6BAoSAA;sBACJ,OADIA;+BAEW,0BAFXA;+BAIM;+BADe,0BAHrBA;gCAKK,SAAE;mBAzSP;6BA4S6BA,MAAMzO,MAAOu2J;sBAC9C,UADiC9nJ;sBACjC,6BACmB,OAFoBzO;sBACvC,IAKE,wBAN+ByO;sBAM/B,YAN+BA,YAAa8nJ;sBAC9C,IAOMsB,iBAR2BppJ;sBAM/B;wBAGO,IAIJqpJ,QAJI,WANYlpK,EAHY6f,MAAMzO;4BAUxB9B;mDACV,gBAX4BuQ,OAW5B,MADUvQ;;wBAVkBuQ;;yBAM3BmpJ,eANwCrB;;wBAAb9nJ;;wBAQ3BopJ;wBASD,YAXCD;wBAYD,gBAlB4BnpJ;wBAkB5B,OALAqpJ;mDAMM;mBA/TP;6BAkUWrpJ;sBAAQ;6CAARA;uBAAQ,kBAARA;kCAAgD;mBAlU3D;6BAoUyBA,MAAMzO,MAAOu2J;sBACvC,oBAD0B9nJ;+BACF,+BADEA,MAAMzO,MAAOu2J;+BAAPv2J,KACoD;mBArUnF;6BAmVAyO,MAAMzO,MAAOu2J;sBAVjB,UAUI9nJ;sBAVJ;wBACkC,IAAhCypJ;wBAAgC,GAS9BzpJ,WATFypJ;6BAUEC,WATF,QAQE1pJ;;8BAPqBgpD;6BAFvBygG,wBASEzpJ;4BANF,WADuBgpD,OAQrB0gG;;;;;sBjL8IE,gBiL9IFA;sBACD,gBAFC1pJ;wBAGC,OAFD0pJ,WAGqB,YAJrB1pJ;wBAKF,GAJE0pJ;yCADA1pJ,wBAWG,OAXGzO;wBAUH,sCAVHyO,MAAMzO,MAAOu2J;sBAYZ,OAZKv2J,KAYA;mBA/VN;;;;;wBAmWO;;;2BACK,IAATA,iBAAS,oBAATA;;0BACOgkE;0BAANypC;;;kCAAMzpC;;mBArWV;6BAwWuBs0F,QAASt4J;sBAGpC,UAHoCA;uBAKlC,UALkCA,YAATs4J,QAASt4J;sBAM7B,aANoBs4J,SAASt4J,MAMQ;mBA9WxC;6BAiXoBytG,KAOpBztG;sB,UAAAA;wBAH2C;yBAFI83J,QAK/C93J;yBALiCw4J,aAKjCx4J;yBALkBy4J,cAKlBz4J;yBAH2C,WAFzBy4J,cAEyB,IAFVD,cAFb/qD;wBAIuB,gCADvC6qD,QAD2CR;sBAKtC,aAPWrqD,MAOpBztG;mBAxXA;6BAsYAyO,MAAM6+E,OAAMwqE;sBAChB,OADIrpJ;wBAEC,OAFDA;;2BASK,mBATLA,OASgC,QAThCA;+BAGEkqJ,QAHUb;;;2BAWC;4BARXa;6BAQW,gBAXblqJ,OAWwC,YAX5BqpJ;;;2BAaP;4BAVHa;6BAUG,gBAbLlqJ;gCAeI,QAfJA,SAgBI,YAhBQqpJ;;;;2BAkBW,6BAlBvBrpJ,mBAAYqpJ;;;;;;;;;kCARKt7F;kCAAHrtE;;;wCAAGqtE;;;;kCACAx8D;kCAAXy2I;kCACFhpC,WADEgpC,UAJUmiB;kCAcdD,QAxBJJ,sBAeM9qD,KADaztG;;;6BjLmGf,YiLhG2B;;wBAwB/B,WApBEyO;wBAoBF,kBApBEA,MAGEkqJ;sBAmBD,eAtBDlqJ,UAsB4D;mBA5Z5D;6BA+ZS0pB,IAAW1pB;sBACxB,GADa0pB,IAAQ,QAARA,aAAQypC,aAAR20F;sBAC6C,yBAD7CA,OAAW9nJ;sBACkC,UADlCA,kBAC4D;mBAhahF;6BAqasBA,MAAO2xB;sBACjC,IAAIh0C,IAAJ,sBADiCg0C;sBACjC,SAAIh0C;wBAEC,I9X9FYe,O8X2FSshB;wB9X3FA,e8X2FAA,S9X3FTthB;sB8XgGf,QALwBshB,QACtBriB;sBAIF,eALwBqiB,SAME;mBA3axB;6BA+aAA,MAAMzO;sBACA,IAANgQ,IAAM,SADNvB;sBAEJ,QAFIA;sBAEJ,OAFIA;;yBAMG,mBANHA;0BAM8B,wBAN9BA,MACAuB;6BAEA8nJ,QAHM93J;;;yBAQK,IALX83J,QAKW,gBARXrpJ,aACAuB,KADMhQ;;;yBAUH;0BAPH83J;2BAOG,gBAVHrpJ;8BAYE,wBAZFA,MACAuB,gBADMhQ;;;;yBAkBQ;iDAlBdyO;0BAiBgB;;6CACF,sBAjBduB,UADAvB;;0BAiBgB,QADZu5F,IAfJh4F;0BAEA8nJ,QAmBA,sBADIrqD,KArBEztG;sBAwBV,kBAxBIyO,MAGAqpJ,UAqB2B;mBAvc3B;6BA2cArpJ,MAAM6+E,OAAMttF;sBACN,IAANgQ,IAAM,SADNvB;sBAEJ,QAFIA;sBAEJ,OAFIA;;yBAMG,mBANHA,OAM8B,QAN9BA;6BAGAqpJ,QAHY93J;;;yBAQD,IALX83J,QAKW,gBARXrpJ,aACAuB,KADYhQ;;;yBAUT;0BAPH83J;2BAOG,gBAVHrpJ;8BAYE,QAZFA,eACAuB,KADYhQ;;;;yBAgBZ,IAAI4G,IAhBJ6H;yBAiBA,SADI7H;yBAAJ,IAEIza,EAAI,SAFJya;yBAGJ,QAHIA;yBAAJ;0BAKe,sBArBf6H,OACAuB,OAiBI7jB;0BAfJ2rK,QAoBA,sBAHIrqD,KApBQztG;sBAyBhB,kBAzBIyO,MAGAqpJ,UAsB2B;mBApe3B;6BAwhBArpJ,MAAM6+E,OAAKttF;sBACf,QADIyO;wBAGkC,wBAHlCA;wBAGkC;wBACpC,SAJEA,YAAM6+E;wBAIR,OAJattF;sBAMR,OANQA,KAMH;mBA9hBR;6BAkiBAyO,MAAMzO;sBACV,OADIyO;+BAEW,OAFLzO;+BAGA,OAHAA;+BAIe,OAJfA;;yBAMR,QANEyO,YAOM,WADJ7H;yBAEJ,QAFIA;yBAAJ;0BAGkD,sBAThD6H,OAOEtiB;0BAGQ,iCADRmsK,QATIt4J;yBAUI,kCAVVyO,MAUEqpJ,WAC2C;mBA7iB7C;6BAijBArpJ,MAAMzO;sBACV,OADIyO,SACoB,QADpBA;sBAED,eAFCA,OAEsB,QAFtBA;sBAE8E,SAF9EA;wBAIC,UAJDA;wBAIC;;;;wBjLnFC,YiLuFF,QARAA;sBASJ,OATUzO,KASL;mBEpmBI;6BAA2Bq5J;sB,gBAQ9B3oK,MALN,UAHoC2oK,MAQ9B3oK,KACF;mBAGa,+BLsBf0kK;mBKrB8B,4CLqB9BA;mBKpBoB;mBACN,4BLJZF;mBIHFoE;6BAAM7qJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHyB;6BAAM9qJ,MAAM6+E,OAAMttF;sBACpB,oBADQyO,SAER,UAFQA,OAER,OAFoBzO,KAGf;mBAGHw5J;6BAAM/qJ,MAAM6+E,OAAMttF;sBACpB,oBADQyO;sBAER,YAFQA;sBAER,OAFoBzO,KAGf;mBAGHy5J;6BAAMhrJ,MAAM6+E,OAAMttF;sBACpB,oBADQyO,SAER,UAFQA,OAER,OAFoBzO,KAGf;mBAGH05J;6BAAMjrJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,oBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH6B;6BAAMlrJ,MAAM6+E,OAAMttF;sBACpB,oBADQyO,SAER,UAFQA,OAER,OAFoBzO,KAGf;mBAGH45J;6BAAMnrJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,QADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH+B;6BAAMprJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,QADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHgC;6BAAMrrJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,mBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHiC;6BAAMtrJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHkC;6BAAMvrJ,MAAO6+E,OAAMttF,OAAS,eAAtByO,WAAyE;mBAC/EwrJ;6BAAMxrJ,MAAO6+E,OAAMttF,OAAS,eAAtByO,WAA8E;mBAEpFyrJ;6BAAMzrJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,cADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHqC;6BAAM1rJ,MAAM6+E,OAAMttF;sBACR,IAAR83J,QAAQ,cADJrpJ,MAAYzO;sBAEpB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHsC;6BAAM3rJ,MAAM6+E,OAAMttF;sBACR,IAAR83J,QAAQ,cADJrpJ,MAAYzO;sBAEpB,oBAFQyO;sBAGR,YAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHuC;6BAAM5rJ,MAAM6+E,OAAMttF;sBACR,IAAR83J,QAAQ,cADJrpJ,MAAYzO;sBAEpB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHwC;6BAAM7rJ,MAAM6+E,OAAKttF;sBACP;6CADJyO,MAAWzO;uBAEP,4BAFJyO,MAAM6+E,OACVwqE;sBAEJ,oBAHQrpJ;sBAIR,UAJQA;sBAIR,OAFIkqJ,OAGC;mBAGH4B;6BAAM9rJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,cADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH0C;6BAAM/rJ,MAAM6+E,OAAKttF;sBACP;6CADJyO,MAAWzO;uBAEP,gBAFJyO,MAAM6+E,OACVwqE;sBAEJ,oBAHQrpJ;sBAIR,UAJQA;sBAIR,OAFIkqJ,OAGC;mBAGH8B;6BAAMhsJ,MAAM6+E,OAAKttF;sBACP;6CADJyO,MAAWzO;uBAEP,gBAFJyO,MAAM6+E,OACVwqE;sBAEJ,oBAHQrpJ;sBAIR,UAJQA;sBAIR,OAFIkqJ,OAGC;mBAGH+B;6BAAMjsJ,MAAM6+E,OAAKttF;sBACP;6CADJyO,MAAWzO;uBAEP,2BAFJyO,MAAM6+E,OACVwqE;sBAEJ,oBAHQrpJ;sBAIR,UAJQA;sBAIR,OAFIkqJ,OAGC;mBAGHgC;6BAAMlsJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,cADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH8C;6BAAMnsJ,MAAO6+E,OAAMttF,OAAS,eAAtByO,UAA+E;mBAErFosJ;6BAAMpsJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHgD;6BAAMrsJ,MAAM6+E,OAAMttF;sBACR,IAAR83J,QAAQ,iBADJrpJ,MAAYzO;sBAEpB,oBAFQyO;sBAGR,YAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHiD;6BAAMtsJ,MAAM6+E,OAAMttF;sBACR,IAAR83J,QAAQ,iBADJrpJ,MAAYzO;sBAEpB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHkD;6BAAMvsJ,MAAM6+E,OAAKttF;sBACP;uDADJyO,MAAWzO;uBAEP,sBAFJyO,MAAM6+E,OACVwqE;sBAEJ,oBAHQrpJ;sBAIR,UAJQA;sBAIR,OAFIkqJ,OAGC;mBAGHsC;6BAAMxsJ,MAAM6+E,OAAMttF;sBACR;uDADJyO,MAAYzO;uBAER,sBAFJyO,MACJqpJ;sBAEJ,oBAHQrpJ;sBAIR,UAJQA;sBAIR,OAFIkqJ,OAGC;mBAGHuC;6BAAMzsJ,MAAM6+E,OAAMttF;sBACR;uDADJyO,MAAYzO;uBAER,sBAFJyO,MACJqpJ;sBAEJ,oBAHQrpJ;sBAIR,YAJQA;sBAIR,OAFIkqJ,OAGC;mBAGHwC;6BAAM1sJ,MAAM6+E,OAAMttF;sBACR;uDADJyO,MAAYzO;uBAER,sBAFJyO,MACJqpJ;sBAEJ,oBAHQrpJ;sBAIR,UAJQA;sBAIR,OAFIkqJ,OAGC;mBAGHyC;6BAAM3sJ,MAAM6+E,OAAKttF;sBACP;uDADJyO,MAAWzO;uBAEP,sBAFJyO,MACJqpJ;uBAEQ,4BAHJrpJ,MAAM6+E,OAEVqrE;sBAEJ,oBAJQlqJ;sBAKR,UALQA;sBAKR,OAFI4sJ,OAGC;mBAGHC;6BAAM7sJ,MAAM6+E,OAAKttF;sBACP;uDADJyO,MAAWzO;uBAEP,sBAFJyO,MAAM6+E,OACVwqE;sBAEJ,oBAHQrpJ;sBAIR,UAJQA;sBAIR,OAFIkqJ,OAGC;mBAGH4C;6BAAM9sJ,MAAM6+E,OAAKttF;sBACP;uDADJyO,MAAWzO;uBAEP,sBAFJyO,MACJqpJ;uBAEQ,gBAHJrpJ,MAAM6+E,OAEVqrE;sBAEJ,oBAJQlqJ;sBAKR,UALQA;sBAKR,OAFI4sJ,OAGC;mBAGHG;6BAAM/sJ,MAAM6+E,OAAKttF;sBACP;uDADJyO,MAAWzO;uBAEP,sBAFJyO,MACJqpJ;uBAEQ,gBAHJrpJ,MAAM6+E,OAEVqrE;sBAEJ,oBAJQlqJ;sBAKR,UALQA;sBAKR,OAFI4sJ,OAGC;mBAGHI;6BAAMhtJ,MAAM6+E,OAAKttF;sBDkSnB,cClSQyO;sBDkSR;uBCjSIqpJ;6BADIrpJ,YDsSc,iBCtSdA,SAAWzO;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH4D;6BAAMjtJ,MAAM6+E,OACVttF;sBDoSJ,WCrSQyO;sBDqSR,OCrSQA;;;;;yBD2SN,SC3SMA;2BD6SgC,2BC7ShCA;2BD6SgC;2BACpC,SC9SIA;yBD+SN,SC/SMA,YAAM6+E;sBAEd,oBAFQ7+E;sBAGR,UAHQA;sBAGR,OAFIzO,KAGC;mBAGH27J;6BAAMltJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,qBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH8D;6BAAMntJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,qBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,YAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH+D;6BAAMptJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,iBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHgE;6BAAMrtJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHiE;6BAAMttJ,MAAM6+E,OAAKwqE;sBDtCnB,UCsCcxqE;sBDtCd;;;;;;;;;;;6CAAIl+F;;;sBjLuRE;+BiL/QF,SC8BIqf,iBDtCJrf,ECsCUk+F;mCDtCVl+F,ECsCUk+F;;sBD3Bd,SC2BQ7+E,SDtCJrf;sBAAJ,ICuCI4Q,MD5BJ,eC2BQyO,MAAM6+E,OAAKwqE;sBAEnB,oBAFQrpJ;sBAGR,UAHQA;sBAGR,OAFIzO,KAGC;mBAGHg8J;6BAAMvtJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,YAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHmE;6BAAMxtJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHoE;6BAAMztJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,oBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHqE;6BAAM1tJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHsE;6BAAM3tJ,MAAM6+E,OAAKttF;sBACP;kDADJyO,MAAWzO;uBAEP,6BAFJyO,MAAM6+E,OACVwqE;sBAEJ,oBAHQrpJ;sBAIR,UAJQA;sBAIR,OAFIkqJ,OAGC;mBAGH0D;6BAAM5tJ,MAAM6+E,OAAKttF;sBACP;kDADJyO,MAAWzO;uBAEP,yBAFJyO,MAAM6+E,OACVwqE;sBAEJ,oBAHQrpJ;sBAIR,UAJQA;sBAIR,OAFIkqJ,OAGC;mBAGH2D;6BAAM7tJ,MAAM6+E,OAAKttF;sBACP;kDADJyO,MAAWzO;uBAEP,uBAFJyO,MAAM6+E,OACVwqE;sBAEJ,oBAHQrpJ;sBAIR,UAJQA;sBAIR,OAFIkqJ,OAGC;mBAGH4D;6BAAM9tJ,MAAO6+E,OAAMttF,OACrB,eADQyO,UACqD;mBAG3D+tJ;6BAAM/tJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,oBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH2E;6BAAMhuJ,MAAM6+E,OAAKwqE;sBDzEsB,IAArCxjJ,OCyEI7F,sBAAM6+E;sBDzE2B;+BAArCh5E,MAEgB,QCuEZ7F;sBDzEiC,UAGP,IAH9B6F;sBAGJ,SCsEQ7F;sBDzEiC,IC0ErCzO,MDvEJ,eCsEQyO,MAAM6+E,OAAKwqE;sBAEnB,oBAFQrpJ;sBAGR,UAHQA;sBAGR,OAFIzO,KAGC;mBAGH08J;6BAAMjuJ,MAAO6+E,OAAMttF,OACrB,eADQyO,UACqD;mBAG3DkuJ;6BAAMluJ,MAAM6+E,OAAKwqE;sBDrEoC,kBCqEzCxqE;sBDrEyC,WCqE/C7+E;sBDrE+C,ICsEnDzO,MDtEmD,eCqE/CyO,MAAM6+E,OAAKwqE;sBAEnB,oBAFQrpJ;sBAGR,UAHQA;sBAGR,OAFIzO,KAGC;mBAGH48J;6BAAMnuJ,MAAM6+E,OAAKwqE;sBDvEyB,kBCuE9BxqE,QDvE8B,MCuEpC7+E;sBDvEoC;gCAEV,IAF9B6F;sBAEJ,SCqEQ7F;sBDvEoC,ICwExCzO,MDtEJ,eCqEQyO,MAAM6+E,OAAKwqE;sBAEnB,oBAFQrpJ;sBAGR,UAHQA;sBAGR,OAFIzO,KAGC;mBAGH68J;6BAAMpuJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,qBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHgF;6BAAMruJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHiF;6BAAMtuJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,qBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,YAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHkF;6BAAMvuJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,iBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHmF;6BAAMxuJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHoF;6BAAMzuJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHqF;6BAAM1uJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,YAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHsF;6BAAM3uJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHuF;6BAAM5uJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHwF;6BAAM7uJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHyF;6BAAM9uJ,MAAM6+E,OAAKwqE;sBD6GnB,WC7GQrpJ;sBD6GR,OC7GQA;mCACJkqJ,QADeb;mCACfa,QADeb;mCACfa,QADeb;;yBDmHjB,IAAIlxJ,ICnHE6H;yBDoHN,SADI7H,ICnHQ0mF;yBDoHZ,SCpHM7+E;2BDuHI,IAAJtiB,EAAI,SAJNya;2BAKF,QALEA;2BAIM;4BAGgB,yBC1HpB6H,ODuHAtiB;4BAKQ,+BAHRmsK,QCzHWR;4BACfa,QD2HY,2BC5HRlqJ,MD4HAzO;;8BC3HJ24J,QADeb;sBAEW,gBAFtBrpJ;sBAER,oBAFQA;sBAGR,UAHQA;sBAGR,OAFIkqJ,OAGC;mBAGH6E;6BAAM/uJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,YAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH2F;6BAAMhvJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH4F;6BAAMjvJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,YAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH6F;6BAAMlvJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH8F;6BAAMnvJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,oBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGH+F;6BAAMpvJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHgG;6BAAMrvJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHiG;6BAAMtvJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHkG;6BAAMvvJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHmG;6BAAMxvJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,oBADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHoG;6BAAMzvJ,MAAM6+E,OAAKwqE;sBD7OsB,IAArCxjJ,OC6OI7F,sBAAM6+E;sBD7O2B;+BAArCh5E,MAEgB,QC2OZ7F;sBD7OiC,IC8OrCzO,MD5O4E,eC2OxEyO,MAAM6+E,OAAKwqE;sBAEnB,oBAFQrpJ;sBAGR,UAHQA;sBAGR,OAFIzO,KAGC;mBAGHm+J;6BAAM1vJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHsG;6BAAM3vJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,UAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHuG;6BAAM5vJ,MAAM6+E,OAAKttF;sBACP,IAAR83J,QAAQ,eADJrpJ,MAAM6+E,OAAKttF;sBAEnB,oBAFQyO;sBAGR,YAHQA;sBAGR,OAFIqpJ,OAGC;mBAGHwG;6BAAU7vJ,MAAMzO,OAAQ,qBAAdyO,MAAMzO,MAAiC;mBACjDu+J,mBAAU9vJ,MAAMzO,OAAS,eAAfyO,WAAgE;mBAC1E+vJ,mBAAU/vJ,MAAMzO,OAAS,eAAfyO,WAAqE;mBAE/EgwJ;6BAAUhwJ,MAAMzO;sBACN,IAAR83J,QAAQ,cADArpJ,MAAMzO;sBACN,qBADAyO,MACRqpJ,QACqB;mBAGvB4G;6BAAUjwJ,MAAMzO;sBACN,IAAR83J,QAAQ,iBADArpJ,MAAMzO;sBACN,qBADAyO,MACRqpJ,QACqB;mBAGvB6G;6BAAUlwJ,MAAMzO;sBACN;uDADAyO,MAAMzO;uBAEN,sBAFAyO,MACRqpJ;sBACQ,qBAFArpJ,MAERkqJ,QACqB;mBAGvBiG,mBAAUnwJ,MAAMzO,OAAS,eAAfyO,UAAkE;mBAC5EowJ,mBAAUpwJ,MAAMzO,OAAS,eAAfyO,UAAkE;mBAE5EqwJ;;qBAxjBAxF;;;;;;;;;qBAOAC;qBAMAC;qBAbAF;qBAOAC;qBAYAE;qBAnBAH;;;;;;;;;;;;;;;;;;qBAOAC;qBAPAD;qBAyBAI;qBAOAC;qBAhCAL;;;;qBAsCAM;qBAOAC;qBA7CAP;;;;;;;;;;;;;;;;;qBAoDAQ;qBApDAR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2DAS;qBA3DAT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkEAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBACAC;;;;;;;;;;qBAtDAT;qBAsDAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAEAC;;;;;;;;;qBAOAC;qBAOAC;qBAdAF;qBAOAC;qBAcAE;qBArBAH;;;;;;;;;;;;;;;;;;qBAOAC;qBAPAD;qBA4BAI;qBAQAC;qBApCAL;;;;qBA2CAM;qBAQAC;qBAnDAP;;;;;;;;;;;;;;;;;qBA2DAQ;qBA3DAR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmEAS;qBAnEAT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAOAC;qBAOAC;qBAdAF;qBAOAC;qBAcAE;qBArBAH;;;;;;;;;;;;;;;;;;qBAOAC;qBAPAD;qBA4BAI;qBAQAC;qBApCAL;;;;qBA2CAM;qBAQAC;qBAnDAP;;;;;;;;;;;;;;;;;qBA2DAQ;qBA3DAR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0EAU;qBA1EAV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAOAC;qBAOAC;qBAdAF;qBAOAC;qBAcAE;qBArBAH;;;;;;;;;;;;;;;;;;qBAOAC;qBAPAD;qBA4BAI;qBA8CAM;qBA1EAV;;;;qBA2CAM;qBAQAC;qBAnDAP;;;;;;;;;;;;;;;;;qBA2DAQ;qBA3DAR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmEAS;qBAnEAT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4EAW;;;;;;;;;;qBAOAC;qBAPAD;;qBAcAE;qBAdAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqBAG;;;;;;;;;qBAQAC;qBAQAC;qBAhBAF;qBAQAC;qBAgBAE;qBAxBAH;;;;;;;;;;;;;;;;;;qBAQAC;qBARAD;qBAgCAI;qBASAE;qBAzCAN;;;;qBAiDAO;qBASAC;qBA1DAR;;;;;;;;;;;;;;;;;qBAmEAS;qBAnEAT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0EAU;qBA1EAV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiFAW;;;;;;;;;;qBAOAC;qBAPAD;;;;;;;;;;;;;;;;;;;;;;;qBAcAE;qBAdAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqBAG;qBArBAH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4BAI;;;;;;;;;;qBAOAC;qBAPAD;;qBAcAE;qBAdAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqBAG;;;;;;;;;;qBArBAH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4BAI;qBA5BAJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCAK;;;;;;;;;;qBA5BAJ;qBA4BAI;;;;;;;;;;;;;;;;;;;;;;;qBAQAC;qBARAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgBAE;qBAhBAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAwBAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAIAC;;;;;;;;;;qBAJAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAWAE;;;;;;;;;;qBAXAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkBAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAIAC;;;;;;;;;;qBAJAD;;;;;;;qBAIAC;;;;;;qBAJAD;;;;;;;;;;;;;;;;;;;;;;;;;;qBAIAC;;;;;;qBAJAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAWAE;;;;;;;;;;qBAXAF;;;;;;;qBAWAE;;;;;;qBAXAF;;;;;;;;;;;;;;;;;;;;;;;;;;qBAWAE;;;;;;qBAXAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkBAG;;;;;;;;;qBAOAC;qBAOAC;qBAdAF;;;;;;;;;;;;;;;;;;;;;qBAOAC;qBAPAD;qB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AA,WvC8lDA,sBuC9lDAA,e0Cxb0E;;wBjF4hE1E;iCuCpmDAA;iCvComDA,uCuCpmDAA,e0CrbwD;;wBjF+hExD;iCuC1mDAA;iCvC0mDA,oCuC1mDAA,e0ClbkF;;wBACjE,kB1CibjBA,iB0Cjb4D;;wBjFm9D9D,qBACE,gBuCniDAA,gBvCmiDyB;wBADhB;0EuCliDTA,kB0Chb8E;;wBjFu9D3D;iCuCviDnBA,WvCuiDmB,8BuCviDnBA,Y0C/aoE;;wBAC3C,sB1C8azBA,mB0C9a4E;;wBjF29D5E;iCuC7iDAA,WvC6iDA,qBuC7iDAA,e0C7awE;;wBjFg+DxE;iCuCnjDAA;iCvCmjDA,sCuCnjDAA,e0C1auD;;wBjFm+DvD;iCuCzjDAA;iCvCyjDA,mCuCzjDAA,e0CvagF;;wBAC9D,kB1CsalBA,iB0Cta8D;;wBjFohE3C;iCuC9mDnBA;iCvC8mDmB,4CuC9mDnBA,Y0CnaoE;qDAG5C,wBAAsC;oD1C+ZtDmvC,QAAQC;wBAEpB;;oDADIpvC,WADQmvC,QAAQC;;uD,OtCk3DhBt8B,UsCj3DA9S,mB0C7Z2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8J3D;;;;;kBpDzZO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBoDqec,mCAAyB;;wBjFq1CV,0CiFl1C4B;;;0BASnC,oDAAsC;;;;0BjF21CrE,eiFt1CE;0BjF0rBF;4BAG6C;qFAA8B;0BADnE;;8CtJpqCJ7I,oBsJoqCyB;yCiF5rB8C;;;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;;;;;;;;;;;;;;wBjFwrDrE,8CiFr4DkD;6CAErC,WAAI;;wBACL,uB,mBAAuB;;wBjFqlDrC,sDiFplDqE;;wB;uCjFwlDvE,2CiFvlDmD;;wBjF0nDnD,8CiFvnDoD;;wBjF6nDlD;yFiF1nDmE;;wBjF8nD/D;;;wBACqB,QiF9nDgB;;wB;;iCjFmoD3C;yCiFloD6D;;wBjFqoDrB,kDiFpoDW;;wBjFuoD/C,4CiFtoDmD;;wBjF0oDnD;mCiFzoDmE;;wBjF6oDnE,0DiF5oD2D;;wBjFglDzD;;;wBACqB,QiFhlDU;;wB;uCjFqlDrC,mDiFplDuD;;wBACpC,mCAA0B;;wBAxLrC,sCAyL+D;;wBjFwlDnE,yCiFvlD6C;;wBjF2lD7C,0DiF1lD6D;;wBjF8lD7D,uDiF7lDqD;;wBjFimDnD;;;wBAEqB,QiFlmDoB;0CAEjC,QAAC;6CjFwoDf,oCiFvoDyC;2CjF0oD1B,oBiFzoDU;yCjF0oDZ,mBiFzoDQ;;wBACA,mCAA4B;;wBAC5B,mCAA4B;;wBACxB,uCAAgC;;wBjF6pDzD,+CiF5pD6D;;wBjFiqD7D,2CiFhqDiD;;wBjFoqDjD,oCiFnqD6C;6CAC3B,iCAAyB;;wBjF0qD3C;;;;gDAA8C,6BAAQ,EiFzqDX;;wBjF6qD3C,kDiF5qDyC;yCjForDzC,gCiFnrDiC;2CAClB,+BAAsB;wCjFyrDX,+BiFxrDK;4CjF+rD/B,mCiF1rDyC;;wBjFmsDzC,wCiF9rDqD;;wBjFksDjD,wCiFjsD6C;2CjFqsD7C,qCiFpsDmC;;wBjFwsDnC,oCiFvsDqC;;wBjF2sDrC,yCiF1sD2C;;wBjF8sD3C,wCiF7sD6C;;wBjFktD/C;;;;;sCiFjtDqD;;wBjFwtDrD;;;;;sCiFvtDmD;;wBjF8tDnD;;;;;sCiF7tDmD;;wBjFouDnD;;;;;sCiFnuDiD;;wBjF2uDjD;;;yCiF1uD+C;;wBjFivDjD,sCiFhvDyD;4CjFovDzD,oCiFnvDuC;;wBjF6vDvC,qDiFvvD6E;;wBjF2vD7E;qEiFxvDwD;;wBjFkwDpD,sCiF/vDqC;0CjF4wDf,iCiFjwDS;;wBjFowDnC,oDiFnwD6E;;wBjFwwD3E;;;kCiFrwD8C;;wBjF+wDhD,2DiF3wDqD;;wBjFqxDrD,8CiFlxDqE;;wBjFsxDrE,uCiFrxDmD;;wBACzC,uB,OhFopEN0b,0BgFppEuB;;wBACb;0BjFuxD+B,8CiFvxDV;2CjF0xDnC,8BiFzxDiC;;;wBjFmyDjC;;;;;mCiFhyDiF;;wBjFwyDhC,uCiFryD4B;;wBjFwyD7E,kDiFryDqD;;wBA1QC,kDA6QM;;wBAxT5D,gDAyToE;wDAlT3C,oBAmT8B;;wBAhTvD,kDAiTmE;;wBjF6wD7B,uCiF7nDuC;;;0BAQ5C,qCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8B1F7bnEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kB0F0lBH;;kBparqBGuV;kBI4HFwV;kB4WrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uB5B0BX4rB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBhV0GE7rB;kBJ5HExV;kBqaVN;;kBrDEa;mBqDFb;sCtC0F0B,uCsC5DgD;mBA9B1E;;sBxC2NE,gBAAY8lC;wBACO,IAAb1tD,WADM0tD;wBAKH,sB,UAJH1tD;wBAEF;yBADE1vH;0BACF;4BACE,4BAHA0vH;;;0CACA1vH,EAFMo9K,MAQI,CwCnMwD;mBAhC1E,0BAkDmD,wBAAe;mBAlDlE;;sBAqD6B;sBvEFL;;;mDuEEwC,4BvEFmB,EuEEC;mBArDpF;;sBAyDI,0BACE,4BAAmB;sBADM;qEACL;mBA1D1B;;sB,I3CgqBM1tD;6C2Clfe,U3CkffA,gB2ClfuC;;wBACL,mC3CiflCA,iB2Cjf6E;;wBAG/E,wC3C8eEA,iB2C9ekD;;wBxF0rCpD,qBAEkB,U6C9sBhBA,gB7C8sBoC;wBADpC,gC6C7sBAA;wB7C6sBA,+CwFxrCyD;;4CxFqqCV,U6C1rB/CA,iB2CteqC;;wBxFmqCnB,U6C7rBlBA,W7C6rBkB,W6C7rBlBA,sB2CreuC;0CAC3B,iB3CoeZA,a2CpeiC;;wBAzDf,U3C6hBlBA,W2C7hBkB,Y3C6hBlBA,c2CneyC;;wBAtDvB,U3CyhBlBA,W2CzhBkB,gB3CyhBlBA,c2CleiD;;wBxFwrC9B,U6CttBnBA,W7CstBmB,a6CttBnBA,e2CjemC;;wBxF2rCrC,4B6C1tBEA,c2CheuD;;wBxF8rCpC,U6C9tBnBA,W7C8tBmB,c6C9tBnBA,e2C/d+B;;wBxFksCxB,U6CnuBPA,W7CmuBO,oB6CnuBPA,e2C9d6C;;wBAGvC,gC3C2dNA,2B2C3dwD;oD3C0dhD8rC;wBAEZ,oCADI9rC,WADQ8rC;;uD,UACR9rC,mB2Cvd+D;;;;;;;;;;;;;;;;;;;mBAzMrE;kBAmUM;kBrDjUO;;;;;;;;;;;;;;;;;;;;;;;8CqDyYS,4BAAoB;4CxFwxBV,gCwFvxB2B;;;0BAQlC,wCAA4B;;;;0BxFsyBjD,ewFlyB0B;0BxFsab;;8ChJ9yBT7I,oBgJ8yB8B;yCwFtaiD;;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;+CxFggCiB,kCwF//Bf;yCxF8/BjC,kBwF7/Ba;2CxF+/BX,oBwF9/Be;6CxF+/Bf,kBwF9/Be;0CxF+/BhB,mBwF9/Bc;gDxF+/BV,qBwF9/BkB;0CxF+/BtB,mBwF9/Bc;gDxF+/BV,qBwF9/BkB;2CxF+/BvB,gBwF9/Ba;+CxF+/BT,oBwF9/BiB;0CACpB,mBAAc;2CxF+/Bb,oBwF9/Be;yCxF+/BhB,kBwF9/Bc;;wBxFihCiC,+CwFhhCf;2CxF8/B9B,oBwF7/BgB;4CxF8/Bf,qBwF7/BiB;0CxF8/BnB,mBwF7/Be;0CxF8/Bf,mBwF7/Be;yCxF8/BhB,kBwF7/Bc;6CxF8/BV,sBwF7/BkB;6CxF8/BlB,sBwF7/BkB;8CxF8/BhB,uBwF7/BoB;;wBxF8/Bd,uB,oCwF7/B0B;oDxF8/B1B,6BwF7/B0B;;wBACzB,iCAAsC;wCxF6/BZ,gCwF5/Bf;2CxF6/BqB,kCwF5/Bf;;wBxF6/BuB,sCwF5/Bf;;wBxF+/Bf,sCwF9/BmB;wCAC5C,4BAAwB;wCACxB,4BAAwB;2CACrB,+BAA2B;8CxFkgCiB,iCwFjgCf;8CxFkgCe,iCwFjgCf;6CxFkgCa,gCwFjgCf;;wBxFogCF,0CwFngCsB;;wBxFsgCX,sCwFrgCW;4CxFsgCH,mCwFrgCf;;wBxFsgCyB,oCwFrgCf;;wBxFwgChB,wCwFvgCoB;0CAC5C,8BAA0B;gDACtB,gCAA8B;;wBAC1B,oCAAkC;2CxFwgCC,kCwFvgCf;;wBxF0gCK,iDwFzgC6B;;wBxF6gC5E,4CwF1gCyD;;wBxF8gCpB,uCwF3gCmB;;wBxF8gC3B;4D,gBwF7gCiB;;wBxFghCN,0CwF/gCsB;;wBxFmhCzB,sCwFlhCmB;0CxFqhCD,iCwFphCf;wCxFqhC5B,iBwFphCY;;wBxFqhC6C,sCwFphCf;4CACxC,QAAC;0CACD,QAAC;;;wBxFwhCf;yFwFrhC4E;;wBxFwhC3B,uCwFrhCiC;;wBxFwhClF,kDwFrhC0D;;;wBxFyhC1D;;;;;;mCwFrhCqF;6C,iCAIzC;;wBxF6hC3B,oDwF1hC6C;;wBxFkiC7C;;;yBA5QX;wBADA;0EwFpxB8C;;;wBApQpD,gDAuQoE;wDAnQ/C,oBAoQkC;;wBAhQvD,kDAiQmE;gDA4I/C,8BAAoB;8CxF62BZ,6BwF52BkC;;;0BAS1D,2CAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+IzE;;kBra9jBG0wB;kBI4HFwV;kB4WrIS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kB5WoITD;kBJ5HExV;kBoTVN;;kBAkEG;;kBpTvDGC;kBI4HFwV;kBADAD;kBJ5HExV;kBsaVN;;kBtDEa;mBsDFb;oC;mBAAA;;;;;;;;uBlH2MWvvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBkH3MX;;;;;;;;;uBlH2MWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBkH3MX;;;;;;;;;;;;;;uBlH2MWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBkH3MX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4MG;;kBtajMGwvE;kBI4HFwV;kB4WrIS;;;;;;;;;;;;;;;;;;;;;;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qBADAD;;;;;;;;;qB4FjBKqpB;;;;mB6HrNgC,qB;mBAAA;;;;kBAkBvC;kBAED;;kBjbhBGuK;kBI4HFwV;kBADAD;kBJ5HExV;kBkbKN;;kBAsHG;;kBlb1HGC;kBI4HFwV;kBADAD;kBJ5HExV;kBmbVN;;kBAW4B,sBAAC,WzN8RhBH;kByNzIV;;kBnbrJGI;kBI4HFwV;kBADAD;kBJ5HExV;kBobVN;;kBpEEa;mBoEWP;;mBAAmC;oC;mBAAA,kB5EkHrC+R,gBrIqCApD;mBiNvJqC,kB9E4QrCsB;mB8E5QqC;;;qB5EkHrC8B;qBrIqCApD;qBmIqHAsB;;;;;;qB9I+XEvjC;qBAaAtF;qBACAxB;;kB4NzpBmC;;qB5EkHrCmsC;qBrIqCApD;qBmIqHAsB;;;;;;qB9I4YE7oC;qBAbAsF;qBAcA9G;;kBwJpqBO;mBoE4BT;;mBAAmC;oC;mBAAA,kB5EiGnCmsC,gBrIqCApD;mBiNtImC,kB9E2PnCsB;mB8E3PmC;;;qB5EiGnC8B;qBrIqCApD;qBmIqHAsB;;;;;;qB9I4YE7oC;qBACAxB;qB4FreK2X;kBgInK4B;;;qB5EiGnCw0B;qBrIqCApD;qBmIqHAsB;;;;;;qB9I4YE7oC;qB4FpeKkW;qB5FqeL1X;;kB4NxoBiC;kBpE5B1B;mBoEyCP;;mBAAmC;oC;mBAAA,kB5EoFrCmsC,gBrIqCApD;mBiNzHqC,kB9E8OrCsB;mB8E9OqC;;;qB5EoFrC8B;qBrIqCApD;qBmIqHAsB;;;;;;mB8E9OqC;;qBvOZjC3gC;;qBWsoBFlI;qBACAxB;;;;;;;;;qBAbA+G;qBADAD;;;;;;;;;;;;qB2CroBFnjG;mBiLwBqC,2B;mBAAA;;;;;;;;;;;;;;;;sBAkBvC,0CAA6D;mBAlBtB;;sBAqCvC,sDAA4E;kBAK3D;;kBpb1Eb02H;kBI4HFwV;kBADAD;kBJ5HExV;kBqbVN;;kBrEEa;mBqEIT;;mBAA2C;oC;kBAAA;kBA4B+B;;kBrbvBxEC;kBI4HFwV;kBADAD;kBJ5HExV;kBsbVN;;;kBtEEa;mBsEKP;;mBAAiC;oC;mBAAA,mB9EoGnC0R,crIkBAlD;mBmNtHmC,mBhFuRnC0B;mBgFvRmC;;;qB9EoGnCwB;qBrIkBAlD;qBmIiKA0B;;;;;;mBgFvRmC;;qB1Ta/BlzB;;;;;;;;;;;;;;;;;;;;;;;;;;mB0Tb+B,qB;mBAAA;;;;;mBAgBnC;;mBAAiC;oC;mBAAA,mB9EoFjC00B,crIkBAlD;mBmNtGiC,mBhFuQjC0B;mBgFvQiC;;;qB9EoFjCwB;qBrIkBAlD;qBmIiKA0B;;;;;;;;qBlD7FO7yB;kBkI1K0B;;;qB9EoFjCq0B;qBrIkBAlD;qBmIiKA0B;;;;;;;qBlD7FO9yB;;;kBkItJiE;;kBtbhCtE6iB;kBI4HFwV;kBADAD;kBJ5HExV;kBubVN;;kBAauC;;kBvbFjCC;kBI4HFwV;kBADAD;kBJ5HExV;kBwbVN;;kBxEEa;mBwEGT;;mBAI4D;oC;mBAAA,8BAJ5D,QAI4D;;;sBAJ5D;;;qEAI4D;;;;sBAJ5D,gDAI4D;;;sBAJ5D;;;+BACE,gBACA,iBACA,SAC0D;;;;kBxEPnD;mBwEOmD;;;;;;;;;;;;;;;;;;qB7b2D1DhpB;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAO;qBADAD;qBAGAG;qBADAD;qBAJAJ;qBACAC;;;;;;;;;mB6b7D0D,2B;mBAAA;;;kBAMlB;;kBxbJxC+oB;kBI4HFwV;kBADAD;kBJ5HExV;kBybVN;;kBzEEa;mByEuBX;;mBAA2C;oC;mBAAA,mBjF0GzCgS,erIuDAnD;mBsNjKyC,mBnFkSzCuB;mBmFlSyC;;;;;;;;;uBjF0GzC4B;uBrIuDAnD;uBmIiIAuB;;;;;;;uB9IQE5jC;uBAcAsyB;;mBiOxTuC;;;;;uBjF0GzCkT;uBrIuDAnD;uBmIiIAuB;;;;;;uB9IQE5jC;;uBAcAsyB;;mBiOxTuC;;;;;;;;;qBjO2SvCryB;qBADAD;;;mBiO1SuC;;sB;;wBA4BlB,+CAAyC;6CAC9C,kBAAO;;wBACR,oDAAkB;;wBACd,8CAAyC;6CAC7C,oBAAM;6CACD,wBAAQ;;wBAGpB;wBACR;;oEAIM;;;;;;;;;;kBAiBV;kBAmCkE;;kBzb3G9DyzB;kBI4HFwV;kBADAD;kBJ5HExV;kB0bVN;;kB1EEa;mB0EKP;;mBAA4C;oC;mBAAA,mBlFqG9C2R,arIwBAlD;mBuN7H8C,mBpF8R9C0B;mBoF9R8C;;;qBlFqG9CwB;qBrIwBAlD;qBmIiKA0B;;;;;;;qB9IkFE9oC;qBb5QE8b;qBerCEb;kBsJpEG;mB0EgBP;;mBAAgC;oC;mBAAA,mBlF0FlCqvB,arIwBAlD;mBuNlHkC,mBpFmRlC0B;mBoFnRkC;;;qBlF0FlCwB;qBrIwBAlD;qBmIiKA0B;;;;;;mBoFnRkC;;qB7PF9B5gC;;qB2BuWFlI;qBb5QE8b;;qBkBlFJvyD;qBmDsIE25C;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAM;;qBAEAE;qBADAD;qBAHAH;qBACAC;;;;qBtD5FI6X;;;;;mBgOpD4B,qB;mBAAA;;;;;;;;;;;;;;;;;;;kBAWpC;kBAS4E;;kB1b3BxE2d;kBI4HFwV;kB4WrIS;;;qBhG6JPlrC;qBAJAJ;qBAEAE;qBACAC;qBAJAJ;qBAEAE;qBAOAM;;qBAEAE;qBADAD;kB5Q9BF6qC;kBJ5HExV;kB2bVN;;kB3EEa;mB2EGP;;mBAAkC;oC;mBAAA,mBnFwIpCiS;mBmFxIoC,mBrFgUpC5B;mBqFhUoC;;;qBnFwIpC4B;;qBFwLA5B;;;;;;mBqFhUoC;;;qBhboHtCxa;qB6MsSIvuB;qBEzVI+xB;;qBG5CN7+D;qBH4CMi9D;;;;;;qBF6UJS;qBADAnC;qBE5UIiC;;qBF4UJjC;qBE5UIgC;;;;;;;;;mBiOjE8B,qB;mBAAA;;;;;;;kBAUtC;kBAS8E;;kB3bb1EkI;kBI4HFwV;kBADAD;kBJ5HExV;kB6bVN;;kB7EEa;mB6EGP;;mBAAkC;oC;mBAAA,mBrFgJpCkS;mBqFhJoC,mBvFiVpC5B;mBuFjVoC;;;qBrFgJpC4B;;qBFiMA5B;;;;;;mBuFjVoC;;qB1ckDlC9gC;qBAzBe+b;qBqOyafhkB;qBEjYIgnB;qBvOxCW9C;qB0OHjB5wD;qB1OGiBqwC;;;;;;qBqO6ZfI;qBADAD;qBrO5ZeG;;;;;;;;qBuOwCXihB;;;;mBmOjE8B,qB;mBAAA;;;;;;kB7EH3B,ItJuEHmhD;kBmOpE8B;kBAUtC;kBAS8E;;kB7bb1E3tC;kBI4HFwV;kBADAD;kBJ5HExV;kB8bVN;;kB9EEa;mB8EFb;;;;qBFuFUwtC;;;;mBEvFV,2B;mBAAA;;;;;;;;;;qB5CUiEK;;;;;;;;mB4CVjE;;sBAkBM;;;gCnPyFEb;;;;;;;yCmPtFsD;mBAGvB;;;;;;;;;;;;;;;;;;;;;;kB9EtB1B;mB8EsB0B;;;;;;;;;;;;qB3a+J/B/yC;;;;;;;;;;;;;;;;;;;;;;;;;;mB2a/J+B,qB;mBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmDrC;kBAS8E;;kB9bzE1EgG;kBI4HFwV;kBADAD;kBJ5HExV;kB+bVN;;kB/EEa;mB+EIP;;mBAAgD;oC;mBAAA;;;sBAOhD;;kFACgD;wB3EqRhDme;;;;;;;;;;;;;;;;;;kBJjSO;mB+EsBP;;mBAAiC;oC;mBAAA,mBvF4DnC3M,crIbArD;mB4N/CmC,mBzF+EnCqB;mByF/EmC;;;qBvF4DnCgC;qBrIbArD;qBmIgCAqB;;;;;;mByF/EmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;mBAAA;;;;;;kBAapB;;kB/b1BbvP;kBI4HFwV;kBADAD;kBJ5HExV;kBgcRN;;kBAwByB;;kBhcfnBC;kBI4HFwV;kBADAD;kBJ5HExV;kBicVN;;kBjFEa;mBiFIT;;8C,gCAAwD;kBAAxD;kBAW2B;;kBjcNzBC;kBI4HFwV;kBADAD;kBJ5HExV;kBkcVN;;kBlFEa;mBkFGP;;mBAAsC;oC;mBAAA;sC5FoWxCuQ;mB4FpWwC;;;;;qB5FoWxCA;;;;;;mB4FpWwC;;;qBvbgI1CnpB;qB6M0ZI5f;;qBEzdI8f;qBG1CNrsD;qBH0CM6wC;;;;;;qBF6cJI;qBADAD;qBE5cIG;;;;;;;;qB0F+KEmb;;;;mB8IhPgC;oC;kBAAA;;kBAU1C;kBASkF;;kBlcb9E0Y;kBI4HFwV;kBADAD;kBJ5HExV;kBmcVN;;kBnFEa;mBmFKP;;mBAA6B;oC;mBAKlB;;0CAMmB,uBAAkB;mBANrC,mBlHFb7Y;mBkHEa;;sBAUX,qDAAwD;mBAV7C;;sBAcX,iDAA6D;mBAdlD;;;;qBlHFbA;;;;;;;;mBkHEa;;;;;;;;;;;;;;;;;;;;;;;;;;;;mC;kBAmCqC;;kBncpChD8Y;kBI4HFwV;kBADAD;kBJ5HExV;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S,EACAC,EACAqD,EACApH,EAtBFggO,KAQA51N,GA+CoB,iBA/BlB/F;4BAgCJ,MAlCIrE,EACAkW,EAJApS,EACAC,EACAqD,EArBF44N,KAQA51N,GAgDoB,iBAhClB/F;4BAiCJ,MApCI+C,EACApH,EACAkW,EAJApS,EACAC,EApBFi8N,KAQA51N,GAiDoB,iBAjClB/F;4BAkCJ,MAtCIN,EACAqD,EACApH,EACAkW,EAJApS,EAnBFk8N,KAQA51N,GAkDoB,iBAlClB/F;4BAmCJ,MAxCIP,EACAC,EACAqD,EACApH,EACAkW,EAvBF8pN,KAQA51N,GAmDoB,iBAnClB/F;4BAoCJ,MArCI6R,EAJApS,EACAC,EACAqD,EACApH,EAtBFggO,KAQA51N,GAoDoB;4BACtB,MAvCIpK,EACAkW,EAJApS,EACAC,EACAqD,EArBF44N,KAQA51N,GAqDoB;4BACtB,MAzCIhD,EACApH,EACAkW,EAJApS,EACAC,EApBFi8N,KAQA51N,GAsDoB;4BACtB,MA3CIrG,EACAqD,EACApH,EACAkW,EAJApS,EAnBFk8N,KAQA51N,GAuDoB;4BACtB,MA7CItG,EACAC,EACAqD,EACApH,EACAkW,EAjBF+pN,KAIA51N,GAsDoB;4BACtB,MA1CI6L,EAJApS,EACAC,EACAqD,EACApH,EAhBFigO,KAIA51N,GAuDoB;4BACtB,MA5CIrK,EACAkW,EAJApS,EACAC,EACAqD,EAfF64N,KAIA51N,GAwDoB;4BACtB,MA9CIjD,EACApH,EACAkW,EAJApS,EACAC,EAdFk8N,KAIA51N,GAyDoB;4BACtB,MAhDItG,EACAqD,EACApH,EACAkW,EAJApS,EAbFm8N,KAIA51N,GA0DoB;4BACtB,MAlDIvG,EACAC,EACAqD,EACApH,EACAkW,EAjBF+pN,KAIA51N,GA2DoB;4BACtB,MA/CI6L,EAJApS,EACAC,EACAqD,EACApH,EAhBFigO,KAIA51N,GA4DoB;4BACtB,MAjDIrK,EACAkW,EAJApS,EACAC,EACAqD,EAfF64N,KAIA51N,GA6DoB;4BACtB,MAnDIjD,EACApH,EACAkW,EAJApS,EACAC,EAdFk8N,KAIA51N,GA8DoB;4BACtB,MArDItG,EACAqD,EACApH,EACAkW,EAJApS,EAbFm8N,KAIA51N,GA+DoB;4BACtB,MAvDIvG,EACAC,EACAqD,EACApH,EACAkW,EAjBF+pN,KAIA51N,GAgEoB;4BACtB,MApDI6L,EAJApS,EACAC,EACAqD,EACApH,EAhBFigO,KAIA51N,GAiEoB;4BACtB,MAtDIrK,EACAkW,EAJApS,EACAC,EACAqD,EAfF64N,KAIA51N,GAkEoB;4BACtB,MAxDIjD,EACApH,EACAkW,EAJApS,EACAC,EAdFk8N,KAIA51N,GAmEoB;4BACtB,MA1DItG,EACAqD,EACApH,EACAkW,EAJApS,EAbFm8N,KAIA51N,GAoEoB;4BACtB,MA5DIvG,EACAC,EACAqD,EACApH,EACAkW,EAjBF+pN,KAIA51N,GAqEoB;4BACtB,MAzDI6L,EAJApS,EACAC,EACAqD,EACApH,EAhBFigO,KAIA51N,GAsEoB;4BACtB,MA3DIrK,EACAkW,EAJApS,EACAC,EACAqD,EAfF64N,KAIA51N,GAuEoB;4BACtB,MA7DIjD,EACApH,EACAkW,EAJApS,EACAC,EAdFk8N,KAIA51N,GAwEoB;4BACtB,MA/DItG,EACAqD,EACApH,EACAkW,EAJApS,EAbFm8N,KAIA51N,GAyEoB;4BACtB,MAjEIvG,EACAC,EACAqD,EACApH,EACAkW,EAnBFgqN,KAQAv0H,GAwEoB;4BACtB,MA9DIz1F,EAJApS,EACAC,EACAqD,EACApH,EAlBFkgO,KAQAv0H,GAyEoB;4BACtB,MAhEI3rG,EACAkW,EAJApS,EACAC,EACAqD,EAjBF84N,KAQAv0H,GA0EoB;4BACtB,MAlEIvkG,EACApH,EACAkW,EAJApS,EACAC,EAhBFm8N,KAQAv0H,GA2EoB;4BACtB,MApEI5nG,EACAqD,EACApH,EACAkW,EAJApS,EAfFo8N,KAQAv0H,GA4EoB;4BACtB,MAtEI7nG,EACAC,EACAqD,EACApH,EACAkW,EAnBFgqN,KAQAv0H,GA6EoB;4BACtB,MAnEIz1F,EAJApS,EACAC,EACAqD,EACApH,EAlBFkgO,KAQAv0H,GA8EoB;4BACtB,MArEI3rG,EACAkW,EAJApS,EACAC,EACAqD,EAjBF84N,KAQAv0H,GA+EoB;4BACtB,MAvEIvkG,EACApH,EACAkW,EAJApS,EACAC,EAhBFm8N,KAQAv0H,GAgFoB;4BACtB,MAzEI5nG,EACAqD,EACApH,EACAkW,EAJApS,EAfFo8N,KAQAv0H,GAiFoB;4BACtB,MA3EI7nG,EACAC,EACAqD,EACApH,EACAkW,EAnBFgqN,KAQAv0H,GAkFoB;4BACtB,MAxEIz1F,EAJApS,EACAC,EACAqD,EACApH,EAlBFkgO,KAQAv0H,GAmFoB;4BACtB,MA1EI3rG,EACAkW,EAJApS,EACAC,EACAqD,EAjBF84N,KAQAv0H,GAoFoB;4BACtB,MA5EIvkG,EACApH,EACAkW,EAJApS,EACAC,EAhBFm8N,KAQAv0H,GAqFoB;4BACtB,MA9EI5nG,EACAqD,EACApH,EACAkW,EAJApS,EAfFo8N,KAQAv0H,GAsFoB;4BACtB,MAhFI7nG,EACAC,EACAqD,EACApH,EACAkW,EAnBFgqN,KAQAv0H,GAuFoB;4BACtB,MA7EIz1F,EAJApS,EACAC,EACAqD,EACApH,EAlBFkgO,KAQAv0H,GAwFoB;4BACtB,MA/EI3rG,EACAkW,EAJApS,EACAC,EACAqD,EAjBF84N,KAQAv0H,GAyFoB;4BACtB,MAjFIvkG,EACApH,EACAkW,EAJApS,EACAC,EAhBFm8N,KAQAv0H,GA0FoB;4BACtB,MAnFI5nG,EACAqD,EACApH,EACAkW,EAJApS,EAfFo8N,KAQAv0H,GA2FoB;4BACtB,MArFI7nG,EACAC,EACAqD,EACApH,EACAkW,EAjBF+pN,KAQAE,GA0FoB;4BACtB,MAlFIjqN,EAJApS,EACAC,EACAqD,EACApH,EAhBFigO,KAQAE,GA2FoB;4BACtB,MApFIngO,EACAkW,EAJApS,EACAC,EACAqD,EAfF64N,KAQAE,GA4FoB;4BACtB,MAtFI/4N,EACApH,EACAkW,EAJApS,EACAC,EAdFk8N,KAQAE,GA6FoB;4BACtB,MAxFIp8N,EACAqD,EACApH,EACAkW,EAJApS,EAbFm8N,KAQAE,GA8FoB;4B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C;;;;;;;;;;;;;;;;;;;;;;;;;;;;kClZuDHE;kCAYAE;uBApHN;;;;;;;;;;;;;;;;;0BAkII;8CAAuB;2BADvB;;;2BADSpxL;;8CgLjGL+xI,WhLiGKs/C,YAAM;;mCAANzrN,IgLjGLisK,ahLiGKj0D,oCAEkC;;;;;;;;;;0BAG7C;;;;;;;;;mC2JmEQkvC;4C3JlEOvvF;qCAAU;0DAAgB,iBAA1BA;sCAAU;;sCAAVv9B;;yDgLvGT+xI,WhLuGS5M,YAAM;;8CAANvlI,MgLvGTiyI,ahLuGSj0D,oCAA6C,EAAE;;;sB7B3H1D6nB;sBI4HFwV;sBsexDgB;uBmC7EL;;uBCEA;;;;;;;uBCDE;;;;uBCGG;;;;;;;;;;uBCJL;;;;uBCCE;;;;;;;;;;;;;;;;uBCDF;;uBCFA;;uBCEA;;uBCAA;;;;uBCAA;;;;;;;;;;;;;;;;;;;;;;;;;;uBCAA;;uBCCD;;;uBCDC;;;uBCCE;;uBCDF;;;;;;;;;;;uBCAO;;;;;uBCAP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sB1hBoIXD;sBJ5HExV;sB+hBVN;;sBAwPG;;sB/hB7OGC;sBI4HFwV;sBADAD;sBJ5HExV;sBgiBVN;;sBtD+EoB;uBsDrEd+rF;2DAA4C/jO;sBAwC/C;;sBhiBvCGi4I;sBI4HFwV;sBADAD;sBJ5HExV;sB8BVN;;sB4c+EoB;uB5cxEC,iCsMwDjBzsE;uBtMxDiB;;;;;;;;;;;;;;;;wCA+EJ,uBAFT+4J,IA/CFL,SAiDyB;yBA/E3BD;wBAgGS,qB+LzFTx4J;;;;wB/L4F+B;;0BAArB,gB+L5FVA;;;0B/L4F+B,gB+L5F/BA;;;sB6QiEgB,I5c+Bd+4J;;;;;;;;;wCAES,+BAAwB;;;;;;;;;;0BACxB,uBAHTA,2BAGqC;;;;;;;;;;0BAC5B;gDAJTA,6B+LhGF/4J,a/LoG0E;sB4cnC1D;uB5cqCdg5J;uBAgCE3iE,mC8L0aFt5F;uB9LvaAk8J,oBAzCAF;8BAwFFhyL;sB4cvHgB,I5c2DZmyL;;;;;;;;;wCAsES,4BAAsB;sB4cjInB;uB5cmIZC;iCAAQC,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j6P;gCA0rBxB,WFn2FuBi6P;uCAEb;;gCEg3FV,IF/2FgCC,KE+2FhC,WAzsBwBl6P;gCAysBxB,WF/2FgCk6P;;gCEy3FhC,IFv3F8BC,KEu3F9B,WAntBwBn6P;gCAmtBxB,WFv3F8Bm6P;;gCEi4F9B,IF/3FqCC,KE+3FrC,WA7tBwBp6P;gCA6tBxB,UF/3FqCo6P;;gCEy4FrC,IFv4FqCC,KEu4FrC,WAvuBwBr6P;gCAuuBxB,WFv4FqCq6P;uCAE/B;;gCEo5FN,IFn5FQC,aEm5FR,gBAtvBwBt6P;gCAsvBxB,eAtvBwBA,UF7pEhBs6P;;;+BEoqER,IFl3EWp9B,GEk3EX,gBAPwBl9N;+BF12EU,QE02EVA,UF32Ebk9N;+BAEP,WEy2EoBl9N;+BFz2EpB;;wDEy2EoBA;;qCFt2ElB,WEs2EkBA,gBFt2ElB;;+BAGF;;wDEm2EoBA;;qCFj2EpB;qCAEA;qCAEA,eE61EoBA;;+BA+CxB;gCF14EgCrmB;iCE04EhC,WA/CwBqmB;+BF11ElB,iBE01EkBA,OF31EQrmB;+BAC1B,UAD0BA;;+BEq5EhC;gCFl5E8Cm1H;iCEk5E9C,WA1DwB9uG;+BFv1ElB,YEu1EkBA;+BFv1ElB,UADwC8uG;qCAI1C;;+BE85EJ;gCF75EgCqtH;iCE65EhC,WA1EwBn8N;+BFl1ElB,iBEk1EkBA,OFn1EQm8N;+BAC1B,UAD0BA;;+BEw6EhC;gCFr6E8Co+B;iCEq6E9C,WArFwBv6P;+BF/0ElB,YE+0EkBA;+BF/0ElB,UADwCu6P;;+BEg7E9C,IF76E2B7tO,OE66E3B,WAhGwB1sB;+BAgGxB;iCF56EU,eAlXRw2P,cAiXyB9pO;;;wDAEH,UAFGA;iCEo7E7B;;+BAIE,IFr7EyCC,OEq7EzC,WA3GwB3sB;+BFz0ElB,YEy0EkBA;+BFz0ElB,UADmC2sB;;+BE+7EzC,IF77E2BC,OE67E3B,WArHwB5sB;+BAqHxB,UF77E2B4sB;;+BEu8E3B,IFr8EyCC,OEq8EzC,WA/HwB7sB;+BFr0ElB,YEq0EkBA;+BFr0ElB,UADmC6sB;;+BE+8EzC,IF78EiB2tO,IE68EjB,WAzIwBx6P;+BAyIxB,aF78EiBw6P;;+BEu9EjB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Xj6I;+BF9BZs6I;;kC,OE8DHZ,4BA7C+CI,QAATC;;8BFXxC,UEwBiB/5I;;iCFxBbu6I;;;mDALClma;4CAS0C,wBEoBnB4la;mCF7BvB5la;;;;8Bne0gBC;mCmergBFkma,eAEwB,wBEsBAN;;+BFlBxBO;gCEKEtC,uBAakC8B,YAbAD,QAASD;+BFJ7CO;;;iDAZChma;0CAKDkma,wBAMAC;iCAXCnma;;;4CE6BY2rR;uCFjBbq6I;;;wDAZChma;;mDAoBQ,aApBRA,ME6BY2rR;kDFjBbq6I;wCAZChma;;;;kCEqCW62H;qCFKd+sS;;yC,OE1BIC,6BAAkC6B,QAASD;uCFhB5Czla;uCEqCW62H;;;kCAfU9/N,cAAR0gQ;8BAKX;uCF3BFz3J;uCEsBay3J;uC1dYhBslQ;uC0dPK;yCALmBhmgB;;2C,OANpB8sgB,6BAAkC6B,QAASD;;;0CAmCf,mBFnD7Bzla;0CEoD+B,mBFpD/BA;8BEiDa;;;yC,OAjCZ6ja,6BAAkC6B,QAASD;uCFhB5Czla;uCEgBwBqtJ;;;;;mDAqCH3N,mBAAL/6P;qCAxDnB4ghB,iBFGGvla,IEqDgBr7G,IAAK+6P;;0BApC1B,UA0C6C,0BA3ChB2N;0BA2CgB,8BF3DxCrtJ,iBE2D8E;uBAlDnF;iCA0F4BqtJ,UAAWlzL;0BACvC;iCAD4BkzL;2BAC5B;iCAD4BA;0BAC5B;iDHtGSrtJ;;2BGsGT;oCAQoB,IAATuzJ,eAAS,gBATmBp5L,IHrG9B6lC,IG8GEuzJ;0DH9GFvzJ;;kCGgHI62H;qCH5FXorS;uD,OGiFIC,4BAAiC/nc;uCHrG9B6lC;uCGgHI62H;;;kCARU9/N,cAAR0gQ;8BAKX;uCH7GKz3J;uCGwGMy3J;uC1dlEb8nQ;uC0duEE;yCALmBxogB;yD,OAHjBmrgB,4BAAiC/nc;;;;uCAwBR,YH7HtB6lC;;yCG8HwB,YH9HxBA;yCGuHP;2D,OAlBIkia,4BAAiC/nc;2CHrG9B6lC;2CGqGmBqtJ;;;;iDA0BL3N,iBAAL/6P;qCAhIhB4ghB,iBHCOvla,IG+HSr7G,IAAK+6P;;8BAGC,oCA7BI2N;8BA6BJ,8BHlIfrtJ,kBGkIoD;uBAvH7D;iCAiIiBs0N,UAAWyvM;0BAC5B;+BADiBzvM;2BAEbtyE,I1dvGFw9Q,M0dqGelrM,a1dxGfyoM;2B0d2GEhxZ,M1dvGF0zZ,M0doGenrM,a1dxGfyoM;2B0d8GE,2BALA/8Z,gBADas0N;2BAMb;;;;iCANaA;0BAMb;;6BAwBE,UA9BWA;6BA8BX;8BACqB;;4DAAbjnE,UA1Baq4Q,QAAwBD;;wCA2BlC,YA/Bbzla;6BA6BE,IAlBAuf;;qCAEc,YAbhBvf;;2BAKA;4BAUE;;wCAfFA;6BAWEuf;8BAIA;;kC,OA1IAskZ,6BA+HqB6B,QAAwBD;gCAJ/Czla;;gCAcgBsia;gCAfQyB;;;4BAwBtB;;6BAZAxkZ;8BAYA;;kC,OAlJAskZ,6BA+HqB6B,QAAwBD;gCAJ/Czla;gCAsBe62H;;0BAtBnB;2BAGIhxO;4BA8BF;8BA7BIynY;uCA6BwCtrI,IAAIziI,M,iBAAJyiI,IAAIziI,MAjC9Cvf;8BAWEuf;0BAsBJ,UAjCEvf,IACAgiJ,IACAj2I,MACAlmH,IAiCkB;uBAtKtB;iCAyKgByuU;0BAChB;+BADgBA;2BAEZtyE,I1d/IFw9Q,M0d6IclrM,a1d/IdgrM;2B0dkJEvzZ,M1d/IF0zZ,M0d4IcnrM,a1d/IdgrM;2B0dqJE,2BALAt/Z,gBADYs0N;2BAMZ;;;;iCANYA;0BAMZ;;6BAsBE,UA5BUA;6BA4BV;8BACqB;;2DAAbjnE,UAxBao4Q,QAAwBC;;wCAyBlC,YA7Bb1la;6BA2BE,IAhBAuf;;qCAEc,YAbhBvf;;2BAKA;4BAUE;;6BAJAuf;8BAIA;;kC,OArIJ8lZ,4BA0HyBI,QAAwBC;gCAJ/C1la;gCAcgBsia;;;4BAOd;;6BAVA/iZ;8BAUA;;kC,OA3IJ8lZ,4BA0HyBI,QAAwBC;gCAJ/C1la;gCAoBe62H;;0BApBnB;2BAGIhxO;4BA4BF;8BA3BIynY;uCA2BwCtrI,IAAIziI,M,iBAAJyiI,IAAIziI,MA/B9Cvf;8BAWEuf;0BAoBJ,UA/BEvf,IACAgiJ,IACAj2I,MACAlmH,IA+BkB;uBA5MtB;iCA+MgByuU;0BAChB;+BADgBA;2BAEZtyE,I1drLFw9Q,M0dmLclrM,a1dpLdirM;2B0duLExzZ,M1drLF0zZ,M0dkLcnrM,a1dpLdirM;iC0doLcjrM;2BhmBpMd;;;;yCAA4Bl/P;kCAAL;6CAAKA;mCAAL,IAAOi4L;mCAEjB,yBAFej4L;mCAGV,aALLzqB,SAGPq1D;mCAEY;;4CAAZgiJ,OADAziQ,WACKoiQ,OACgB;2BAJ3B;;2BAOM,egmB8LJ3hJ,IhmBtMU6U;iCgmBqMEy/M;;;6BAyBV,UAzBUA;6BAyBV;8BACqB;;2DAAbjnE,UArBElzL;;wCAsBC,YA1Bb6lC;6BAwBE,IAjBAuf;;qCAEc,YAThBvf;;;4BAWE;;wCAXFA;6BAOEuf;8BAIA;gD,OAjIA2iZ,4BA0HU/nc;gCAJZ6lC;;gCAUgBsia;;;4BAQd;;6BAXA/iZ;8BAWA;gD,OAxIA2iZ,4BA0HU/nc;gCAJZ6lC;gCAiBe62H;;0BAjBnB;2BAGIhxO;4BAyBF;8BAxBIynY;uCAwBwCtrI,IAAIziI,M,iBAAJyiI,IAAIziI,MA5B9Cvf;8BAOEuf;0BAqBJ,UA5BEvf,IACAgiJ,IACAj2I,MACAlmH,IA4BkB;uBA/OtB;iCAkP2Bo7S,MAAOjhM,IAAK86J,SAAU0rQ,QAASvO;0BAC9C,IAARh7J,QAAQ,OADeh8D;0BACf,GAD2BnmC;2BAMP;qCAL5BmiG,iBAKoDp6G,MAAQ,OAARA,UAA2B;4BAJ/EkhR,U7WqqCiD;;+B6WrqCjDA,UAEgB;0BAHR;2BAOR0C;4BAAQ;8BAPRxpK;uCAO+Bp6G,MAAQ,kBAReo1Q,KAQvBp1Q,KAN/BkhR,UAM2D;0BAAnD,GAR2BjpQ;4BAiB1B;yCATT2rQ,eASgCxO,MAAQ,OAARA,OAAgB;6BAG9C;;gCAZFwO;yCAYyB9hW;kCACrB;2CADqBA;;iDApBoB6hW,gBAoBpB7hW,cApBK3kE,SAwBiB;6BAE/C;;gCAlBAyma;yCAkBuBxO;kCACV;iDADUA,UAPnByO,eAOmBzO;mCACV,iBAAP14Y,MA3BwBvf;kCA2BjB,uBADUi4Z,gBAEjB0O,UACqD;6BAG3D;;gCAhC8B3ma;gCAkC5B;kCA1BFyma;2CA0B0BxO;oC,aAlCmBuO,gBAkCnBvO,aAlCIj4Z;6BA0CpB,eA1CoBA,MAkB5B59B,SAaAm9C;4BAQA;qCAvC4Bvf;;wCAuC5B,gBAvC4BA,IAyCrB,WAzCqBA,IAiB5B+wM;0BAHF;mCAd8B/wM;;mCAc9B;qCANAyma;8CAMwBxO;uCACrB,uBADqBA,wBACmC,GA4B1D;uBA7RL;iCA2TO3jM,UAAW1tU,EAAGgghB,MAAOC;0BAChB;2CAAgB,aAAsB,OAD7BD;2BAEL,oBAAgB,aAAsB,OAF1BC;2BAGZ,mCAHTvyM;2BAGS,IAAZ0yM;2BAEO,eAFPA,eAHcpghB;2BAaV,aAVJoghB;2BAIF;;8BAHEhna;iCAHA8ma,QAGA9ma;iCAME,YANFA,IAQI,WATJgna;0BAIF,qBAa+CjqgB;4BAA1C;;;;;;4BAIqC,SAJnBo2R,YAAU8vO;iCACzBx5f,GAnBNs9f;;;4BreoME;6Bqe/KiD,IAF7Ct9f,GADyBw5f,YAnB/B6D,QAwBwB,kBArBxB9ma;4BAgBG,IAOGl2G,IAAM,YAvBZk2G,OAiBMv2F,GAjBNu2F,QAgBSqtJ;4BAOG,eAANvjQ,IAPuCiT,QAhB7CijG,QAwBmC;0BAXrC;6CAdEgna,qBAGAjqgB;2BfqcA,MAD2Bxd,KAAOm0R,SetclC1zK;0BfgXwB,aAALxgC,IehXnBwgC,IA0B0D;uBAzV9D;;0B,OA2TEk4Z,W1dhSAqH;uB0d3BF;;0B,OA2TErH,W1dlSA6E;uB0dzBF;;0B,OA2TE7E,W1djSAoH;uB0d0UF;;;;;4BAA8B;;6BAHQ,aAGgBr+N,MARpDgmO;6BAS4B,gBALQ,OAIgBhmO,MANpDkmO;6CACqC,OAKelmO,MAPpDimO,sBAQgF;uBAIlF;;;;mCAAoClna;4BAAN;;;6BbvQI,wCauQe+xO,WAAU9wC;6BbvQzB;;6BaiNlC;;gCAsD2DA;gCAAvBjhM;gCAC9B86J;+CAD8B96J;gCA1JlCsma;6BA6JE;;gCAlEJ;kCA+D2DrlO;kCAAvBjhM;kCAC9B86J;iDAD8B96J;kCAhMlCqma;;;qCAwHF;uCAwE2DplO;uCAAvBjhM;uCAC9B86J;sDAD8B96J;uCAxOlComa;2CA4O0C;uBAJ5C;6CAOqC/4Q;0BACrC,8BADqCA,UhmBtXnCq1Q,kBgmBuXoF;uBARtF;6CAWoCr1Q;0BACpC,6BADoCA,UhmB1XlCq1Q,kBgmB2XmF;uBAZrF;6CAeoCr1Q;0BACpC,6BADoCA,UhmB9XlCq1Q,SgmB+XoD;sBCnYjC;2BDkXnB2E;;;;2BALAD;;;;;;sBC5WmB,0BDyXnBE;sBCxXmB,0BD4XnBC;sBC3XmB,0BD+XnBC;sBhNvTgB;uBiNxEG;;;uBhmBAP;;mCAQV7uT;;;;;yDACiD;mCADjDzpJ;4B;8BAAA;;;;;;;;0CAAoB0wE,KAApBC,QAAoBj8I;;wCAAc,QAAdA,cAAc65D;sC0HggBhC;0C1HhgBF7Q,iCAAoBgzF,KAApBh1F;;wCAAsD88d,KAAtD7nY,QAAsD38C;;sCAAQ,QAARA,gBAAQG;;wCAA9D12C,iCAAsD+6d,KAAtD98d;;sCAAuC+8d,KAAvC9nY,QAAuC1hC;;oCAAU,QAAVA,gBAAUE;;sCAAjD3xD,iCAAuCi7d,KAAvC/8d;;;;;;;;;gHACiD;4BADjD,YACiD;0BADjD;;;;;;;;;;2ChFoJNmjI;;;2BgFpJWnV,eAAL1uB;;;;;;qEgH4FEuhC,chH5FFzuH;;oEgH4FEyuH,chH5FFxuH;;kEgH4FEwuH,chH5FFm8V,IACiD;mCADjDxuW;;;;;8CgH4FEsS,ehH5FF9sK;8CgH4FE8sK,ehH5FF9sK;8CgH4FE8sK,ehH5FF9sK,aACiD;8BADjDy6J;;6EACiD;mCADjDG;4BAAoB;sDgH4FlBmS,chH5FF/sK;6BAAuC,qBgH4FrC+sK,chH5FF/sK;6BAAsD,mBgH4FpD+sK,chH5FF/sK;4BAAsD,UAAlCipgB,cAAmBC,UAAeC,QACL;;2BADjDtuW;oCAAKb,YAALS;;;4BAAkC,GAAlCO,gBAAkC;4CAAlCA;4BAAkC;8BAAe,kBAAjDA;8BAAiD,iBAAa,UAA9DA,mBAAiDjlG;4BAAf,QAAG;mCAArCJ;4BAAkC,GAAlCqmG,gBAAkC;sCAAlCA;4BAAkC;8BAAe,UAAjDA;8BAAiD,gBAAjDA;8BAAiD;;;wCAAZ;mCAArCkF;;;;;;;;;;;;;;;;;;;;;sC0HggBE;wC1HhgBF;;;;;;;;;+FACiD;mDADjDj+B;;;;;;;2CAAoB;qEAApBF;;6CAAoB;;;;;0CAAkC;oEAAtDA;;4CAAsD;;;;;yCAAf;mEAAvCA;;2CAAuC;;;;wCAAvC;;;;;;;;qCAAoBqmY;+BAApB,MAAuCC;+BAAvC,MAAsDC;;;;iCAAfE;iCAAnBC;4DAAmBD,cAAeD;8BAAtD;;;;iDAAoBH;;kDAAmBC;qDAAeC,gCACL;mCADjDp0Z;;;;;6BAAsD,egH4FpD8N,ahH5FoDmmZ;;6BAAf,iBgH4FrCnmZ,ahH5FqCkmZ;iEAAehlY;6BAAlC,iBgH4FlBlhB,ahH5FkBimZ;iEAAmB9kY;4BAAnB,iBAC6B;0BADjD;wCAAK61B;0BAAL;;;;;yDACiD;0BADjD;4B;8BAAA;;;;;;;;0CAAoBh5B,KAApBC,QAAoBj8I;;wCAAc,QAAdA,cAAc65D;sC0HggBhC;0C1HhgBF7Q,iCAAoBgzF,KAApBn5H;;wCAAsDihgB,KAAtD7nY,QAAsD38C;;sCAAQ,QAARA,gBAAQG;;wCAA9D12C,iCAAsD+6d,KAAtDjhgB;;sCAAuCkhgB,KAAvC9nY,QAAuC1hC;;oCAAU,QAAVA,gBAAUE;;sCAAjD3xD,iCAAuCi7d,KAAvClhgB;;;;;;;;;gHACiD;4BADjD,YACiD;0BADjD;;;;;;;;;;;;;;;;;;;;;sC0HggBE;wC1HhgBF;;;;;;;;;+FACiD;mDADjDo7H;;;;;;;2CAAoB;qEAApBF;;6CAAoB;;;;;0CAAkC;oEAAtDA;;4CAAsD;;;;;yCAAf;mEAAvCA;;2CAAuC;;;;wCAAvC;;;;;;;;qCAAoBqmY;+BAApB,MAAuCC;+BAAvC,MAAsDC;;;;iCAAfE;iCAAnBC;4DAAmBD,cAAeD;8BAAtD;;;;iDAAoBH;;kDAAmBC;qDAAeC,gCACL;0BADjD;;;;;6BAAsD,egH4FpDtmZ,ahH5FoDmmZ;;6BAAf,iBgH4FrCnmZ,ahH5FqCkmZ;iEAAehlY;6BAAlC,iBgH4FlBlhB,ahH5FkBimZ;iEAAmB9kY;4BAAnB,iBAC6B;0BADjD,SAAsD00G,oBAAK;0BAA3D,SAAuCz+L,sBAAO;0BAA9C,SAAoBsvd,0BAAW;0BAA/B,SASAhuc,OATKguc;gEAAC;0BAAN;;;;;;;;;;;;;;;;;;;;;;;;mCAWAC,cAAcpkhB;4BAChB,SAAIqkhB,gBAAgBrkhB,GAAI,iBAAJA,WAAqC;4BACnD,kBAFUA;4BAEV;;;;;kCAII;mCAHgBszP;mCAATz+L;mCAAbsvd;mCAGM,sBAHNA;kCAGM;mCACC;0DAJMtvd;oCAIN,YAA2B,gBAJZy+L;;;kCAIiC,aAClD;kCAFC,IAKI,kBARYA,OAOV,kBAPCz+L;kCAMG,sBANhBsvd;4BAWA,sBACoE;0BA1BtE,SA4BAG,cAActkhB;4BAAI;8BAAS,2BAAbA,IAAyC;kDAAI;0BA5B3D,SA8BAg4H,UAAUh1H;4BAAI,UAAJA,KAAI,MAAJA,KAAI,MAAJA;4BAAI,mDAAkD;0BA9BhE;;;;;;;mCA8CAwhhB,iBAAiBC;4BAAQ,mCAARA,MAAQ,QAAsC;0BA9C/D,SAgDAC;4BAAsB,OAJrBH,gCAImD;0BAhDpD,SAkDAI,uBAAwB3hhB;4BAE1B,UAF0BA,SAZxB65F;4BAcF,aAF0B75F,SAZxB65F,oBAeoC;0BArDpC,SA0DA+rG,SAAS5lM;4BAAS,eAATA;4BAAS;8BAAsB,eAA/BA;8BAA+B,qBAA/BA;8BAA+B;;;4BAN1C,YAMyE;;;;oCA1DvEwxN;;;;;;oCAAK//C;oCAALS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAAoBivW;kCAAmBtvd;kCAAey+L;kCAStDn9K;kCA6BA0mB;kCAUA6nb;kCAFAF;kCAIAG;kCApBA3sZ;kCAnBAosZ;kCAiBAE;kCA8BA17U;uBAlEU;wC;uBAAA;;sBimB4DR;sBlNYY;uBmNjDhBg8U;uBACAC;uBACAC;uBDmCI,oBAEQxihB,GAAW,OAAXA,oBAAoC;uBAF5C;iCAMKrC;0BACX,QADWA;4BAEC,IAANgF,IAAM,WAFDhF;4BAEmB,gBAAxBgF,MAFKhF;4BAEmB,OAAxBgF;0BADU,yBAC4C;uBAGpD;uBACA;uBACA;;iCAEGwF,IAAI46gB,QAAQ/nhB;0BACd,IAAN2H,IAAM,WADc3H;0BAEvB,SADG2H,MADQwF,IAAI46gB,QAAQ/nhB;0BAEvB,OADG2H,GAEA;uBALK;iCAOM3C,EAAElE,IAAI6B;0BACe,yBADrBqC,EAAElE,IAAI6B;0BACI,yBAAZ,gBADEqC,EAAElE,cACiD;uBARzD;iCAUKqM,IAAIrM,IAAI6B;0BACrB;sDADawK,IAAIrM,IAAI6B;2BACrB,YAAkC,aADrBwK,IAAIrM;0BACqC;uBAX9C;iCAkBKqM;0BACQ,IANIxK,IAMJ,WADRwK;0BAJV,kBAIUA,MALYxK;mCAEpB,cAGQwK;mCAFR,eAGgC;uBAnB7B;iCAqBKjN;0BACb,QADaA;4BAED,IAANyH,IAAM;yCAFCzH,EAEPyH,KACyB,cADzBA,MAFOzH,GAEPyH;0BADQ,yBAE+C;uBA+J1C;sBAQX,cARNyghB;sBlNxLgB;uBkNoNV;uBAAqB;iCAIPj7gB,IAAIrM;0BACvB,cADmBqM,IAAIrM;2BAEE,iDAFNqM,IAAIrM;0BAIrB,SA3NH+mhB,MAuNoB16gB,IAAIrM;0BAKrB;4BA9NH6mhB,MACAC,MACAC,QAgNAQ;0BAawB;wDA/NxBV;2BAgOY,+BAAc,cA/N1BC;2BA+NY,0BAALv5gB;0BAAK,SADLk6gB;4BASc,IAATjtgB,OAAS;4BACb;8BAAY,4BAVbitgB,kBASKjtgB;4BAEJ;8BAVDjN,KAQKiN,OACJ,qBADIA,UAPL3Y;4BASC,gBAFI2Y;0BATY,IAIZw1K,SAAS;0BACb,eADIA,WACe,SALpBy3V;0BAMC;4BALDl6gB,KAGKyiL,SACJ,qBADIA,YAFLnuL;0BAIC,gBAFImuL,SAUX;uBAxB0B;iCAkMF3jL,IAAIrM,IAAI2nhB;0BACzB,IAAN9lhB,IAAM,eADiBwK,IAAIrM,IAAI2nhB;0BACzB,SAAN9lhB,IAEC,2BAHsBwK,IAAIrM;0BACrB;2BAIL,YAJD6B;2BAKa,iBADR+lhB;2BAEQ,eAFRA;2BAGa;yCAPlB/lhB,IASW;0BATL,IAUK,WAVXA,QAWmB,OADJ88G,UACI,WADJA;0BACI,cAPdipa;0BAUQ,SATRC,QANkBx7gB,IAAIrM,IAC3B6B;0BAea,cAVRgmhB,MALLhmhB;;4BAgBuB,eAXlBgmhB,QADAD;6BA0BQ,4BAnBEhmhB;4BAMC;8BAXXkmhB;;8BACAC;;8BAFAF;;8BADAD;8BAnOPN;;4BAoP4B,IAAN7hgB,IAAM,oBAdrBsigB;4BAeW;8BADItigB;;8BAVL7jB;8BACA+pJ,aASW,sBAANlmI;8BAAM,sBAANA;4BACJ,aAVDkmI;4BAca,6BApBvBm8X,QAFAF;4BAuBW,SAtBXC,QACAC,QAFAF;4BAwBW,cAvBXC,MADAD;qCA0BgC;uBAjOZ;iCAmObv7gB;0BACR;sDADQA,MACuB,WADvBA;2BACR;;4DAAJzK;;kCAGAxC;8BACC;gCAAG,0BAJJwC,EAGAxC,IAC+B,WAD/BA,EAC+B;0CAD/BA;;;;;;0BAKF;mCAREwC,EACAkO,SAOF,sBARElO,KACAkO,aAO4C;uBE5enC;uBAIC;;iCAGOi1Z;0BACU,qBADVA;0BACtB,sBADsBA,cACmC;uBAJ1C;iCAOKA;0BACsB;4CADtBA;2BACV,kBADUA;2BAGV,kCAHUA,MACftrC;0BAEK,QAFLA,eAEA4uJ,MAEqB;uBAZX;iCAiCI9gH,IAAIv3I;0B,SAAJu3I,gBAAIv3I,OACe;0BAChC,GAFau3I,SAAIv3I,OAEW;0BAC5B,GAHiBA,SAAJu3I,OAGe;0BAC5B,SAJaA;4BAMsB;sDANlBv3I;6BAMkB,MANlBA;6BAKkB,yBALtBu3I;4BAKR,mBALQA;0BASsB;oDATtBA;2BASsB,MATtBA;2BAQsB,yBARlBv3I;0BAQZ,mBARYA,6BAS0C;uBA1ClD;iCA4CDu3I,IAAIv3I,KAAM,wBAAVu3I,IAAIv3I,QAAiC;uBA5CpC;iCA+CDu3I,IAAIv3I,KAAM,kBAAVu3I,IAAIv3I,YAAiC;uBA/CpC;iCAyFAu3I,IAAIv3I;0BACJ;uDADAu3I;2BAEA,4BAFIv3I;0BAEJ,GAFAu3I,WAAIv3I;4BAOP,sBAPGu3I,SACXmhH,SADe14P,SAEf24P;4BAKQ;8BAEW,IAAN9hhB,IAAM,WAPnB8hhB;8BAQY,SADC9hhB,MATEmpR,SAEf24P;8BASY,cAFC9hhB,IAPb8hhB;8BAWc,QAJD9hhB,MAPb8hhB,iBAFWphH,SACXmhH;8BAQmB,IAAN1yc;;8BAOM,IAANic,MAAM,WAfnBy2b;8BAgBW,SADEz2b,QAhBFs1U,SACXmhH;8BAiBW,cAFEz2b,MAfby2b;8BAkBkB,QAHLz2b,QAfby2b,iBADe14P,SAEf24P;8BAcmB,IAPN3yc,MAOAic;sCAhBFs1U,OASEvxV;0BARF;;4BAuBN,YAxBMuxV,SACXmhH,SADe14P,SAEf24P;0BAsBK,iBAEE,OAzHRV;;4BA4HsB,IAAN3wL,MAAM,SA7BViwE,SACXmhH;4BA6BoB,QADLpxL,QA5BfoxL,SADe14P,SAEf24P;4BA4BoB,UA9BTphH,OA6BIjwE;0BA5BJ,IAkCGC,MAAM,SAnCLvnE,SAEf24P;0BAkCoB,QADNpxL,QAjCdoxL,SAFWphH,SACXmhH;0BAmCoB,UApCL14P,OAmCDunE,MAGK;uBA/HR;iCAkIGn4V;0BAGH,IAANyH,IAAM;6BAHGzH;4BAKA,cAFTyH,kBAGgB,SAHhBA;;2BAIQ,cAJRA,MAI4B,IAPnBzH;0BAGH,gBAHGA;0CAGTyH,IAKC;uBA1IK;iCA8IA0ga,IAAIv3I;0BA5HqB;oDA4HrBA;2BA5HL,eA4HKA;iCCjJhBy4P,WDiJYlhH,SAAIv3I,kBAAyC;uBA9I7C;iCAkKCu3I,IAAIv3I;0BACL;uDADCu3I;2BAED,4BAFKv3I;2BAEL,SADX04P,WACAC;2BAEM,aADNI;0BACM,GAHNL,WACAC;2BAMmB,SAJnB9hhB,MADAkihB,SAHgB/4P,SAEhB24P,SAFYphH,SACZmhH;;2BASmB,SANnB7hhB,MADAkihB,SAHYxhH,SACZmhH,SADgB14P,SAEhB24P;6CAFYphH,OAAIv3I,QAIhBnpR,IAOwD;uBA7K7C;iCAgLG0ga,IAAIv3I;0BACtB,SADsBA,OACD;0BAEL;uDAHEu3I;2BAIF,4BAJMv3I;2BAKd,kBALUu3I,SAGbmhH,SAHiB14P,SAIjB24P;0BACG;4BAII,QATMphH,OAUH,sBAVGA;4BAWD,QAXKv3I;8BAYa,qBAZbA,IAAJu3I;8BAYH;4BAEkB,qBAdfA,IAAIv3I;4BAcP;;2BACJ,mBAAD,SAfQu3I,OAAIv3I,SAtLnBi4P;0BAyLa;2BAaN,mBAhBQ1gH;2BAgBR;4BAAI0hH;8BAGQ,KAhBjBP,WACAC;8BAgBY,KAjBZD,WACAC;2BAiBuB,WAlBvBD,SACAC;2BAsBM;2BACQ,aANLO;0BAOH,SADIjmhB,IA3BGska,SAGbmhH;0BA0BM,gBAFIzlhB,EAxBVylhB,SAkBSQ,SAlBTR;0BAmCM,QAXIzlhB,IANDimhB,OArBQl5P,SAIjB24P;0BAqCM,SAfI3lhB,IACAC,EAvBV0lhB,SAiBSO,SAjBTP;0BADW,IAuCDQ,iBAAmB,YAfnBlmhB,IAvBV0lhB;0BAqDQ,GAzCCM,eA0BCE;4BAeW,IAARC,MAAQ,SAzDJp5P,SAIjB24P;4BA4DwB,QAPXS,QArDbT,SAuBU1lhB,IAvBV0lhB;4BAwDyB,cAlCf3lhB;4BAmCsB,SAnCtBA;4BAmCsB,eA7DfgtR,WA0BPhtR,QA+BGomhB;0BAUL,GAnDCH,YAmDoB,cAzCnBjmhB;0BAvBC;2BAsEa,eA9CdC,IAvBV0lhB;2BAqEwB,MA/BdQ;2BA8BA;2BAJY,kBA1CZnmhB,aA4Ce,SAtEZuka,OAAIv3I;0BAoEP,mBA1CAhtR,SA+CsC;uBAzPtC;iCA2PAuka,IAAIv3I,KAAU,sBAAdu3I,IAAIv3I,OAAkC;uBA3PtC;iCA4PAu3I,IAAIv3I,KAAU,sBAAdu3I,IAAIv3I,OAAkC;uBA6BhC,yBDlSlBw2P;uBCkSkB;iCAWHzhH;0BACjB;4BAAY,iBADKA,OACL,aADKA,QACT7ga;;;;;6BAGH,gBAJY6ga,GAXfwkH;sCDlSA/C;sCCkTK;4BAXP,YAWgC;uBAhBZ;iCAoHAzhH;0BACpB,cADoBA;mCAET,2BAFSA;mCAGf,cAHeA,MAGW;uBAvHX;iCA0HQnja,EAAE4F,IAAI3F,IAAI8nhB,IAAIt+gB;0BAC1C,GADkCxJ,QAClB;0BFkGC,4BA5LjB;0BAEC,cAHsB+nhB,aE0FmBv+gB;0BFtF3B;;6CAJQu+gB,WACnBxqhB;8BAKC;gCANkBwqhB,WACnBxqhB,OADmBwqhB,WACnBxqhB,eADmBwqhB;;;8BAUD,GARlB5khB,QADA5F,iBASkB,aAVCwqhB,WAEnB5khB;gCAQgD;8BACpD;oCATIA;+BASJ,KAVI5F;kDEyF8ByC,IFoG7BiohB;+BAEDC;+BACmB;+BAEZ;+BACA;;sCE1GmBvihB,MAAI3F;+BF0GvB;oCAGP6tH,QE7G0BloH;oCFgH9BwlE,IEhH8BxlE;gCFqH1B;kCAAQ,wBErHgB5F,EFgH5BorE;kCAKY,SA7BRoF;;sCAgCa,UAhCbA,OExF0B5qE,MFgH9BwlE;;6CAxBIoF;;;;;;kCveHE;;;qCueIoB,SADtBA,oBACsB,IEzFgB/mE;gDFwFtC+mE;;;;;qEExFsC/mE;kDFwFtC+mE;;;;;uEExFsC/mE;oDFwFtC+mE;;;+DAIG;qCAkBH29C,6BE9GsC1kH;qCF4GtC4+gB;;;;kCASQ;mCAON,MAhBFA,mBAROJ;mCAwBL,gBAZN78c,QAHI0iD;0DADAu6Z;kCAiBI;oCACC,cArBLx9gB,OAKAsjH;oCAgBK;;gDAxBLg6Z;;;qCA2BK;0CAFIG;0CAEJl1b;sCACE;sDAzBPvoF,KAwBKuoF;wCACE,UADFA;2CAFIk1b,cAEJl1b;;oCAIE;sCA5BPvoF;;sCAFAu9gB;sCAGAp9gB;;sCAJAm9gB;sCAhMmBH;sCAsMnBK;oCA2BK,SA7BLr9gB,OADAH,OAFAu9gB;oCAiCoB,gCA/BpBv9gB,OAFAu9gB;oCAkCqB,4BAnCrBD;oCAmCqB;;kCApBb,UALZ/8c;qCAHI0iD,UAGJ1iD;;8BA/LA,IEiFI9oE,EF+IM,WA3CN6lhB;8BA4CF,SEhJE7lhB,IFuGAuI,OAHAs9gB;8BEnGD,mBADC7lhB,IACe,WADfA,IA3ZF+jhB,gBAyZoC0B,IAElCzlhB,IAE4B;uBA9HZ;iCAiIStC,EAAE4F,IAAI3F,IAAI8nhB;0BACvC,GADmC9nhB,QACnB;0BAAgC,QADbA;4BAI1B;mDAJoBD,EAAE4F;6BAIb,wBAJW5F,EAAE4F;4BAIb;;;;;;;;;;;;;;;;;;8Bze0EZ;;;iCyexEA;0CANuB5F,EAAE4F,YAAI3F,YAAI8nhB;;iCAQjC;0CARuB/nhB,EAAE4F,YAAI3F,YAAI8nhB;;iCAUjC;0CAVuB/nhB,EAAE4F,YAAI3F,YAAI8nhB;4BAW9B,iCAXoB/nhB,EAAE4F,IAAI3F,IAAI8nhB;0BAEvB,iCAFa/nhB,EAAE4F,IAAI3F,IAAI8nhB,OAWY;uBA5I/B;iCAuJA/nhB;0BACpB,8BADoBA,GACpB;0BARA,GAD8BC,QACd;0BAQhB,IAPM,sBAMcD,KANd;;;;8BAEG,kCAIWA,IARUC;;;8BAGrB,kCAKWD,IARUC;0BAKvB,kCAGaD,EARM4F,IAAI3F,MASa;uBAxJvB;iCAsXCkja,GAAG7ga;0BACxB,QADwBA;4BAEnB,SAFmBA,EAEL,OAFE6ga;4BAGhB,SAHgBA,MAGI,OAHJA;4BAKL;wDALKA;6BAKL,SAAVulH,aALkBpmhB;6BAOtB,eADI6khB;6BACJ,QAPsB7khB;4BAStB,gBAFI2C,MACA0jhB;4BAEJ,SAHI1jhB,IACA0jhB,QARexlH,QAKfulH;4BAAU,IAMVxwf,MAXkB51B;4BAUtB,OACI41B;6BAEF;+BANEjzB,IACA0jhB,QAHAD,QAEAzjhB,IACA0jhB,UAHAD,YAMAxwf;4BAE8D,UAb/CirY,MAOfl+Z;0BANQ,yBAcX;uBArYiB;iCAyYek+Z,GAAG7ga;0BACtC,QADsCA;4BAEjC,SAFiCA,EAEnB,OAFgB6ga;4BAG9B,SAH8BA,MAGV,OAHUA;4BAKnB;wDALmBA;6BAKnB,QALsB7ga;6BAKtB,MALsBA;4BAKtB,GAAVomhB,WACAC,QAEuB,OAhrB3BtC;4BA6qBc,IAG+B,SAHzCqC,UACAC,YAIF,eADIxB;4BAEJ,SADIlihB,MAV2Bk+Z,MAM7BwlH,QAGExB;4BAEJ,OAJEjvf;8BAMU,IAANtb,IAAM;8BACV,gBAJE3X,MADAkihB,SAIEvqgB,MANJsb;4BASC,mBANCjzB,MADAkihB;qCAjrBNd;wCAwqBiCljH,MAU3Bl+Z;0BATM,yBAmBX;uBA7ZiB;iCAgbEk+Z,GAAG7ga;0BACzB,QADyBA;4BAEpB,QAFiB6ga,MAEI,sCAFJA,GAAG7ga;4BAdzB,QAcyBA;6BAbpB,SAaoBA;wCA/sBvB+jhB;;+BAmsBG;oCAYoB/jhB;gCAZpB,SACCub;gCAEM,aADNspgB;+BAEJ,qBADIlihB,IAFA4Y,UAWmBvb;+BANhB,SAHH2C,MADAkihB;+BAFD,eAGClihB;;uCALQ;4BAkBqB;gDAJbk+Z,UAAG7ga;0BACX,yBAGgE;uBApb1D;iCAkeN3C,EAAEC;0B,QAAFD,aAAEC;qCAAFD,cAAEC;8BAID;yDAJDD;+BAKC,0BALCC;+BAMC,aAFXmphB,OACAC;+BAEJ,eADI7B;8BAEJ,SADIlihB,MAPQtF,OAMRwnhB;8BAFS,IAIb,MAFIA,iBAEJ;;oCACA3phB;gCACE;iDAHEyH,IAEJzH,EATcoC,KASdpC;kCACE,UADFA;;;8BAGG,mBALCyH,MADAkihB,UAvwBJd,kBAwwBIphhB;4BALgC,OAnwBpCohhB;0BAkwB+B,yBAc9B;uBAjfiB;iCAmfP1mhB,EAAEC;0B,QAAFD,aAAEC;4BAEV,SAFQD,KAEW,OAFTC;4BAGV,SAHUA,KAGS,OAHXD;4BAKE;uDALFA;6BAME,0BANAC;6BAOE,aAFXmphB,OACAC;6BAEJ,eADI7B;6BACJ;uCACWxnhB,EAAGC,EAAGophB;gCACf,SAFE/jhB,MACOtF,OAFPwnhB;gCAGF,UADe6B,eACf;;sCACAxrhB;kCACE;kDAJAyH,IAGFzH,EAFYoC,KAEZpC;oCACE,UADFA;;;wCAEI;4BALN,GAFIwrhB,UADAD;6BAUC,OAfMpphB,EAAEC,EAMTophB;;6BAUC,OAhBQpphB,EAAFD,EAKPophB;4BAYD,mBATC9jhB,MADAkihB,UAzxBJd,kBA0xBIphhB;0BAP2B,yBAmB9B;sBE/yBa,SHOd4/gB;sBGNY,SHOZC;;sBtbTAxva;sBmOwDgB;uB3YsBYjtE;uBAAb8gf;;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAAa9gf,iBAAb8gf;;;;;;6CAAa9gf;;;;;0B,gBAAAA;;;;;;uB8D0jCtB+gf;;;;;;;;;;;;;;;;;;;;;;;;;0BwDhpBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0B;;;;;;;;;;;;0CtH1awB/gf;;;;;;;;;;;;;;;;;;;;;6CyHmvB1BmiC;;;;;;;0BHzUE;;;;;;;;;;;;;;;;;0B,gBtH1awBniC;;;;;;;;;;;;;;;;;;;;;6CyHmvB1BmiC;;;;;;;0BHzUE;;;;;;;;;;;;;;;;;0B,gBtH1awBniC;;;;;;;sB3FiC5BynH;sBJ5HExV;sB4FVN;;+BAGA1zF;sB8Y4EoB;uB9Y/EpB;iCAa4B5mD,EAAUsphB;0BAWlC,IAX6BrphB,IAW7B,sBAXwBD;0BAYrB,qBAZ0BC;4BAchB,IAAPuzE,IAAkB,gBAdAxzE;4BAenB,mBADCwzE,IAduBvzE;8BAiBtB,cAjB2BqphB,cAiBb,gBAjBGtphB,EAclBwzE;gCAIG,QAJHA,YAdoBh2E;gCAC1B;kCAAG,mBADuBA,EAAGyC;oCAGnB,IAAJgD,EAAI,gBAHcjD,EAAExC;oCAIF,KAAnB,WAJ6B8rhB,cAG5BrmhB,eAGC;oCAHG,IAEH,IALmBzF;;kCAOrB;8BAYI;4BACF;0BACF,QAAK;uBAlCd;iCAqCqBqmB,IAAKzoB,KAAMouhB,yBAA0BF;0BACtD;4BAAI,qBADwBE,yBAAX3lgB;4BAGf;;4BAAG,yBAHYA,IAAqCylgB;qCAItB;uCAJJE;uCAII,SAJf3lgB,aAI0C5gB,GAAK,OAALA,YAAsB;qCAC1E,4BALe7H,KAhCtByrD,eAgCiBhjC,OAKoD;uBA1CzE;iCA6CgBA;0BACZ,sBADYA,yBAKkB;uBAO5B;;;;;;;;;;;2CjF0GNgoK;;;uBiF1GM;uBAImB;wC,UAJnB49V;uBAImB;;0BAJnB;;;;;wEuFvCAjjW,cvFuCA3tH;;;6DuFvCA2tH,cvFuCAr7D,OAImB;;iCAJnB1wG;;;;;;;;6EAImB;;iCAJnBA;2EAImB;;iCAJnBA;;;;;mCACE;;6BADF;;;;gDAImB;;iCAMJzX;0BACL,IAAJhD,EAAI,UADKgD;0BAEV,uBADChD;sCAEa,aAHJgD;mCAIL,gBAHJhD,QAIa,aALJgD,KAMI;uBAZA;;0BAeF;2BACG,OGwBMqlC;;4BHzBT;8BAEO,IAAR9E,cAAQ,oBAARA;4BACQ,IAARqqF;4BAAsB,gBAAd,aAARA,SAA+B;uBAlB5B,sBAMfo8Z,aASAC;uBAfe;;;;;yBAJdP;yBAALC;;;;uBAImB;wC;;uBAAA;;;;;;;;uBAgIF;iCAgBXlqhB,EAAEzB;0BACP,6BADOA;+CAAFyB,EAAEzB;;;;0BAQN,uBARMA,GAON,mBAPIyB;0BAOJ;oDA/MJonD,6BAiNM;uBAzBa;iCA4BLvkC,MAAMtf;0BAA0B,kBiGzM1C6mH,cjGyMUvnG,MAAgC,UAA1Btf,GAAoC;uBA5BrC;;;;;;;;;;;;;2CAoFVvD,EAAEzB,GAAQ,sBAAVyB,EAAEzB,EAAmB;uBApFX,eAuFbyB,EAAEzB,GAAI,gBAANyB,EAAc,YAAZzB,GAA0B;sBAvFf;;;;;;;;;;;;;;;;;;;yBGxFSqqC;;;sB2YtBZ,kB9Y8GG;;wCA+GV6hf,0BGvMmB7hf;sBHwFT;;yBqT5DwC+hf;;;;yBrT2KlDI;yBqT3KkDC;;;;;;yBrT2KlDP;;;;yBAvSTrje;sB8Y0EgB;uB9Y8GG;;;mCAsIjBgke,eAAgB/jY;4BAAuB,uBG9N1BqiY,mBH8NGriY,MAA6C;mCAUzDgkY,uBAAwBxogB,MAAOwkI;4BAClC,GADkCA;6BAEzB,uCAFkBxkI;4BAIX;wCAJkBwkI;6BAKtB,8BALexkI,MAIxByogB;6BAES,8BANezogB,MAIxByogB;4BAGG;qDAFH9if,aADA8if,YAEAz3e,OACgE;mCAqBpEuxD,OAAQviF,MAAM0ogB;4BACb,cADaA,QGpQY3if;8BHuQkB,qBAhErCuif,mBA6DOI;8BAG8B;4BAGtC,cANQA,QAMA,gBG1QD7B;8BH2Qc,sBAPb6B;8BAOJ,uCAPF1ogB;4BALa;;6BACuB,eAI9B0ogB,QALZC;6BA/B0CnkY;4BAC9C;8BAAG,6BAD2CA,OAMhBvhH;+BAkB9B;iCAAa;2DAYHjjB,MApCoCwkI;kCAmBtC,0BAnBsCA,OAoC9BkkY;oCAhBZ,WAF6C1ohB,EAE7C,SADAX,EAiBYqphB;kCAVX,kBAR4C1ohB,EAkBjC0ohB;;8BAjCmC,YAHLlkY;uCA4Cf;oCAR7BjiD;uBA5KiB,eAwMT7hG,EAAEuiC,OAA0C,aAA5CviC,IAAEuiC,cAA0D;uBAxMnD,gBAyMRviC,GAAU,aAAVA,aAA+B;uBAzMvB,uBAyMboohB,OADAD;uBAxMa;iCA8MA18Z,YAAYC;0BAC5B,cADgBD,YAAYC;;;;yDA/FtBy7Z,aA+FsBz7Z;;4BAG7B;;;;;2DAlGOy7Z,aA+FU17Z;;0BAOO,sBACYnsG;4BAVD;qCAElBmsG;qCAFkB;;uCAUCnsG;uCAVqB,UAAM,SAElCosG,YAAZD,eAS4B,CAAC;uBAvN7B;iCA0NRA,YAAYC;0BAId;;yDAJED,YAAYC;2BAGb,2BAHaA;0BAEb;wDAFCD,qBAKR;uBA/NgB;iCA+PV48Z;0BACO;qCADPA;2BAEM,SADXC;2BAEqB;sCAAM,gBG1VhBnC,aHyVXn+Z;2BAxBD,iBGjUYm+Z,aAAa9gf;2BHiUzB,eAAsB,WGjUV8gf,aHgUoBz6Z;0BACe;;;;yDA1HzCy7Z,aAyH0Bz7Z;;4BAGjC;;;;;2DA5HOy7Z,aGvMMhB;;0BHwVC;2BAlBD,sBGtUAA;2BHuUf,sBAPmCz6Z;0BAOnC,eACSnrF;4BAGP;;;gCAXiCmrF,YAFE,0BG9TtBy6Z,aHwUN5lf;6BAbN;8BAaMA,WGxUmB8E,IH2TmB,gBG3ThC8gf,aHwUN5lf;4BAEP,iCG1Ua4lf,0BH2UqC;0BAHpC;;6DAFZtsX,SACAC;0BACY,iDAkByC;;uBAGxC;sBAGjB;;;mCAC6B,UGjWDz0H;sBH8W9B,4BAvKWmif;sBAuKmC,QAA9C1je;sB8YpYkB;uB9YoY4B;6CAK5BtpD,GAAI,yBAAJA,EAAmB;uBALS;;0BAOlB;;;;;0ByHqDtB,mBzHnDY;uBAT4B;iCAYTqmB;0B;sCAAAA,iCAA6B;uBAZpB;iCAc5BA;0BACZ;mCADYA,UAFV6ngB,6BALAD,kBAYsD;uBAMxC,sBAvepB5ke;sBAueoB;;;;yBAtBlB0ke;yBAEIC;yBASAG;yBG5XsBtjf;;;yBHuYtBujf;sBASP;;sB5F1eGrxY;sBI4HFwV;sBADAD;sBJ5HExV;sBisBVN;;sBvN+EoB;sBuN7EpB;;;sBvN6EoB;uBuN7EpB;uCAEkB73I;0BAAW,IAAhBk2B,YAAJD,YAAoB,iBAAXj2B,EAALk2B;0BAAU,qBAALl2B,EAATi2B;uBAFT;6CAI4Bj2B;0BAAc;2BAAnB45F;2BAAJC;2BAAL3jE;2BAAJD;2BAAgC,iBAAdj2B,EAAdk2B,GAAS0jE;0BAAU,qBAAL55F,EAAlBi2B,GAAS4jE;sBAEe;;sBjsBG5Bi+C;sBI4HFwV;sBADAD;sBJ5HExV;sBksBVN;;sBAUG;;sBlsBCGC;sBI4HFwV;sBADAD;sBJ5HExV;sBmsBVN;;sBAEA;sBAUW;;sBnsBDLC;sBI4HFwV;sBADAD;sBJ5HExV;sBosBVN;;sB1N+EoB;;;;sB0N7EpB;;;sBAUwD;;sBpsBDlDC;sBI4HFwV;sBADAD;sBJ5HExV;sBqsBVN;;sB3N+EoB;;;sB2N7EpB;;;sBAM6C;;sBrsBGvCC;sBI4HFwV;sBADAD;sBJ5HExV;sBssBVN;;sBAGkB;;sBtsBQZC;sBI4HFwV;sBsexDgB;uB6N5EN;iCAoEK/3B,UAAU9iH;0BACvB,SAAI0gE,kBACF,0BAA4D;0BAD9D,SAGIo2c,MAAMrqhB,EAAGqB,EAAGiU,MAAQ,YAAK;0BAH7B,UADa+gH,UACTpiD,KAGAo2c,MACsB;uBAzElB;iCA2ECh0Z,UAAUpiD,KAAKo2c;0BAAQ,UAAvBh0Z,UAAUpiD,KAAKo2c,MAAkC;uBA3ElD,iBpfyYJD,aof9TFE;uBA3EM,cA8EHvub,WAA2D/7F,GAClE,0BAA4D;uBA/ElD,eAiFF+7F,WAA2D/7F,EAAGK,GACtE,YAAK;uBAlFK,yBA8ER4zE,KAGAo2c;uBAjFQ;wDAgHcvshB,GAAI,UAAJA,EAAI,QAAS;uBAhH3B;iCA8HCu4H,UAAUpiD,KAAKo2c;0BACxB,IAAItnX,EAnBNwnX;0BAmBE,kBAAIxnX,QADK1sC,UAAUpiD,KAAKo2c,MAEmB;uBAhInC;iCAmIHtub,KAAK66J,GAAG52P;0BACf,IAAI+iK,EAxBJwnX,QAwBA,kBAAIxnX,KADGhnE,KAAK66J,GAAG52P,EAEC;uBArIN;iCAuIF+7F,KAAK66J,GAAG52P,EAAEK;0BAClB,IAAI0iK,EA5BJwnX,QA4BA,kBAAIxnX,KADIhnE,KAAK66J,GAAG52P,EAAEK,EAEC;sBnsBNnB8tJ;sBJ5HExV;sBwsBVN;;sB9N+EoB,I+N6PViyY,4B;sBDzRA;;sBxsBxCJhyY;sBI4HFwV;sBADAD;sBJ5HExV;sB0sBVN;;sBhO+EoB;uBgO/EpB;iCAgBa76I;yCACDzB,GACR,UAFSyB,EACDzB,EACF;0BADM,mCADHyB,Ehf4SXy+H;0Bgf3Sc;uBADC,+B7ekCTpzD,MH0QNozD;uBgf9SI4lG;;;;;;;;;;0BAOF;;;;;;;;;mCAPEA;;qCAOqB;qCAAsB,mBAAhBrkO,EAAGzB;mEAAsB;sBhO0DtC;uBgOnDpBwuhB;;;;;;;;;gCAxBE;iCAwBF7gf;;;;iCAxBE,KAwBF/rC;iCAxBE,KAwBFA;iCAxBE,KAwBFD;iCAxBE,KAwBFA;iCAxBE;;8CAwBFF;;;;qCAA8C;sBhOmD1B;uBgOvChBothB,qBAAYrvhB,GAAI,UAAJA,IAAS;uBAEjBsvhB;;0B;0BAAe;;;;;;iCAKK9phB;;iCAAP+phB;iCAAJC;iCAARn+gB;iCAAJD;gCACI,mBADAC,GAAQm+gB;kCACK,kBADjBp+gB,GAAgBm+gB,IAAO/phB;gCAEL,aAFlB4L,GAAIC,IAEc,mBAFNm+gB,GAAID,IAAO/phB;8BADtB;4BAFA,SAK6C;;iCAExBqvE,GAAGF;0B,GAAHE,MAAGF;4BAjBzB;6BAqBgBnhB,KAJSmhB;6BAIfrmE,GAJeqmE;6BAIpBlhB,KAJiBohB;6BAIvBzmE,GAJuBymE;6BAnBWjiE,GAuBvBtE;6BAvBmB+C,GAuBnB/C;6BAvBcqE,GAuBzBvE;6BAvBqBgD,GAuBrBhD;6BArBC;8BAFwBuE,OAAKtB;iDAATD,GAAawB;uCAAbxB;mDAASC,GAALsB;kCAInB,gBAJmBA,GAAKtB;;oCAKxB,gBAL4BuB,GAAbxB;;sCAMlB,4BANkBA,GAAIuB,GAAKtB,GAAIuB;;;yCAuBlCxE,GAKY,MALNqlD,KAJoBkhB;yCAIfrmE,GAOC,MAXWumE,GAINrhB;4BArBhB,qBAuBgBpxD,aAAHD;4BACE,aADFA,EAAGC,GACD,MAHVqxD,KAAWD;8BAFjBhuD,EAF0BmvE,MAAHE;0BAGrB,OADFrvE,CASuC;uBAEvCiqhB;iCAAmB56c,GAAGF,IAAkB,0BAArBE,GAAGF,IAA4C;uBAYlE+6c;iCAAiBn1O;0BACnB,GADmBA;;6BAIZo1O,KAJYp1O;6BAIjBv6S,EAJiBu6S;;uCAK4B1vQ,IAAI5oC;gCACxB,sCADwBA,GAAJ4oC,IACD;4BADvB,mBADhB8kf,KACgB,YADrB3vhB;0BADE,QAG4C;uBAkB9C4vhB;iCAAUn8c;0B,YAAAA;0BACC;;;;;;;;mDAKKpiE;gCACL;kCACA,yBAFKA;;;8BAHL;;4BAEP,SAMF;uBAEFw+gB;iCAAWrhf,IAAc/F;0BAC3B,GADa+F,IAAW,QAAXA,gBAAWypC,aAAX63c;0BACb,SACQl6T,GAAG/qL,IAAI5jC,KAAKwhC;4BACf,mBADUxhC;8BACW,2BAAkB,MADjC4jC;8BACe;2CAEb7qC;8B,IAAKQ,EAALR,YAHL41N,MAGK51N,EAHF6qC,KAAI5jC,aAGGzG;4BA7GhB,eACSyB;6CACDzB,GACR,UAFSyB,EACDzB,EACF;8BADM,mCADHyB,EhfkTXy+H;8BgfjTc;4BADC;4DAyGKj4F,MhfyMpBi4F;6BgflTe;6EA6Ge;0BAL9B,eAOSz5H,MACT,YATa6ohB,WAQJ7ohB,SARkBwhC,MASE;0BAR7B;sDhsBmCIg5H,yBgsB3ByB;uBAErB,iB7e1EFn0F;;;;;;;;;;0B6e4E0B,qCAF9By6J,MAxBA6nT,aA0B8D;sBhO/C9C;;iCgOmDT/6c;0B,SAAAA;0Bha2iBT;;;0CAEa;;;uCACL;4Bga5iBK;6BADTr0E;4CACIm0E,IACR,UAHSE,GAEDF,GACA;6BADK,iBADTn0E;4BACS,kDACL;uBALNuvhB,gDAJAhoT;;;;;;;;;;0BAYK,cA5GTinT,SA4GgB;wDAA6C;;;;;;;;;;0BAG3D;;;;;;;;;mCAXEe;;qCAWmC,0BACM,yBADG3thB,EAAHD;qCAChC,cAhHb6shB,SAgHoB,mBADyB7shB,EAAGC;;mEACwB;;;;;;;;;;0BAGtE;;;;;;;;;mCAfE2thB;;qCAemC;qCACvB,uCAD6B5thB,EAAGC,GACN;;;;;;;;;;0BAGxC,IAEMI;0BAFN,eAGWwthB;2CACAlxb;6CACAD;+CACAoxb;kCACqB;gEAJrBD,GACAlxb,UACAD,GACAoxb;mCACD,wBAHCnxb,GACAD;kCAED,wCAA8D;gCADxD;;2DADLA;gCACK;8BADA;;yDADLC;8BACK;4BADA;;uDADLkxb;4BACK;0BADA;4DADVxthB;2BAFFs/K;;;;;;;;;;;;qCASmB;qCAAyB,uCAAnB7/K,EAAGzB,GAAyC;;;sB1sBjJrEu8I;sBI4HFwV;sByFvIJ;sB6Y+EoB;uB7YtEpB29X;2DATA;;wBASAA;iCAPAC;;;;;;;;;;;;;;;;;;;;;;;;4BwH6gBQ,cxH7gBR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAOAD,aAPAC;;;;;;;;;;;;;;;;;mDAOAD,aAPAC;mDAOAD,aAPAC;;;gEAKiB;sB6YwEG;uB7Y/EpB;iCAEAA;;;6BACE,gCADFA,KACEvrhB;;;6BACA,kC8GuGMq7H,a9GvGN6gB;;;;8BACAzlF;;mCAIF+0d,aAPAD,KAGE9wY;mCAIF+wY,aAPAD,KAGE90d;;;6BACA;;;8CAJF80d,KAIE3wY;mCAGF4wY,aAPAD,KAIEnxY;sEACe;uBAPjB,kBA6Bex6I,GAAI,UAAJA,EAAS;uBA7BxB,aA6BM6rhB;sBAqHH;sB8mBlJH;sBjO+EoB,IiO7EhBC,sB,IAAMlma;sBAAc;sBCAxB;sBlO6EoB;;;;2B3MEHmma;;;;2B6auGFnha;;;;;;;;;;;2BAIMP;;;2BAEFW;;;;;;kCANJd;;;;;;;;;;;mCAIME;;mCAEFY;;;;;;sBAiBf;sBC/MJ;sBnO+EoB;uBmO/EpB;;;;iCA2BO/7C,MAAO+nS;gDAAP/nS;;;8BAKS;+BADMy8V;;+BAAZinB;+BACM,mBADNA;8BACM;4CADMjnB;;gCACN,qBAEF,IADMjua,aACN,UADMA;gCAGN,2BADO0uhB,cAJCzgH;;4BADZ,SAUQ;uBAxClB;iCA0CqB9qT;0BACjB,SAAI+xU,OACC05F;4BACH;;6BAGM;yCANSzra,WAEZyra,iBAI2C5uhB,GAAK,YAALA,EAAU;4BAAlD,mBAEF,IADEA,WACF,OADEA;4BAGF,QAAkB;0BATxB,UAAIk1b,OAWM;sBAGX;sBEzDH;sBAmFG;sBCnFH;sBtO+EoB;uBsO/EpB;iCAIQ3xb,EAAGP,EAAE8e;0BACH,IAAJ9hB,EAAI,WADFuD,EAAKue,KACH,kBADC9e,EACLhD,EACD;uBANL;iCAQSuD,EAAGP,EAAE8e;0BACJ,IAAJ9hB,EAAI,WADDuD,EAAKue,KACJ,kBADE9e,EACNhD,EADQ8hB,IAEL;uBAVT,mBAYW9hB,SAAM,OAANA,CAAO;uBAZlB,eAcQuD,EAAEue,KAAM,kBAARve,EAAEue,IAAW;uBAdrB;iCAsBS9hB,EAAEzB,EAAGyE,EAAE8e;0BACN,mBADD9hB,EAAO8hB,KAEN,eAFCvjB,EAAKujB;0BAEN,kBAFI9e,EACR62D,IACA3tB,IACC;uBAzBP,kBA2Bc3pC,EAAqCuf,KAAO,kBAAPA,IAArCvf,EAAiD;uBA3B/D;uCA+B+C4lH,MAE1CrmG;0BACmB;;2BAJEqtgB;2BAAfC;2BAIa,mBAJbA,cACoCjna;2BAGvB;;2BACT,YADTkna,WADDvtgB;0BAEU,kBALWqtgB,mBAKpBl8S,OADY3/J;uBAlClB;8CA2CMu7c,QAFAS,OAIAR;uBA7CN;;;;;;;;;;;;iCA8DUvrhB,EAAEue,IAAKqhG;0BACb,OADM5/G;mCAGF,OAHEA,KAGM,QADFw8N,GAFFj+M,KAGI,aAHCqhG,QAGLvhH;mCAGJ,IADM4B,EALJD,KAMG,gBADCC,EALFse;;6BAQI,IADAgxD,IAPNvvE,KAOE0shB,KAPF1shB,KAQM,UADJ0shB,KAPAnugB;6BAQI;+BACF,uBATGqhG,QAQL5qC;;6BAKA,eADFv4E,EACE,OADFA;6BADO,gBAJD8yE,IAPJhxD,MAaG;uBA3Ef,YA8DMkugB;uBA9DN,iBA+EazshB,SACD,uBADCA,KACuB;uBAhFpC,UA+EM2shB;sBAqBH;sBlnBpGH;sB4Y+EoB;uB5Y/EpB;yCA4Cez6gB,GAAI,cAAJA,EAFT+gW,UAEa,QAAoB;uBA5CvC;iCA8CWxzW;0BAAI,aAAiCyS;4BAAK;8BAAI,qBAA9CzS,EAAqCyS,GAAuB;kDAAI;0B4MuNjE,qB5M3NJ+gW;0B4M2NI,UAEM;0BADF,e5MxN8D;uBA9C5E;iCAgDgB7sU,GAAG44C,GAAGh/E;0BAClB;4CAAU0hK;qCAAc,qBAAdA,KADQ1hK;uD0MgTMyxH,a1M/S8B,WAA5CiwC,KADEt7H,GAAG44C,MAC2D;uBAjD9E;;;;2BAeE25F;;2BAEA3sG;2BAGAw5E;mCAmDMykE,SAASxtN,GAAI,YAAJA,EAAO;mCAEhBqwhB;4BAAW,mBAAgB,IAALrwhB,WAAK,UAALA,GAAmB,QAAI;mCA1DnDk8K,oBAEA3sG,IAGAw5E,OAmDMykE,SAEA6iU;0BAGG;;uBA5EX;;;;;iCA2FgB9vhB,GAAI,mCAAJA,IAAyD;uBA3FzE;iCA6HkByC,QAAIO;0BAfqB,GAerBA;2BAbZ,MAaYA,cAdNvD;;8BAcMuD;gCAZJhF,EAYIgF,KAZPs2D,IAYOt2D,cAZPs2D,IAAGt7D;;+BAYIgF;iCAVH2oC,IAUG3oC,KAVN+7F,IAUM/7F,cAVN+7F,IAAGpzD;;gCAUG3oC;kCARFy0B,EAQEz0B,KARLoyE,IAQKpyE,KARRk8F,IAQQl8F,cARRk8F,IAAG9pB,IAAG39C;;wCAGV;0BA3BN;;6BACE,gCA+BYh1B,EA/BZL;;;6BACA;;;8CA8BYK,EA9BZ67I;8CA8BY77I,EA9BZo2D;;;6BACA;;;8CA6BYp2D,EA7BZo6I;8CA6BYp6I,EA7BZ+5I;;;6BACA;;;;8CA4BY/5I,EA5BZu6I;8CA4BYv6I,EA5BZq7I;8CA4BYr7I,EA5BZq2D;+EA4BwD;uBA7H9D;iCA+HkBr2D,QAAIzC;0B;0BAlClB,SAkCkBA;;;;;;;;;;;;;;;;;;;;;;;;;8CAlClB,0BAkCkBA;;;;;4CAlClB,0BAkCkBA;;;;0CAlClB,0BAkCkBA;oDAlClB,0BAkCkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAlClBk9I;;;;;;;6DAkCcz6I,EAlCdL;6DAkCcK,EAlCdo2D;;;;;;;0FAkCkB74D;;;;;0CAlClBq+I;;;;;;;;;;6DAkCc57I,EAlCd67I;6DAkCc77I,EAlCd+5I;6DAkCc/5I,EAlCdq2D;;;;;;wFAkCkB94D;;;;wCAlClB48I;;;;;;;yDAkCcn6I,EAlCdo6I;yDAkCcp6I,EAlCdq7I;;;;;sFAkCkB99I;;;kCAlClB;;;;oDAkCcyC,EAlCdu6I;;;;;mFAkCkBh9I;;yCAlClB,kCAkCkBA;;uCAlClB,iCAkCkBA;0BuHgZd,sBvHlbJ,0BAkCkBA;0BA3BqB;mCAEjC,IADMP,WACN,oBADMA;uCAEEzB,WAAHs7D,iCAAGt7D;;iCAEC2tC,aAAHozD,kCAAGpzD;;iCAEClU,WAAH29C,aAAH8pB;gDAAG9pB,IAAG39C,GAoB0C;uBA/H9D,kBAiIiBz0B,GAAI,UAAJA,EAAU;uBAjI3B,2BAiIqB,YAAM;uBAjI3B;iCAqIYA,EAAGP;0BACT,GADMO;4BAGF,IADMhB,EAFJgB,KAGM,+BAHHP,EAECT;6BAFJgB;4BAKW,IADJ81D,GAJP91D,KAIG61D,GAJH71D,KAKW,iBALRP,EAIIq2D;4BACF,2BALFr2D,EAIAo2D;6BAJH71D;4BAOgB;6BADNyghB,GANVzghB;6BAMM4iJ,KANN5iJ;6BAMEmoH,KANFnoH;6BAOgB,iBAPbP,EAMOghhB;6BACA,iBAPPhhhB,EAMGmjJ;4BACF,0BAPDnjJ,EAMD0oH;6BANFnoH;4BASW,IADJC,EARPD,KAQIrD,EARJqD,KASW,iBATRP,EAQIQ;4BACD,4BATHR,EAQC9C;0BAGN,yBAAe;uBAhJzB;iCAkJgCq+gB;0B,gBACvBoS,UAAqBpthB;4BACxB,GADwBA;8BAGpB;iCAHoBA;+BAGZ,aAHTothB,UAEOpuhB;+BAEC,iBALeg8gB,UAIlBv+gB,EAJkBu+gB;8BAKf,8BALeA,UAIlBv+gB,EAJkBu+gB;+BACFh7gB;8BAMO;+BADlB81D,GALW91D;+BAKf61D,GALe71D;+BAMO,iBAN5BothB,UAKUt3d;+BACG,iBANbs3d,UAKMv3d;8BACO,kBAPUmld;+BACFh7gB;8BAQ6B;+BADrCyghB,GAPQzghB;+BAOZ4iJ,KAPY5iJ;+BAOhBmoH,KAPgBnoH;+BAQ6B,iBARlDothB,UAOa3M;+BACqB,iBARlC2M,UAOSxqY;+BACU,iBARnBwqY,UAOKjla;+BACS,iBATS6yZ;8BAST,kBATSA;+BACFh7gB;8BAUqB;+BADhCC,EATWD;+BASdrD,EATcqD;+BAUqB,iBAV1CothB,UASUnthB;+BACiB,iBAV3BmthB,UASOzwhB;+BACM,iBAXUq+gB;8BAWV,kBAXUA;4BAatB,yBAAgB;sBAExB;;yBAlCMiS;yBAFAD;yBAQAG;yBAaA3nY;yBAfA0nY;yBAFAJ;sB4YlDY;uB5YkFlB;uCAW6CQ;8BAAJ3whB,WAApB4whB;6BAAwBD;2BAEI,MAFJA,sBAED7whB;;qCAFHE;0BACvC,UADmB4whB;uBAXrB,kBAgBWp8e,MAAM10C,EAAEzB,GAAI,mBAANyB,EAAEzB,GAARm2C,MAA8C;uBAhBzD;iCAkBaA,MAAM10C,GAAI,uBAAJA,GAAN00C,MAAyC;uBAlBtD,cAoBUA,MAAMx0C,EAAEC,EAAEqD,GAAI,kBAARtD,EAAEC,EAAEqD,GAAVkxC,MAAkD;uBApB5D,gBAsBYA,MAAMx0C,EAAEsD,GAAI,oBAANtD,EAAEsD,GAARkxC,MAA+C;uBAtB3D;iCAwBgBnxC;0BACd,UADcA;0BACd,UAAoC,IAAP6gB,aAAO,OAAPA;0BAAqB,YAAE;sBAG/C;sBmnB7LT;sBvO+EoB;uBuOrEP;iDAQS,QAAE;uBARX,6BAUO,sBAA2B;uBAVlC,mCAYgB,sBAAoC;uBAZpD,0BAcS,QAAC;uBAdV;8BAQHgtgB,UAEAC,OAEAC,aAEAC,WAdJJ;uBAAO;;0BAkBH;0CAAsCpzhB,GAAI,kBAA7B2zhB,KAAenuhB,EAAUxF,EAAa;uBAlBhD;;;0BA8CH6zhB;0BAAYz6f;0BAAO06f;0BAAgBv+c;0BAAKw+c;0BAAQC;0BACrDC;0BAAgB7ua;0BAAS8ua;0BAAe1lf;;;0BAE3C,GAF2CA,QAAQypC,IAARzpC,aAAQypC,aAAR5hE;0BAE3C;+BAFsEisF,eAAb6xb,WAAa7xb;;+BAAb6xb;0BAEzD,oBAHQN;0BAGR;;4BAHwDG,iBAC5BE,aAD4BF;2BAMxD;;0BAWY;kCAXRK;kCAN4CN;kCAA5B36f;kCAAuBm8C;kCAKvC6+c;kCALIP;kCAAmBC;kCACCI;kCAAe79gB;kCAgB/B,MAhBO+uG,QJjCfw+T;kCIiCqDuwG;;kCAAtDF,eAoBF;uBAnEU;uCA6ERj0hB;8BADoB6zhB,oBAAmBt+c,aAAPn8C;iCAChCp5B,IADoB6zhB;mCAEA,kBAFYz6f,OAChCp5B;mCAC4C,kBAFLu1E,KACvCv1E,IADoB6zhB;uBA5EZ;uCAoB4C5xhB;;2BA4DnC6xhB;2BAAgBv+c;2BAChC/wE,EADgBsvhB;;0BA5DH,MA4DmBv+c,OA5DnB,EA4DmBA;0BA5DuB,WAA7Bo+c,KAAenuhB,EAAUvD;yDA6DnDuC;uBAjFO;;8BAoFGsvhB,wBACVtvhB,EADUsvhB;;yDACVtvhB;uBArFO;wC,IA4FGiwhB;uBA5FH;iCA8FKjvhB,EAAEivhB,WAAY,WAAZA,UAAY,QAAwB;uBA9F3C;iCAkGCjvhB,EAAE6Q;0BAAQ;kCAAV7Q;;;;;;;;kCAAE6Q;kCAAF7Q;;;wCAA0B;uBAlG3B;iCA4GGA,EAAE4/G;0BAAU;kCAAZ5/G;;;;;;;;;kCAAE4/G;kCAAF5/G;;wCAA8B;sBAMY;sBC5H1D;sBxO+EoB;;;;2BwO4EdqvhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAQH;sBCnKH;sBAmEG;sBpnBnEH;sBA8NG;sBqnB9NH;sB1O+EoB,I0O5EdW,mBAAOvzhB,GAAI,OAAJA,CAAK;sBACf;sBpnBJH;sB0Y+EoB;uB1Y5EE;wC,O7DIlBqrH;uB6DJkB;;;;;;iCAgCV9nH;0BAER,SAFQA;4BAEe,IAALrD,EAFVqD,KAEe,gBAAIhD,GAAK,UAALA,EAATL,EAAoB;0BAAiB,IAAL+E,EAF1C1B;0BAE+C,OAAL0B,CAAM;uBAlCtC,mBAuCPjF,GAAU,UAAVA,EAAgB;uBAvCT;;;kCA2CRA,EAAUgD;2BACd,SADIhD,MAGA,IADGE,EAFHF,KAGK,qBAHKgD,EAEP9C;2BAGH,IADO+E,EAJPjF;2BAKA;4CACOO;qCACQ,qBAHR0E,EAEA1E,GACQ;qCACP,UADAk8D,IACA,WAREz5D,EAOC9C,GACC,EAAE;uBAnDN;iCAqDRF,EAAUgD;0BAClB,SADQhD,MAGJ,IADGE,EAFCF,KAGJ,kBAHcgD,EAEX9C;0BAGH,IADO+E,EAJHjF;0BAKJ;2CACOO;oCACQ,qBAHR0E,EAEA1E,GACQ;oCACN,mCARKyC,EAOH9C,IAAHu8D,IACQ,EAAE;uBA7DN,uBAqDdo3d,QAZAD,OAFAD;uBAvCc;;;;;;;;;;;sBAkcnB;sBqnBrcH;sB3O+EoB;;;0B2OxDhB;;;;mCAEEa,eAAejyhB;4BACjB,yBAJEgyhB,aAGehyhB,EAC0C;0BAH3D,SAKEkyhB;4BAA8B,sDAAwB;0BALxD;;;;;;;mCAuBEC,kBAAoB3qa,IAAIg9G;4BAEd;;;6BAEF;6BACG;6BAJb;4BAIa,SAEP4tT,QAAQpyhB;8BAAI,oCAHd+wE,IAGU/wE,EAA0B;4BACtC;wEADIoyhB;6BAKG,qBARLrhd;6BAOF;;;gCAVEs+c;gCACAz6f;gCACA06f;;mCAEAC;;;;;;6BAUK,GALLjvgB;6BAMW,iBAhBOknG,IAAIg9G,GAUtBlkN;6BAMW;;6BACA,SADXmkC;4BAED,mBAHCnhC,GAEA+ugB,UAEF;4BAAsD,UAH7C50hB,EAVP2whB,UAcU;0BA3Cd,SA6CEkE,cAAgB9qa,IAAIg9G;4BACtB;8BAAM,IAGJvhO,IAHI,kBADYukH,IAAIg9G;kCAEVz0N;yDACR,sBADQA;4BAGR,UADF9M,IACQ;0BAlDV,SAoDEsvhB,2BAA6Bvld,IAAKw6C,IAAIg9G;4BAE5B;;;6BAEF;6BACG;6BAJb;4BAIa,SAEP4tT,QAAQpyhB;8BAAI,oCAHd+wE,IAGU/wE,EAA0B;4BACtC;wEADIoyhB;6BAKG,qBARLrhd;6BAOF;;;gCAVEs+c;gCACAz6f;gCACA06f;;mCAEAC;;;;;;6BAUK,GALLjvgB;6BAMM,eAhB0BknG,IAAIg9G,GAUpClkN;4BAMM;qCAhBqB0sD;qCAgB3B/pE;;uCACO,8BACQ,SADEqd;uCAEd,mBAJHgD,GAGI+ugB,UAEF;uCAAsD,UAHhC50hB,EAXxB2whB,UAegB;0BAzEpB,SA2EEoE,uBAAyBxld,IAAK88C,SAAQtC,IAAIg9G;4BAC5C;8BACE;+BAMAvhO;gCANA;2CACYxF,EAAGgD;oCAAK;6CAHKusE,IAGbvvE,WAAsBA,GAAQ,qBAA3BgD,EAAmBhD,GAAa,EAAC;kCAHV+pH;kCAAIg9G;8BASxC,OADFvhO;kCAFU8M;;8BACD,kBAPqB+5G,SAOrB,eADC/5G,IAGL;0BApFP,SA4aI0ihB,cAtVajra,IAAIg9G;4BAET;;;6BAEF;6BAER;;+CAJE5vM,MACA06f,eACAv+c;6BAKK,GAJLzwD;6BAKW,iBAVEknG,IAAIg9G,GAKjBlkN;6BAKW;;6BACA,SADXmkC;4BAED,mBAHCnhC,GAEA+ugB,UAEF;4BAAsD,OAH7C50hB,CAIV;0BApGD,SA8aIi1hB,oBAxUiBlra,IAAIxmH;4BACN;qDADEwmH,IAAIxmH;6BACN;;6BACX,6BADJvD,EAAG2whB;4BACC,OAAJ92d,GACH;0BAzGD,SAgbIq7d,gBArUanra,IAAIxmH;4BACrB;8BAAwC;;;+BAC5B,6BADkCvD,EAAG2whB;8BACrC,OAAJ92d,GACD;4BAFM,sCADIkwD,IAAIxmH,SAGd;0BA9GP,SAkbI4xhB,UAlUSpra,IAAIxmH,GAAI,kBAARwmH,IAAIxmH,WAA4C;0BAhH7D,SAobIy/B,MAlUK+mF,IAAIxmH;4BAAI,wBAARwmH,IAAIxmH,GAAI;0E,cAAoD;0BAlHrE,SAqHIgvhB,UAAU6C;4BACZ,IAAI7yhB,EADQ6yhB;4BACZ;yDAAI7yhB,EACoC;0BAvH1C,SAyHI+vhB,gBAAgB+C,cAAcD,WAAWp1hB;4BACnC,IAAJuC,EAAI,UADwB6yhB;4BAEhC,6BAFkBC,cAAyBr1hB;4BAE3C,OADIuC,CAEH;0BA5HH,SA2LM61b,MAUEk9F,YAAWC;4BACf;;6BAlDE,WAiDaA;6BAjDb,UAiDED;4BAjDF,SAkBEI;8BASE;+BANAC;+BADAC;+BADAC;+BAQA,iBANAF;8BAIA;uCANAE;;wCAMA;0CALAD;0DAMI,iBAVPR,aAU8B;;4BAGvB;+CAboBK;6BAcjB,mBAd6CD;6BAuCjDO,aANMR;6BAOX3D,WAxCDwD;6BAyCS;+CADRxD;6BAGM;6BACG;6BAEX;;;gCANEA;gCACAz6f;gCACA06f;gCACAv+c;mCACAw+c;;;;;;6BAKK,GAJLjvgB;6BAIK,YAhBLyygB;6BAqBA,mBADSU,eAjBT7ta;6BAoBF,6BAJI8ta,QAPFpzgB;6BAWF;qCAEEqzgB,gBAAgBh0hB;8BAAI,kBAAJA,EAtBhBimH,MAcAnhE,QAQ+B;4BAFjC,SAGEmve;8BACa,IADc3whB,aAAPqd,eACP,SADOA;8BAEnB,mBAZDgD,GAWE+ugB,UAEF;8BAFa;+BAGF,iBAxBNmB,gBAoBsBvwhB;+BAIhB;+BACG,mBAzBTuwhB,gBAHAD;+BA4BS;8BAEd;gCAHEnhd;gCACAyhd;gCALkBvzgB;yCAO2BA,MAAMrd,IAAIswhB;kCAClC,mCAD8BtwhB,IAAIswhB;kCAC9C,oCADoCjzgB,SACe;8BAPjD,IASXwzgB,qBA3BFxE,oBAFAD;8BA8BF,yBA1BEE,OAyBEuE;8BACJ,OA1BEvE;4BAYF,UAEEoE,gBACAC,mBAemC;0BA9O3C,iCA2LM/9F;0BA3LN,SAiPIk+F,kBAMEvsa,IAAK0ra,UAAWD,WAAWtzhB;4BACjB;6BAAVq0hB;8BAAU;6DADLd,UAAWD;4BACN,eAEiBrta,MAAItlG;8BAAa,kBAH5CknG,IAG4C,WAHjB7nH,EAGAimH,OAAItlG,MAA0B;4BAA3D;8CAFE0zgB;6BAEF;;8CAFEA,cACA1zgB,MAAOrd,KAG4B;0BA5PzC,SA8PIgxhB,4BAI8B9tgB;4BAAjC;;;6BACqB;;4BAEE,SAAlBgugB;8B,OA5IFpE,gBA0IE+C,cACAD;4BAEe;gDAJTqB,gBAAsB/tgB;6BAIb;4BACL,KADVuqN,OADAyjT;4BAEU,OAJVrB,aAKS;0BAxQf,SAkRMsB,qBAKClB,gBAA2B/sgB;4BAA/B;;6BACqB;;qCAEhB4pgB,gBAAgBtyhB;8BAClB,IAAIuC,EAFF6yhB;8BAEF;8BAEA,6BALEC,cAEgBr1hB;8BAGlB,6BAFIuC,EAGkB;4BANJ;mCADjBkzhB;6BACiB;;6BASF,mBADQgB,gBATI/tgB;6BAUZ;;6BACL,cADTuqN,OAPAq/S;6BASY,qBAHLuD,iBAEPx9N,SADQ/kP;6BAON,iBAjBYkid;4BAiBZ,sBADe,iBAdjBJ,aAcwC;4BADtC;6CAfYI;6BAchB,sBAdgBA;6BAchB,gBAZEJ;4BAYF;oCAFEwB;oCACAC;oCAMAC;oCAlBAzB,cAmBqD;0BA3S7D,YAkRMsB;0BAlRN,SAqTMI,gBAAkBxqf,IAAmCkpf,UACpDD,WAAW9sgB;4BACd,GAFoB6jB,IAAW,QAAXA,gBAAWypC,aAAX43V;4BAOlB;sDAPqD6nH,UACpDD,WAAW9sgB;6BAMZ;;;;+CAHsBkpgB;6BAMd;6BAER;;gCAZkBhkH;gCRpTtB+T;yCQgU0Dx+T,QAAQ9iH,GAC5B,wBAD4BA,GAAR8iH,QACF;6BAI7B,qBAPrB7vC;6BAMmC,qBAXjBn8C;6BAWpB;;;gCAZsBy6f;;gCAKpBC;;;;mCAEA1ua;;;;6BASK,GALLtgG;4BAKK,SACLqzgB,gBAAgBnvT;8BAAK,kBAALA,GAnBd6vT,UAaF/zgB,MAMuC;4BADlC,SAELm0gB;8BACa,IADqBxxhB,aAAPqd,eACd,SADcA;8BAE1B,mBAJDgD,GAGE+ugB,UAEF;8BAFa;+BAEyC,aAxBvDY;+BA2BC,iBAFOD,gBAJ2B/vhB;+BAMlC;;+BAEqB,mBAJd+vhB,gBAvBQvxgB;+BA2BM;+BAErB;;kCALEkzgB;kCAGAC;kCARyBt0gB;2CAWjBA,MAAMu0gB,UAAUC;oCAEpB,+BAFIx0gB,MAAMu0gB;oCACZ,6BA7BcjggB;oCA8BZ,UAGG,yBALOiggB,UAAUC;oCAInB,oCAJGx0gB,SAMI;+BAMD,YAfXs0gB,cAewB,qBAdxBnwe;+BAeF;2CApBOuue,mBAmBHtiT,OAlBUgkT;8BAmBd,aAzCkB9/f,MAKlBm8C,KA+BEgkd;4BArBG,UACLpB,gBACAc,0BA6B0C;0BAxWlD,uBAqTMD;0BArTN,SA2WIt1b,KAQC81b,MAAM9B,UAAUD,WAAWgC,GAAG9ugB;4BAE/B;sDAFO+sgB,UAAUD,WAAc9sgB;6BAE/B;;;;4BAE+B;qCAJ9B6ugB;qCAC+BT;qCAAZD;qCAGW,WAJHW,KACxBZ;qCAA6CvB,cAGa;0BAvXlE,SAyXIoC;4BAOE1ta,IAAK0ra,UAAWD,WAAY5nH,SAAS1ra,EAAEwmB;4BAKzC;;;mDAL8BklZ,SAAvB6nH,UAAWD,WAAuB9sgB;6BAKzC;4BAGA;8BAJIwtgB;uCAIiBU,UAAU/zgB;gCAAa,kBAR1CknG,IAQ0C,WARL7nH,EAQlB00hB,WAAU/zgB,MAAgC;4BAA/D,QAEiB;0BA1YrB,SA4YI60gB;4BAQE3ta,IAAK/mH,EAAGyyhB,UAAWD,WAAY5nH,SAAS1ra,EAAEwmB;4BAE5C;6BADE6tgB;8BACF;mDAFiC3oH,SAAvB6nH,UAAWD,WAAuB9sgB;4BAE5C,eAG6BkugB,UAAU/zgB;8BAC/B,kBANNknG,IAMM,WANkC7nH,EAKb00hB,WAAU/zgB,MACZ;4BAD3B;8CAJE0zgB;6BAIF;;6BAGoB,mBAPlBA,cAGA1zgB,MAAOrd;6BAIW;;8CARbxC,EAQLkvJ,QAASluI,OACG;0BA7ZlB,eAgagC2zgB,OAAO3zgB,QAAW,OAAlB2zgB,MAAwB;0BAhaxD,SA+ZIC;4B;qCAnBAF;;0BA5YJ;;;6BAqHInF;6BAIAD;;6BAwHAgE;6BAaAE;;;6BA6GA/0b;6BAcAg2b;6BAmBAC;6BAmBAE;0BA/ZJ,SAoaIC,mBAAkB9ta,IAAIxmH,EAAGiyhB,WAAWtzhB;4BACtC,6BADoB6nH;4BACpB;8B,8BAD2Byra,aAAHjyhB,EAAcrB,GACG;0BAra3C,SAuaI41hB,wBAAuB/ta,IAAK/mH,EAAEO,EAAGiyhB,WAAWtzhB;4BAC9C,6BADyB6nH,IAAK/mH;4BAC9B;8B,8BADmCwyhB,aAAHjyhB,EAAcrB,GACG;0BAxanD;;;;6BAoaI21hB;6BAGAC;6BAGAC;6BAEA/C;6BAEAC;6BAEAC;6BAEAC;6BAEAnyf;0BApbJ,SAubE0xE,OAAK1xG,EAAEi7F,KAAKu3b,WAAWtzhB;4BACzB,sBAAyD,OADhCA,CACiC;4BAA1D,2BAAkBlC,SAAO,kBADlBgD,EACWhD,EAAU;4BAA5B,+BADSi+F,KAAKu3b,iBAC6C;0BAxb3D,SA0bEwC,2BAA0BvC,UAAWD,WAAWtzhB;4BAClD;wDAD4BuzhB,UAAWD,aAAWtzhB,EACoB;0BA3btE,IA6bE+1hB;0BA7bF,SA+bEC,mBAAkBzC,UAAWD,WAAWtzhB;4BAC1C;yDADoBuzhB,UAAWD,aAAWtzhB,EACoB;0BAhc9D,SAkcEi2hB,wBAAuBn1hB,EAAGyyhB,UAAWD,WAAWtzhB;4BAClD;yDADyBc,EAAGyyhB,UAAWD,aAAWtzhB,EACoB;0BAnctE,SAqcEk2hB,oBAAmB3C,UAAWD,WAAWtzhB;4BAC3C;wDADqBuzhB,UAAWD,WAAWtzhB,EACoB;0BAtc/D,SAwcEm2hB,gBAAc90hB;4BAAI,iCAAJA,EAAoC;0BAxcpD,SA0cE+0hB,gBAAc/0hB;4BAAI,mCAAJA,EAAoC;0BA1cpD,SA4cEg1hB,oBAAkBh1hB;4BAAI,uCAAJA,EAAwC;0BA5c5D,SA8cE6rP,QAAM7rP,GAAI,yBAAJA,EAA4B;0BA9cpC,SAgdEi1hB,YAAUj1hB,GAAI,6BAAJA,EAAgC;0BAhd5C;;;kCADEgxhB;kCAGAC;kCAGAC;;;;;;;;kCAkBAC;kCAsBAG;kCAOAC;kCAuBAC;;;kCA4WArgb;kCAGAsjb;kCAGAC;kCAEAC;kCAGAC;kCAGAC;kCAGAC;kCAEAC;kCAEAC;kCAEAnpS;kCAEAopS;sBACH;sBCxeH;sB5O+EoB;uB4O/EpB;;mCA4GQxzhB,KAIOzB;gCAAJqlC,MAAIo6E;4BACP;iCADOA;;;;iCAIC4ya;iCAJLjme,YAIKime;iCAJLhtf;iCAAIo6E;;8BAGH,OAHDp6E,IAOC;2CAXJ5jC;mCAeA21B;4BACF,sBAOuB,+BAAiB;4BAPxC,sBAM6C,QAAE;4BAN/C;kDAIgC,QAAE;4BAJlC,sBAGiC,gBAAU;4BAH3C,sBAE8B,QAAE;4BAFhC;;qDAC+B,gBAAU;;;;;;4CAOtC;mCAED2mE;4BACF,sBAOsB,+BAAiB;4BAPvC,sBAM6C,QAAE;4BAN/C;;8BAIsB,IAAM2xI,gBAAc,wBAAdA,YAAyB;4BAJrD,eAG2BjwO,GAAM,aAANA,KAAkB;4BAH7C;8BAEoB,IAAMiwO,gBAAc,wBAAdA,YAAyB;4BAFnD;;8CACyBjwO,GAAK,aAALA,KAAkB;;;;;;4CAOxC;mCAGCy1hB,UAAU/vgB;4BACZ,sBAUsB,+BAAiB;4BAVvC,sBAS6C,QAAE;4BAT/C;kDAOgC,OARpBA,KAQyB;4BAPrC,eAIWmwH;8BACI,GANHnwH,UAKDmwH,QAEH;4DAAU;4BANlB,sBAE8B,OAHlBnwH,KAGuB;4BAFnC;;qDAC8B,gBAAU;;;;;;4CAUrC;;gDHjJe,0BAAiB;gDADM,QAAI;;;4BAF3B,IAAS1oB,WAAT,uBAASA,EAAyB;yCAD7BA,GAAK,iBAALA,GAAmB;gDAD1B,IAASA,WAAT,UAASA,EAAY;;2BAHvC09P;;;uCAEuB19P,GAAK,cAALA,KAAe;;;;;;;sCAFtC09P;mCG6JI7T,WAAS,iBAAW;0CAhBpB4uS,kBAgBA5uS;mCAGF6uS,gBAU6BC,MAC3BC;4BAXQ;;;;;;;;;2CAgBe54hB;8BAAU,kBALjC44hB,KAKiC,WAX9BzJ,gBAWoBnvhB,GAA6B;4BAhB5C;;qCAELovhB;qCACAyG;8CAYoB71hB;uCAAqB,kBAXzCy2hB,gBAWyC,WALjBkC,MAKJ34hB,GAA8B;;qCATlD41hB;qCACAD;qCACA3yf,OAYJ;mCAED61f,oBAU6BF,MAAwBC;4BAVvC;;;;;;;;;2CAmBC54hB;8BAAW,kBAXrBgjC,MAWqB,WATG21f,MASd34hB,GAAoB;4BAnBrB,eAcSA;8BAAU,kBAJoB44hB,KAIpB,WAX5B/C,cAWkB71hB,GAA2B;4BAdpC;;8CAaSA;uCAAmB,kBAXrCovhB,cAWqC,WAHbuJ,MAGN34hB,GAA4B;;qCAT9Cy2hB;qCACAtH;qCACAyG;qCACAD;4CAaJ;mCAED5sa,KAAMlrH;;;6BAQDmlC;6BADA2yf;6BADAC;6BADAzG;6BADAsH;6BADAZ;6BADAzG;2CAgFUnia;8BAAuB,iBAAvBA,GA1EVjqF;8BA0EiC,oCAAsB;;8BAFtD;uCAhFAnlC;;yCAiFK;4DA1EN83hB;iDADAC,uBA2E6D,EAAE;+CAjF9D/3hB,OAMD+3hB;;8BAyDD;;;+BAEI;;kCAFUkD;uCAAR7lT;;oCAKG;;;;;+CAAYjmE,UAAe8oO;qCAG1B;;wCAlETq5I;2CAmEY,iBATPl8S,OAMM8lT,UADwBjjJ,YAALxiU;oCAGrB,aADE60C,MAFG5P,MACHwgb,UAKoB;+BAT5B;qCADExgb,IAYE;2CA3BK0U;8BAAX,oBAAW05B,QAAG/9G;;oCAAWkwf,MAAXlwf,OAAEowf,QAAFpwf;mCAAH+9G;kCAKa;mCADf96E,GAJE86E;mCAIPpjJ,EAJOojJ;mCAKa,iBAlDzB8vY,gBAiDKlzhB;mCACoB;;mCAEd;;8CAPMy1hB,QAKN/lT;2CAAQ3/J,IAAR2/J,mBALe6lT;mCAAdnyY,KAIF96E;mCAJKjjC;;gCAGR,OAHQA,IAYE;;8BA5BlB;;;+BAEI;;kCAFUkwf;uCAAR7lT;;oCAKG;;;;;+CAAYjmE,UAAe8oO;qCAG1B;;wCAtCT+/I;2CAuCY,iBATP5iT,OAMM8lT,UADwBjjJ,YAALxiU;oCAGrB,aADE60C,MAFG5P,MACHwgb,UAKoB;+BAT5B;qCADExgb,IAYE;;;8CA3BK0U;uCAAX,oBAAW05B,QAAG/9G;;6CAAWkwf,MAAXlwf,OAAEowf,QAAFpwf;4CAAH+9G;2CAKa;4CADf96E,GAJE86E;4CAIPpjJ,EAJOojJ;4CAKa,iBAtBzByoY,cAqBK7rhB;4CACoB;;4CAEd;;uDAPMy1hB,QAKN/lT;oDAAQ3/J,IAAR2/J,mBALe6lT;4CAAdnyY,KAIF96E;4CAJKjjC;;yCAGR,OAHQA,IAYE;;;;;;;mCAsDtBp6B,MAAO3Q,OAAO6/P;4B,OA3Gdm7R;qCAtBAH,UAkIF,KADS76hB,OAAO6/P;;6CAGyC;mCAEvDu7R,MACCC;4BAEH,SAAQvlU,GAIHulU;8BACH,GADGA;gCAuBiB;iCADfC,QAtBFD;;iCAoBGl2f;iCADA2yf;iCADAC;iCADAzG;iCADAsH;iCADAZ;iCADAzG;iCASc,WADf+J;iCACe;;;oCAiDV;0DACuC,kBAlDpCz7R,OAiDQ7xL,GACwC;oCAApC,qBArDnB7oC,MAoDUhjC;oCACS,yCAAuC;iCAlD5C;;oCA6CC;mDAjDf21hB;qCAkDkB,iBA9CXj4R;oCA8CW,UADR5xL,GAlDV8pd,uBAmDUkD,MAC+B;iCA/C3B,MALdlD,yBAKOl4R;iCAAO;;oCA6BV;;;;;;qCAEI;;wCArCRyxR,mBAqCyB,iBAFfl8S,SAAazyO,KAAJsrE;qCAMP;;wDANFmnK,OAAazyO,IAAbyyO,oBAAazyO;uCAAKqrE;qCAKpB,gBAlCD6xL;oCAkCC,UAJEh1O,MAGA+pD,KAOS;iCAxCL;;oCAuBV;;;qCACoB,iBA/BxBgkd,gBA8BUz2hB;qCACc;;qCACG,mBAzBpB09P,OAuBQ7xL;qCAEY;;oCACnB;qDAFEonK,OACA+lT;+CADQ1ld,IAAR2/J,kBACS6lT,OAE0B;iCA3B/B;;oCAUV;;;;;;qCAEI;;wCApBRjD,iBAoBuB,iBAFb5iT,SAAazyO,KAAJsrE;qCAMP;;wDANFmnK,OAAazyO,IAAbyyO,oBAAazyO;uCAAKqrE;qCAKpB,gBAfD6xL;oCAeC,UAJEv1I,MAGA11C,KAOO;gCArBH;;;2CAIV;;;4CACoB,iBAdxB28c,cAaUpvhB;4CACc;;4CACG,mBANpB09P,OAIQ7xL;4CAEY;;2CACnB;4DAFEonK,OACA+lT;sDADQ1ld,IAAR2/J,kBACS6lT,OAE0B;;;;;;;8BA3B/C,sBAOuB,+BAAiB;8BAPxC,sBAM6C,QAAE;8BAN/C;oDAIgC,QAAE;8BAJlC,sBAGiC,gBAAU;8BAH3C,sBAE8B,QAAE;8BAFhC;;uDAC+B,gBAAU;;;;;;8CAqEtC;4BA9ET,UAFGI,MAkFK;mCAEN/6W,OAAOi7W,KAAKC;4BAEd,mBAFSD,QAAKC;4BAEd;8BAEY,oCAAMn5hB,KAAGC,KAAe;;;8BA/NlCu4hB;;;;kCAgOS,mDAAQx4hB,EAAGC,EAAiD;;8BAE3D,oCAAMD,KAAGC,KAAe;mCA5MlC04hB;;;;uCA6MS,mDAAQ34hB,EAAGC,EAAiD;mCAIrEq+K,OAAO46W,KAAKC,KAAKC;4BAEnB,mBAFSF,QAAKC,QAAKC;4BAEnB;8BAEY;wCAAMp5hB,KAAGC,KAAGqD,MAAkB;;;8BA3OxCk1hB;;;;kCA4OS;;;;;;4CAAQx4hB,EAAGC,EAAGqD,EACP;;8BAEN;wCAAMtD,KAAGC,KAAGqD,MAAkB;mCAzNxCq1hB;;;;uCA0NS;;;;;;iDAAQ34hB,EAAGC,EAAGqD,EACP;mCAEhB+1hB,OAAOH,KAAKC,KAAKC,KAAKE;4BAExB,mBAFSJ,QAAKC,QAAKC,QAAKE;4BAExB;8BAEY;wCAAMt5hB,KAAGC,KAAGqD,KAAGpH,OAAqB;;;8BAvP9Cs8hB;;;;kCAwPS;;;;;;;;4CAAQx4hB,EAAGC,EAAGqD,EAAGpH,EAEP;;8BAET;wCAAM8D,KAAGC,KAAGqD,KAAGpH,OAAqB;mCAtO9Cy8hB;;;;uCAuOS;;;;;;;;iDAAQ34hB,EAAGC,EAAGqD,EAAGpH,EAEP;mCAEnBq9hB,OAAOL,KAAKC,KAAKC,KAAKE,KAAKE;4BAE7B;;uCAFSN,QAAKC,QAAKC,QAAKE,QAAKE;4BAE7B;8BAEY;wCAAMx5hB,KAAGC,KAAGqD,KAAGpH,KAAGkW,QAAwB;;;8BArQpDomhB;;;;kCAsQS;;;;;;;;;;4CAAQx4hB,EAAGC,EAAGqD,EAAGpH,EAAGkW,EAEP;;8BAEZ;wCAAMpS,KAAGC,KAAGqD,KAAGpH,KAAGkW,QAAwB;mCApPpDumhB;;;;uCAqPS;;;;;;;;;;iDAAQ34hB,EAAGC,EAAGqD,EAAGpH,EAAGkW,EAEP;mCAEtBqnhB,OAAOP,KAAKC,KAAKC,KAAKE,KAAKE,KAAKE;4BAElC;;;mCAFSR,QAAKC,QAAKC,QAAKE,QAAKE,QAAKE;4BAElC;8BAEY;;;;;;;wCAAM15hB,KAAGC,KAAGqD,KAAGpH,KAAGkW,KAAGtP,SAA2B;;;8BAnR1D01hB;;;;kCAoRS;;;;;;;;;;;;4CAAQx4hB,EAAGC,EAAGqD,EAAGpH,EAAGkW,EAAGtP,EAEP;;8BAEf;;;;;;;wCAAM9C,KAAGC,KAAGqD,KAAGpH,KAAGkW,KAAGtP,SAA2B;mCAlQ1D61hB;;;;uCAmQS;;;;;;;;;;;;iDAAQ34hB,EAAGC,EAAGqD,EAAGpH,EAAGkW,EAAGtP,EAEP;mCAEzB62hB;4BAAc57b;4BACZ67b;4BACAC;4BACAC;4BACAC;4B,OA3QFpB;qCAtBAH,UAmSF,MANgBz6b,MAGZ+7b,eACAC;qCAHAH;qCACAC,aAMmD;;;;6BA/UrDp/f;6BAWA2mE;;6BA+BAo3b;6BAsBAG;6BAsBA9va;6BAqFAv6G;6BAKAyqhB;6BAqFA96W;;6BAYAK;6BAYA+6W;6BAcAE;6BAcAE;6BAcAE;2BAvUA1I;2BAWAvyR;;2BA+BAs7R;2BAsBAC;2BAsBArxa;2BAqFAsxa;2BAKAC;2BAqFAC;2BAUAhvd;2BAEAivd;2BAYAC;2BAcAC;2BAcAC;2BAcAC;;;;kCAvUAxJ;kCAWAvyR;;kCA+BAs7R;kCAsBAC;kCAsBArxa;kCAqFAsxa;kCAKAC;kCAqFAC;kCAUAhvd;kCAEAivd;kCAYAC;kCAcAC;kCAcAC;kCAcAC;uBAlcR;;;2BVoMkC7G;;;2B5mB5F1BE;2BAEAC;2B4mB0F0BC;;;;;;;uBUpMlC;;;;;;;sBAgdoC;sBrnBhdpC;sBAubG;sB6mBvbH;sBAsFG;sBStFH;sBAkNG;sBClNH;sB9O+EoB;;;mC8O9Dd0G,aAAa56hB;4BAAgB,IAXnBk/O,GAWmB,KAAW,uBAA3Bl/O;4BAVjB;qCADck/O,cACgBnhP,EAAE6qC,IAAIzoC,GAAK,OAALA,EAAJyoC,YAAF7qC,OAAE6qC,GAA2C,EAUX;0BAOtD;0BACD,mBAvBM/qC;4BAwBb;;uCAIW0F;gCAAiB,0BAAjBA;gCAAiB,oCAAW;6BAJvC;uCAMWvD;gCAA8B,uBAA9BA;gCAAqB,8CAA0B;6BAN1D;uCAQeA,EAAEzB,GAAI,qCAANyB,EAAEzB,EAAkC;6BAI9C;;yCAAmByB;kCAAa,kCAAbA;kCAAa,mCAAsB;yCAChDA;kCAEe;;mCAApB;uEAvCOnC,OAqCFmC,QAEoC;6BAE/B,wCAbd66hB,SAEAC;6BAWc;;oCAAPp9R,0CANL16N;6BAMY;;8C,8BAzCHnlC;6BAyCG;uCAMN0F;gCAAmC,IA/CzBV,EA+CyB,gBAAnCU;gCA9CZ,SAAIy3hB,QAAQj9hB;kCAAI,wBADM8E,MACV9E,aAAwB;gCAApC,cADeF,OACXm9hB,QA8CsD;6BANxC;uCAQV76hB,EAAI+6hB,KAAeC;gCAAe,kCAAlCh7hB,EAAI+6hB,KAAeC,OAAgD;6BARzD;uCAUV53hB;gCAA6B,mBAA7BA;gCAA6B,6CAAY;6BAV/B;;oCA1Bdq3hB;;oCAfW/8hB;oCA4BXg9hB;oCAEAC;oCAEAjI;oCAEA5pK;oCAUA6jK;oCAGAiO;oCAEAE;oCAEA9ya;oCAEA78C;;sBAoBH;sB9OIiB;;;0B;;;;;;;;;;sBxY/EpB;sBwY+EoB;uBxYxElB8vd;2DAPF;;wBAOEA;;;;;;;;;;;;;;;;;;;4BmHwgBM,cnHxgBN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gEACiB;sBwYuEC;uBxY/EpB;;;;;;;wBA6CAC;;;;;;;;;;;;;4BmHkeQ,cnHleR;;;;;;;;;;;;;;;;;;;;;;;;;;;;uDAIAC,aAJAx8W;uDAIAw8W,aAJAx8W;;;;;;;;;;;;;;;gEAEsB;sBA/CtB;wBAiDAw8W;;;;;;;;;;;;;4BmH8dQ,cnH9dR;;;;;;;;;;;;;;;;;;;;;mDAJAD,uBAIAv8W;;;;gEACiB;sBA2ed;sBwY9ciB;;;;;;;;;;;mCxYuSZ4+E,IAAKr2G;4BACP,eAIgCtpJ,EAAE6qC,IAAIzoC,GAC7B,OAD6BA,EAAJyoC,WAAF7qC,EAAE6qC,GACW;4BAL7C,sB;4BAES,eApKW/lC;8BACxB;uCAgKWwkJ,eAhKatpJ,GAAK,uBADL8E,SACA9E,IAA0B;4BAkK5C,8BAFKspJ;4BAEL,6CAI+C;yCAN/Cq2G;mCAcAurH,MAAK5hO;4BAA6B,2BAA7BA,cAA8D;sCAAnE4hO;mCAGFsyK,aAAaC,WAAWC,MAAMC;4BAChC,SAAQ/nU,GAAGl9I,OAAO7tC,IAAImwQ,KAAKvhS;8BACzB,GADoBuhS;mCAAKvhS;kCAMR;mCADDy2Z,GALSz2Z;mCAKdnX,EALcmX;mCAKlB0nO,GALa65D;mCAKlB54S,EALkB44S;mCAMH,kCADf54S,EAASE,EALKuoC;mCAOJ,kCAFVzoC,EALcyoC,IAKLvoC;mCAEC;;0CAAJuB,WADKkB;qDAEA8lC,KACT,UATK6tC,eAQI7tC,IAHNs2M,GAAS+uL,GAIc;sCADV,6BARXx3V,OAMI3zE,EACLlB;sCACY;6DAFP+5hB,eACL57X;;;+BAHJ,KAJqBvoJ,KAIrB,2BAJYoxB;8BAWZ,sBACmE;4BAZzE,YADe4yf,WAAWC,MAAMC,MAeL;;;;;mCAQ7BE,qBAAsCv0Y,MAAa9tI,KAAKkihB,MAAOz4hB;;8BAE7D;oCACe64hB,mBAAN/uT;;iDAUAx9J;mDACAwsd;;uDASDC;0CACR,UADQA,oBApBCjvT,iBAUAx9J,MAWuB;wCADb,uBATVwsd,gBAd6CL,MAGvCI;wCAoBI;sCAJK;mEAnBYx0Y;uCAmBjB,0CAnBmCo0Y;uCAoBvC,2CAPNnsd;sCAOM;4CAAPA,cADIypO,iCACJzpO;sCAJN;;mEAGU0sd,eACJ36X;uCAJN;;;oCAFyB,4BADlB/xF;oCACkB;kCADX,qBAb6CtsE,EAGpD8pO;kCAUO;+CAHLmvT;kCACwC;4DAXF1ihB;mCAW/C,mBADS0ihB,gBAV2CR,MAGvCI;kCAQb,uCAAuE;gCAD5C;yDAPpB/uT;;;8BADT,eAK8CisE,MAAQ,sBAARA,KAAwB;8BAA3D;2DAPyB1xJ;+BAO9B,iCAPgDo0Y;+BAOhD;+BAFa,yBALiBp0Y;+BAIlC;iDACO;8BADP,uCAoB8B;oDsH8Y9B/7E;mCtH3YJ4wd,WAA4B70Y,MAAa9tI,KAAKkihB,MAAOz4hB;;oD,IAC3CuW;8BAAa,+BADK8tI,MAAa9tI,KAAKkihB,MAAOz4hB;8BAC9B;oDsH0YnBsoE;mCtHtYJ6wd,QAAyB90Y,MAAa9tI,KAAKkihB;;8BACzC;oCACeI,mBAAN/uT;sDAUT,2BAVSA,KAUE;+CAHAmvT;kCACwC;4DAVf1ihB;mCAUlC,mBADS0ihB,gBAT8BR,MAE1BI;kCAQb,uCAAuE;gCAD5C;yDAPpB/uT;;;8BADT,eAKoD5sO,GAAK,sBAALA,EAAkB;8BAAtD;2DANOmnJ;+BAMb,iCAN+Bo0Y;+BAMnC;+BAFa,yBAJIp0Y;+BAGrB;iDACO;8BADP,uCASS;oDsH0XT/7E;mCtHvXJ8wd,WAA4B/0Y,MAAc9tI,KAAMuzN,KAAMx9J,KAAKmsd;;8BAG9B;gEAHmB3uT;+BAIxB,iCAJ8Bx9J;8BAI9B,eAI8BpvE,GAAK,mBAALA,EAAe;8BAAnD;2DARUmnJ;+BAQhB,iCAR+Co0Y;+BAQnD;+BAFJ;iDAAgB,mBANQp0Y;8BAMxB;;;iCADEw0Y;iCADAC;iCADKG;;;oCAkBT,oBAjBIH,gBAJqDL,MAKrDI,UAgBwC;kCAJpB;+DAjBEx0Y;mCAiBP,0CAjBsCo0Y;mCAkB1C,2CAlBqCnsd;kCAkBrC;wCAAPA,cADIypO,iCACJzpO;kCAJN;;+DAGUitd,eACJC;mCAJN;;;gCAHiD;0DAXXjjhB;iCAWtC,mBARO0ihB,gBAHgDR,MAKrDI;iCAMF;;;yDAPEQ,eACAC;yDAFKh7X;qEAkBmC;oDsHkW1Ch2F;;;;;;;kCtH7bAiwd;kCAkDJW;kCA3BAN;kCAgCAO;kCAeAC;sBunB7cF;sB/O+EoB;uB+O/EpB;iCAGSv5hB,GAAuB,4BAAW,YAAlCA,GAA6C;uBAHtD;iCAUMA;8BAJO8sD,MAIP9sD,EAJW9E;0BACb;4BAAkB,cADT4xD,M1nB+FmB/mB,K0nB9FO,OADtB7qC;4BAER;iCAFQA;6BAEL,uBAFC4xD;;6BAAI5xD;qCAIA;uBAVjB;;mCAuBM4+hB,WACa5+hB;gCAAJ6qC,gBAAI+iC;4BAAI;8BAAG,mBAAPA,OAAmB,OAAvB/iC;8BAAgC;mCAA5B+iC;+BAA+B,6BAAnC/iC;;+BAAI+iC;uCACD;mCAEZovd;4BACW;6BADIj3f;6BAALqkF;6BAAW8G;6BACV,uBADUA;4BACV;8BAET,GAHanrF;gCAKF,IADJo7M,GAJMp7M,QAKF,WADJo7M,GAHPrhP;gCAIW;8BAEP,iCAPIsqH,MACRtqH,OAMoC;4BAN3B;mCAQX++hB,QAAQ19S;4BACF,IAAJr8O,EAAI,OADEq8O;4BAEH,mBADHr8O;8BAII,qCALEq8O;8BAGqB,0BAF3Br8O,G1nBgEW6mhB,cAAa9gf,a0nBjElBs2M;0DAOT;mCAEC29S,UAAUh6hB;4B,IAAeX;2CACnB4hC;8BACS;;iDAFU5hC,kBAEe,iBAAc,GADhD4hC;+BAGyB,YAAI,eAAW,YAJrB5hC;+BAIV,qBAJLW;8BAMW,cAHnBosH;gCAMI;kEAPJ6ta;iCAM2C,YAAI,eAAW,YARnC56hB;gCAQI;wCAL3B+sH;wCAK2B,SARnBpsH;;2CAERi6hB;4DASH;4BAVc,kBADHj6hB;4BACG;mCAYbk6hB,UAAUl6hB;4B,IAAeX;2CACnB4hC;8BACM;4CADNA,KADmB5hC;+BAGL,wBADlB86hB;+BACkB,MAAlBC;+BAAkB,MAAlBA;+BAI6C,YAAI,eAAW,YAPrC/6hB;+BAOR,eAJf+6hB;+BAE6C,YAAI,eAAW,YALrC/6hB;8BAKR;+CAFf+6hB;;;4CAOH;4BATc,kBADHp6hB;4BACG;mCAWbq6hB,gBAAgB35hB,EAAEV;4BACb,mBADaA;8BAEpB;;;kCACY,IAAJX,EAAI,OAHQW;kCAIE,cAJJU,KAGVrB,GACsC,8BAJ5BqB;iDAMH27O;oCACC,cADDA,GANKr8O,GAQN,6BADJs6hB;oCACI,eACCxzb;qDACD/nG;wCAIuB,mBAX7BM,E1nB4BOwnhB,c0nB/BGnmhB,KAUJ3B,IAQP;sCANyC;;wDAZ5BiB;uCAYwB;uCAA3B;uCADT,iCAFO8mG,KADL1kG;sCAGF;oCAFc,oCATJ1B,KAQR0B;oCACY,0CASf;kCAZa,kBANF1B;kCAME,0CAYb;8BAhBP;0DAgBS;mCAEP+nE,OAAMtrE,EAAEzB;4BACV;8BASO,cAVCyB,KAAEzB;+BAUgC;8BAC9B,cAXJyB,KAAEzB;+BAWsC;8BAKtC;qDAhBAA;+BAcF,iBACE,gBAfFyB;8BAcA,sB,IAIQq9hB;8BAAY,qCALlBD,WAbFp9hB,KAAEzB;8BAkBkB,0CAClB;4BAlBV,uCAkBY;mCAEV4uE,SAAOntE,EAAEzB;4BACX;8BASO,cAVEyB,KAAEzB;+BAUgC;8BAC/B,cAXHyB,KAAEzB;+BAWoC;8BAKrC;qDAhBCA;+BAcH,iBACE,gBAfDyB;8BAcD;gC,IAIQs9hB;8BACR,qCANEF,WAbDp9hB,KAAEzB;8BAmBH,0CAEW;4BApBnB,uCAoBqB;mCAEnBwmH,SAAM/kH,EAAEzB,GAAI,cAAJA,EAAFyB,EAAW;mCAEjBglH,SAAOhlH,EAAEzB,GAAI,gBAAJA,EAAFyB,EAAY;mCAEnBilH,SAAMjlH,EAAEzB;4BAEV,iCAFQyB,KAAEzB,KAEqB;mCAE7Bg/hB,c,IAASp1a;mCAETi0I,SAASp8P;4BACE;0DADFA;6BAEH,yBADJw9hB;4BACI,eAMqCz/hB;8BACb,gCAR5By/hB,OAOyCz/hB;8BACb,6CAA0B;4BADpD,oBAAW,gBANb8E;4BAGI,UAHJA,IAGI,gCALG7C,SAUV;0BAEO,8BAEC;mCAEPy9hB;4BAAkD,IAA5Bv7hB,WAA4B,YAA5BA;4BAAc;0BAF7B,SAIP+4hB,KAAI96hB,EAAG+6hB,KAAOC;2CACRhza;8BAGQ,iBAJP+ya,QAAOC;8BAGA,iBAHPD,QAAOC,iBACRhza,QAMP;4BANa,qCADRhoH,EAAG+6hB,QAAOC;4BACF;0BALL,SAaPj2a,SAAMllH,EAAEzB;4BAEQ,IAAd0wH,YAAc,SAFVjvH,KAAEzB;4BAGP,cADC0wH;8BAIM,oCANFjvH,KAAEzB;8BAKQ,UAHd0wH,YAGc,SALVjvH,KAAEzB;4BAEQ,IASY,mBAXpBA,MAWN,mBAXIyB;4BAWJ,iDAAsD;0BAxBjD,SAsCP09hB,eAAe76hB,EAAE4S;2CACVkohB;6CACAC;gCAC+B,YAD/BA,YADAD,UAE+B,SAF/BA,UAzCPzzhB,KA2CuD;8BADR,sB,OA5D/C+6G,SA0DepiH;8BAEM;+CADd86hB,UADUlohB;+BAEI;;4BADF,oBADJ5S,EAAE4S;4BACE;0BAvCZ,SA2CP0vG,SAAMnlH,EAAEzB;4BAGP,cAHKyB,KAAEzB;8BAMA,qCANFyB,KAAEzB;8BAIQ,mBAJVyB,KAAEzB,MAKQ,SALVyB,KAAEzB;4BAWoB,uBAXpBA,MAWN,mBAXIyB;4BAWJ,iDAAsD;0BAtDjD,SAwDPolH,SAAMplH,EAAEzB;4BACV;8BAEsB,IAAd0wH,YAAc,SAHdjvH,KAAEzB;8BAIH,cADC0wH;gCAEY;;2CAAN9G;oCAEQ,UAJd8G,YAIc,SAPdjvH,KAAEzB,MAKI4pH,QAKP;iCALa,gCALZnoH,KAAEzB;gCAKU;8BAFE,IAUY,mBAbxBA,MAaF,mBAbAyB;8BAaA,iDAAsD;4BAZ9D,uCAYgE;0BArEvD,SAwEP69hB,UAAU79hB,EAAE6C;2CACLi7hB;6CACDC;gCACE;+CAHE/9hB,EAEJ+9hB;iCACE,EAHIl7hB;iCAGJ,MAANsgB;iCAAM,MAANA;gCAKgB;8CAAI,eAAW,YADbjhB;wC1nBxIM0mC;;8C0nB0I3B;8BAPmB,oBADXk1f,QADKj7hB;8BAEM;4BADD,oBADP7C,EAAE6C;4BACK;0BAzEV,SAmFP2iC,IAAIxlC,EAAEzB;2CACC8+hB,MACT,YADSA,KADHr9hB,EAAEzB,EAEkB;4BADV,iBADVyB,EAAEzB;4BACQ;0BApFP,SAuFPgnC,IAAIvlC,EAAEzB;2CACC8+hB,MACT,YADSA,KADD9+hB,EAAFyB,EAEoB;4BADV,iBADVA,EAAEzB;4BACQ;0BAxFP;kCAvIPo+hB;kCAIA5B;kCASA6B;kCASAC;kCAaAE;kCAYAG;kCAoBA5xd;kCAqBA6B;kCAuBA43C;kCAEAC;kCAEAC;kCAIAs4a;kCAEAnhS;kCAYAlyP;kCAEA2qE;kCAEA4od;kCAEAxC;kCASA/1a;kCAyBAw4a;kCAKAv4a;kCAaAC;kCAgBAy4a;kCAWAr4f;kCAIAD;sBAwCH;sB/O9MiB;;;0B;;;;;;;;;;;;;;;;;;;;;;;;;sBvY/EpB;sBuY+EoB;uBvY/EpB;iCAQyBplC,GAAI,0BAAJA,EAAI,QAA4B;uBARzD;;0BA4CgC;;;2BknB5B1B69hB;2BAEAC;2BAIA1J;2BAGAC;2BAGAC;;;;;;2BAkBAC;2BAsBAG;2BAOAC;2BAuBAC;;;2BA4WAtzb;2BAGAg2b;2BAGAjB;2BAEAoB;2BAGAF;2BAGApB;2BAGAtB;2BAEAE;2BAEAD;2BAEAjyf;2BAEAmyf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BlnB3b0B;2BAEM;;;;;;;;;;;;;;;;;6BAF9BhE;6BAEAvyR;0BAA8B,SAGhCm2H,iBAA6B/0X;4BACb;6BADF09P;6BACE,iBADFA,OAAe19P;6BACb;;6BACD,gBADbizO,gBACsCjzO,GAAK,UAALA,EAAqB;4BAA9C,kBAFD09P,UAEZ2xR,WADQ/7c;0BAJsB;;;;;;;;;;;;;;;;;;;;6BAjCrBm5C;;;;;;;;;;;;;;;;;;2BAiCqB;uCwmB5ClC4ha,MxmB+DI3lgB;2BAnB8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA6B9B21gB,QAAQ9kL;4BAAM,kBAJd85K,wBAIQ95K,IAAkC;0BA7BZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BFlBN;2BAEM;;;;;;;;;;;;qDAabvhV,EAAasmgB,MAAiB18hB;4BAGT;;6BAAtC,mCAH+CA,EAA9Bo2B;6BAE+B;8DAFDp2B;6BAE/C,mCAF8B08hB,MAAbtmgB;4BAEjB,sCAED;0BAjB+B,oBAwBpBA;4BACd,eACQA;8BACL,6BADKA;+BACyB;8BACf,oCAFVA;8BAEU,+BAAY;4BAFlB,qCAFEA;4BAEF,oDAEkB;0BA5BI,SA8BhCokO,eAA6Bp8P;4BACb;6BADF09P;6BACE,iBADFA,OAAe19P;6BACb;;6BACD,gBADbizO,gBACsCjzO,GAAK,UAALA,EAAqB;4BAA9C,kBAFD09P,UAEZ2xR,WADQ/7c;0BA/BsB,SEyL5B3C,MFtJG3wE,EAAazB;4B,SAAbyB,cAAazB;8BAMN;+BAJO2tC,IAFD3tC;+BAEXs7D,IAFF75D;+BAMO;0DAJL65D,IAAY3tB;;;+BAGd;;4BAGS,IAAVlU,EAAU,qBARTh4B,EAAazB;4BAQJ;kCACF46I,aAAHv3I;oDAIT,OAJSA,CAIc;8BADV,4BAJTo2B,EACQmhH,IAAHv3I;8BAGI;4BAFS;oDA7CtB0/F;6BA6CmD,oBAF/CtpE;6BAEF;mEAGqB;0BAhDO,aAkD1BuU;4B,GAAAA,IAAQ,QAARA,aAAQypC,aAARthC;4CAAqCn2C;8BAC7C;;yCAD6CA;kCAGzC,QAHyCA,KAGnB,sCADH2tC;kCACZ;gCAEA,6CALkC3tC;;gCAOzC,IADUo3E,IAN+Bp3E;gCAOlC,+CADGo3E;8BAGV;;uCATIjhC;;yCAUA,eACS1c;iEAKT,OALSA,CAKR;2CADY,+BAfwBz5B,EAW5By5B;2CAII;yCALb;;0CAG0C,iCAbLz5B;0CAaR;0CAAL;0CADtB,qCA9DN+iG;yCA8DM,0CAID,EAAE;0BAlEuB,gBAoEvB/0D;4B,GAAAA,IAAQ,QAARA,aAAQypC,aAARthC;4BACX;8BAEI,aAAsB,gCADfmlB;8BACA;4BAEP;;qCALOnlB;;uCAMH,eACS1c;+DAKT,OALSA,CAKR;yCADY,+BAJJA;yCAII;uCALb;;wCAG4B;wCAD1B;;sDACsB,wCA7E5BspE;uCA4EM,0CAID;0BAhFyB,aAqF1B/0D;4B,GAAAA,IAAQ,QAARA,aAAQypC,aAARthC;4BACR;8BAEI,aAAsB,gCADfmlB;8BACA;4BAEP;;qCALInlB;;uCAMA,eACS6pf;+DAYT,OAZSA,KAYJ;yCAHH;;;2DATOA,MAUL;yCADF;uCAVF,eAKiCv+hB;yCACX,gDADWA;;kDAEhB,0BAFgBA,EAEG;uCAFxB;;wCAHV;;sDAGM,wCAhGZshG;uCA6FM,0CAWG;0BAxGqB,aA0G1B/0D;4B,GAAAA,IAAQ,QAARA,aAAQypC,aAARthC;4CAAqCn2C;8B,uBAAAA;gCAGnB;iCADH2tC,IAFsB3tC;iCAElCs7D;iCACe,gCADfA,IAAY3tB;gCACZ;8BAEP;;uCALIwI;;yCAMA,eACS8pf,OACT,2BADSA,MACE;yCADM,gBAPoBjgiB;yCAOpB,0CACN,EAAE;0BAlHa,SE8R5B08hB,KFpKF96hB,EANsC+6hB,KAAkBC;;8BAE5D,SAIIh7hB;gCAGA,IADO4mG,IAFP5mG;gCAGU,iCADH4mG;yCACqB,oBATUm0b;yCASQ,oBATUC;uCAAlBD,iBAAkBC;gCAavB;iCADV7ohB,EAZiC6ohB;iCAY7C53hB,EAZ2B23hB;iCAaL;iCAAD,iCAPhC/6hB;iCAO2B,2BADJmS;iCACN,2BADN/O,EANXpD;iCAOiB;;6CAEJyB;sDAUT,OAVSA,CAUR;gCADqD;4DAT7CA,EAf2Cu5hB;iCAwBvC;;4CAlBjBh7hB,EAkBqC,qBAxBC+6hB,KAAkBC;gCAwBvC;6CAJEh7hB;gCAEH;iCAtBsBs+hB;kCAsBtB,0BAFGt+hB,kBApBmB+6hB,KAAkBC;kEApHxD75b,MAoHsCm9b,OAsBwB;8BAFvC;gEAdvBt+hB;+BAUM;;;;;kCApINmhG;8BAoIM,0CASC;oDuHypBTh2B;0BvHtyBgC,yBA+IJ/oE;;8BAC9B,sBAEA,QAAE;8BADU,gBAFkBA;8BAElB,0CACV;oDuHopBA+oE;0BvH3oBuB;;2BAEC;mCAEtBszd,IAAK5+hB,GAA8B,4BAJnC0+hB,OAIK1+hB,EAAgE;mCAErE6+hB,KAAI1+hB,EAAI+6hB,KAAeC;4BACX,6BADRh7hB,EAAI+6hB,KAAeC,QmnB5LzB5H,UnnB6LuE;mCAIrEuL,+BAQE9+hB,EACAzB;4BADJ,eAGSy5B;oDAaT,OAbSA,CAaD;8BAHS;4DAbbh4B,EACAzB;+BAa4B;+BAAD,iCAXtBy5B;+BAWP;;0CADI+mgB,SACyB,2BADzBA;8BACJ;4BANgB;uEARd/+hB;6BAQiC,0CAPjCzB;4BAOiC;kCAAJA,WAAnByB;8BACyB;gCAAvB,yCADFA;;gCACyB,yCADNzB;+BACwB;8BAC9C;4BANT;;;sDAIYo9hB,eAAmB57X;6BAJ/B;;;;;gCAlLAz+D;4BAkLA,0CAYM;mCAKNn0B,SAHQntE,EAAUzB;4BACE,2BADZyB,GAAUzB;4BACE,mCmnB5NtBg1hB,UnnB4NuD;mCASrDxua,SALO/kH,EAAEzB;4BACX,eACQygiB,YACR,WADQA,WACM;4BADkB,cAFrBzgiB,GAEU,mBAFZyB;4BAEY,0CACP;mCAIZi/hB,IAOA//S;4BAPM,GAONA;;;;kCACE;kDACQggT,UAGR,WAHQA,SAGI;mCAF2B;mCAArC,YAAM,qBAHVhgT;kCAGI;oCALEvuO;uCAPNo0G,eAOMp0G;8BADJ;4BAFA,wBAjDFguhB,QA2Dc;mCAEdzxa,IAOAgyH;4BAPM,GAONA;;;;kCAGI;8DAHJA;mCAEiC,aAFjCA;mCAEmB;kCAAf;oCAJEvuO;uCA5BNw8D,eA4BMx8D;8BADJ;4BAFA,wBAjEF+thB,OAyEkC;mCAElCS,YAAah/hB;4BACuC;4BAA3C,kBuM2FW60H,OvM3FX,qBADI70H,SACiD;mCAE9Di/hB,aAAaj/hB,GAAI,OAAJA,EA9Ebu+hB,OAEAC,OA4E4C;;4BAMhC,0CAAkD;;;;;8BA/O9Dr9b;;uCAgPgBthG;gCAAQ,iCAARA,qBAAqD;;4DAEnDG,GAAa,OAAbA,CAAc,EmnB7QlCozhB;2BnnBuQS71R;yCAYEn7P;4BAED,oCAFCA;4BAED,sCAAyD;;2BAfjE0mX;kCACOvrH;2BAkBAk6I,MAnBP3uB;gDAoB+B,+BAAiB;;2BAFhDo2K;;;8BACOznJ;;;;;;;;;;;;;;;;8BAIT,eAGW/5Y;gCACT,0BADSA,OkGuzCT+gK,elGtzC4B;;+BAJ1BihB;8DvF3IJrgB;6CuFiJ2Dx/J;gCAGnC;kEAhCtBipX;iCAiCS;;oCAAK;sCAJ2CjpX,kB,OA1O3Do8P,SA+NEijS;iCAaI;0DACE;iCAIe,aAPoCr/hB,kBACvD,YAM4C;iCAAjCizH;qD2FzHfzS,Q3FyHeyS,uBAAiC;;;;;;;;;0D,OuHqMhDnS,a5B9TAN;;uC3F4GIq/D;6CAa8C;mCAEhDh4D,KAASn3G,GA6BDvQ;4BA5BH,sBADIuQ,IACY,oBA4BbvQ;4BA5Ba;;;gCAEnB,IADYwQ;gCACL;wDAzCTs4W,qBAwCct4W;8BAGZ,aAAO,qBAwBDxQ,IApBN,iBAoBMA;;;sCAtBC,qBAPAuQ;sCAWP,iBAXOA;4BAmBP,eACSlL;oDAcT,OAdSA,GAcN;8BAFsB;0DAhClBkL,GA6BDvQ;+BAGkB,iCAZfqF;+BAYP;mDAAY,qBAhCPkL,OA6BDvQ;8BAGJ;4BAPQ;8DA7CZk/hB,cAiDQl/hB;6BALsB,iCA5C9Bk/hB,cAoBS3uhB;6BAqBL;;;;mCAGM;gCA5CV2uhB;4BAyCI,0CAaC;mCAGHC,SAAUpgT;4BACZ,eAAuDl/O,EAAEzB,GACrD,2BADmDyB,EAAEzB,EAC7B;4BADR,cADR2gP,GACQ,0CACU;mCAE5BqgT,MAOArgT;4BAPM,QAONA;4BAPM;8BAQJ;8CACQggT,UACR,WADQA,SACI;+BAD2B;+BAApB,YAAM,SAF3BhgT;8BAEqB;;qCAPnB,wBA/JJy/S;yCAgKKjuhB,GAIHwuO,8BAJGxuO;0CAEA8lJ,KAEH0oF,MAFOvuO,GAEPuuO,aAvHFn6H,SAqHKyxC,KAAI7lJ,IAKO;mCAEdq5f,MAOA9qR;4BAPM,QAONA;4BAPM;8BAQmD;8CADzDA;+BACuB,gCADvBA;8BACQ;;qCANN,wBA7KJw/S;yCA8KKhuhB,GAIHwuO,8BAJGxuO;0CAEA8lJ,KAEH0oF,MAFOvuO,GAEPuuO,aA1IF/xK,SAwIKqpF,KAAI7lJ,IAG+D;mCAGpE6uhB,MAAItgT,IAAqB,gCAArBA,IAAkC;mCAEtCugT,MAAIvgT;4BAEW;6DAFXA;6BAEJ;4BADW,mCADPA,UAE4C;;qCAJhDsgT,MAEAC;oCA7BFH,SAIAC,MAYAv1B;mCAmBFxlS,QAAOtkO,EAAUC;4BAAW,6BAArBD,EAAUC,GA1LjBy+hB,IA0L4C;mCAE5C9D,SAAS96hB;4BACX,sBAEA,OAHWA,CAGH;4BADK,6BAAQ,sBAFVA;4BAEE,0CACL;mCAGJ0/hB,QAASn8hB,GAAoB,OAApBA,CAA4B;wCAArCm8hB;mCAIA16a,SAAOhlH,EAAUzB,GAAW,0BAArByB,EAAUzB,EAAmD;mCAEpEohiB,QAASp9hB,GAAW,gBAAXA,EA5MXm8hB,OA4M+B;mCAEjCkB,MAAoB1gT;;8BACF,4CADEA,IAC4B;oDuH4bhD5zK;mCvH1bAj4B,MAAoB6rM;;8BAGa;4CAHbA;+BAGD;+BAAf;8BADA,+CAFgBA,UAG+B;oDuHubnD5zK;mCvHrbAu0d,YAA4B3gT;;8BACkB;8BAA/B,+CADaA,UAC2C;oDuHobvE5zK;0CvHjcI05C,SAEA26a,QAEJC,MAGAvsf,MAKAwsf;mCAOQ92Y,OAAKxlJ;4BACX,OADWA;qCAMP,IADEhB,EALKgB,KAMP,2BADEhB;;+BAGU;gCADV0qH,GAPK1pH;gCAQK,aADV0pH,GAPA87B;gCAQF;gEAtKJ77B;;+BAwKgB;gCADXy5B,KATMpjJ;gCAUK,aADXojJ,KATCoC;gCAUF;gEAtLJk2Y;;+BAgLI,IADEj8a,IAHKz/G,KAIP,aADEy/G;+BACF,iCA7NJ47a,KAmO6C;mCAE3C3L,OAAQ1vhB;4BAAI;2DAAJA,SAA6B;mCAErC0hH,SAAM1iH,GAAI,UAAJA,EAAS;mCAEf2iH,SAAOllH,EAAEzB,GAAI,aAANyB,KAAEzB,MAAgB;mCAIzB4mH,SAAOnlH,EAAEzB,GAAI,aAANyB,KAAEzB,MAAe;mCAIxBuhiB,MAAIv8hB,GAAI,UAAJA,EAAS;mCAEbw8hB,MAAIjud,IAAK,UAALA,GAAU;mCAEd2lK,MAAI3lK,IAAK,UAALA,GAAW;;;;6BA5BXi3E;6BAYJkqY;6BAEAhua;6BAEAC;;6BAIAC;;6BAIA26a;6BAEAC;6BAEAtoT;;;6BAzPFinT;6BAEAC;6BAEAC;6BAEAC;6BAKAC;6BA6BA3xd;;6BAOA43C;;6BAEAk6a;6BAcA/xa;6BAYAiya;6BAGAC;6BAEAn2K;6BAkBAo2K;6BAoBAx3a;;6BAwEA28G;6BAEAs2T;;;;4CA7VAnggB;;mCEyDAgigB,WACa5+hB;gCAAJ6qC,eAAI+iC;4BACb;8BAAG,mBADUA,OACC,OADL/iC;8BACc;mCADV+iC;+BACa,4BADjB/iC;;+BAAI+iC;uCAGA;;mCAIbq0d,0BAA0Bz9hB,EAAG1E;4BAE7B,4BAF6BA;4BAE7B,eAKUmC;8BACA,IAAJ65D,IAAI,qBADA75D;8BACA;uCARmBnC,gBASFE,GAAK,4BAD1B87D,IACqB97D,EAAwB,EAAC;4BAFtC;8DAPYwE;;2CAIYvC,GAAK,0BAALA,EAJTnC,OAIyC;4BAArD,qCAJS0E;4BAIb;qCA1Bb47hB;wCA0Ba;;2CAKwC;mCAErD8B,YAAan8f;4BACf,qBAC6DvhC;8BAAd;8BACb,gBADwBiB,EAAGjB,GAARqmC,KACnB,0BADwBplC,KACR;4BADhD;+CAFasgC;6BAEb;uDADEmpF,GAIsB;mCAExBiza,gBAAiB39hB,EAAa1E;4BAChC,eACSimC;8BACA,IAALq8f,GAAK,YADAr8f;8BACA,sBAIT,OALSA,IAKL;8BAFF;;;kCA7CAkvf,kBA2CEmN,GAEsC,mCALvB59hB;8BAKjB,iDAEE;4BALY,oCAFGA,EAAa1E;4BAEhB,iDAKZ;mCAEFuiiB,wBAAyB79hB,EAAa1E;4BACxC,eACSimC;8BACA,IAALq8f,GAAK,YADAr8f;8BACA,eACD6pC;gCACR,UAHS7pC,iBAED6pC,SACgB;8BADN,gBADdwyd,GAHuB59hB;8BAIT,iDACM;4BAHR,oCAFWA,EAAa1E;4BAExB,iDAGQ;;;;;2BonB7CxBwiiB;2BAFAC;mCApBAlqa,MAAM7yH,EAAG4f,KAAMngB;4BACjB,SAAQ2wN,GAAG51N,EAAE6qC;8B;gCAIQ;iCADZkpC;iCAAL9xE;gDACW4oC,KACT,UALK7qC,UAII6qC,IADNkpC,GAEc;iCADF,iBALJ9uE,EACNjF,EAAE6qC,IAGT5oC;gCACiB;8BAFf,2BAFO4oC;4BAAb,YADWzlB,KAAH5f,EAQG;mCAET8sE,KAAK9sE,EAAG4f,KAAMngB;4BAAI;qCAAbO,EAAG4f,oBAAkCylB,IAAI5oC,GAAK,kBAArCgD,EAA4B4lC,IAAI5oC,EAAY,EAAC;mCAE3DugiB,SAASzud,GAAI3uD,KAAMngB;;kCACRsoH,YAAL9lH,aAKF,UALEA,IAKF,MALO8lH;4BACX;;;gCAFSx5C;mCAAI3uD;+CAE8BnjB;kCAAf;;wCACXzB,WAALqqC,8BAAKrqC,EADsB+sH;kCAClB,qBAHFtoH,EAEe4lC,IAAS5oC;kCACtB,0CACD;4BAFpB;mCAUAmjB,KAAKtgB,EAAGG;4BACV,SAAQ2wN,GAAG/qL,IAAI7qC;8BACV,mBADUA,KACC,2BADL6qC;6CAGE5oC,GACT,aADSA,EAHF4oC,KAAI7qC,UAIU;8BADR,qBAJPiF,EACKjF;8BAGE,0CACQ;4BAJzB,YADO8E,UAOM;mCAEXszH,MAAM5yH,EAAGP;4BACX,SAAQ2wN,GAAG51N;8B;gCAIS;iCADX+zE;iCAAL9xE;uDAEE,UALKjC,UAGF+zE,GAEU;iCADC,iBALT9uE,EACAjF,EAGPiC;gCACgB;8BAFd;4BAFN,YADQuD,EAQF;mCAEJ8oE,KAAK9oE,EAAGP;4BAAI,aAAPO,WAAuBxF,EAAGiC,GAAK,kBAA5BgD,EAAuBhD,EAAQ,EAAC;mCAExCw9E,KAAKj6E,EAAGP;4BACV,SAAQ2wN,GAAG51N,EAAE6qC;8B;gCAIM;iCADVkpC;iCAAL9xE;gDACWzB,GACT,UALKR,aAIIQ,EAJFqqC,KAGJkpC,GAEqB;iCADX,iBALT9uE,EACCjF,EAGPiC;gCACe;8BAFN,gBAFA4oC;8BAEA;4BAFb,cADOrlC,EAQE;mCAEPgsE,IAAIhsE,EAAGP;4BAAI,YAAPO,WAAsBxF,EAAGiC,GAAK,kBAA3BgD,EAAsBhD,EAAQ,EAAC;mCAUtCu2H,QAAQhzH,EAAGP;4BAAI,eAAPO,EAAGP;4BAAI,uCAAsB;mCAErCq3E,OAAO92E,EAAGP;4BAAI,cAAPO,EAAGP,GAAI,uCAAqB;mCAEnCwzH,SAASjzH,EAAGP;4BAAI,eAAPO,EAAGP;4BAAI,uCAAsB;mCAEtCo3E,QAAQ72E,EAAGP;4BAAI,cAAPO,EAAGP,GAAI,uCAAqB;;;;6BAvEpCozH;6BAUA/lD;6BAEAkwd;6BAuDAlmd;6BAFAk8C;6BAMAn8C;6BAFAo8C;6BAjDA8pa;6BAEAD;6BAEAl9gB;6BAmBAkpD;6BAVA8pD;6BAsBA5mD;6BAVAiO;2BpnBuCQgjd;2BAEAC;;;mConBIRC,QAAMn9hB,EAAG4f,KAAMngB;4BACjB,eAA4CjF,EAAE6qC,IAAI5oC;6CACrC4oC,KACT,kBAHa5lC,EAC2BjF,EAC/B6qC,IADqC5oC,EAErC;4DAFiC4oC;4BAA1B,eADZrlC,EACY,iBADT4f,YAGI;mCAEb2jF,OAAKvjG,EAAG4f,KAAMngB;4BAChB,eAA2C4lC,IAAI5oC;6CAClC4oC,KACT,kBAHY5lC,EAEH4lC,IADkC5oC,EAEpC;4DAFgC4oC;4BAAxB,cADZrlC,EACY,iBADT4f,YAGG;mCAEXw9gB,QAAMp9hB,EAAGP;4BAAI;qCAAPO,aAAgCxF,QAAKiC,GAAK,kBAAvCgD,EAA6BjF,EAAKiC,EAAU,EAAC;mCAEtDuwE,OAAKhtE,EAAGP;4BAAI;qCAAPO,mBAAkCvD,GAAK,kBAApCgD,EAA+BhD,EAAQ,EAAC;mCAEhD+3I,OAAKl1I,EAAGG;4BACV,SAAQ2wN,GAAG1tM,IAAIloB;8BACV,mBADUA,KACC,wBADLkoB;6CAGEjmB,GACT,QAJWjC,KAGFiC,EACT,UAJOimB,IAAIloB,UAKG;8BAFD,qBAJPiF,EACKjF;8BAGE,0CAEC;4BAEf,mBARI8E,KAQO;4BACN,mBATDA,KASY;2CAERghL;8BACC,IAAN59J,IAAM,eAZLpjB,EAWIghL,MACC,UAAN59J,IAZCpjB,UAaS;4BAFE,qBAXRG,EAAHH;4BAWW,0CAEF;mCAEd+9hB,OAAKr9hB,EAAGP;4BAAS;qCAAZO,sBAAqCxF,GAAS,kBAA3CiF,EAAkCjF,EAArCwF,MAAqCxF,GAA+B,EAAC;mCAE1EqyE,MAAI7sE,EAAGP;4BAAI,cAAPO,WAAsBxF,EAAGiC,GAAK,kBAA3BgD,EAAsBhD,EAAQ,EAAC;mCAEtC6giB,WAASt9hB,EAAG4f,KAAMngB;4BACpB,IAAIwC,OADU2d;4BACd,eACQ5f,GAMR,UAPIiC,OACIjC,EAMC;4BALP;;;gCAHSA;yCAGKvD;;wCACGzB,WAALqqC,aAHVpjC,SAGUojC,WAAKrqC;kCAAI,qBAJHyE,EAChBwC,OAEYxF;kCACO;4BADrB,0CAKO;yCAEWA,GAAK,OAALA,CAAM;mCAAxB+igB,a,OAZA3yb;yCAcwBpwE,GAAK,OAALA,CAAM;mCAA9BmtH,gB,OAjCA58C;mCA2CAuwd,UAAQv9hB,EAAGP;4BAAI,iBAAPO,EAAGP;4BAAI,iCpnB7DPw9hB,MonB6D6B;mCAErCO,SAAOx9hB,EAAGP;4BAAI,gBAAPO,EAAGP;4BAAI,iCpnB/DNw9hB,MonB+D2B;mCAEnCQ,WAASz9hB,EAAGP;4BAAI,iBAAPO,EAAGP;4BAAI,iCpnB/DRy9hB,MonB+D8B;mCAEtCQ,UAAQ19hB,EAAGP;4BAAI,gBAAPO,EAAGP;4BAAI,iCpnBjEPy9hB,MonBiE4B;0BpnBzD1B;;;6BonBJVC;6BAKA55b;6BA4BA+5b;6BAwBAE;6BAFAD;6BAMAG;6BAFAD;6BAhBAj+B;6BAEA51Y;6BA/BA4qB;6BAFAxnE;6BAFAowd;6BAqBAvwd;6BAFAwwd;;;;;;;;;;;;;;;;;;;2BpnBzBU;mCADRO,QAEG5ob;4BAOG,gBAPHA;4BAOG;kCAGC3L,YAAL1xB,2BAAK0xB;;;;mCANEh8B;mCAALruE;iDALF2+hB;;yCAKOtwd;;gCADH;4BAMF,yBAEO;0BAZH,SAcRwiR,KAAK76O;4BACP;4BAAO,mBAAC,OADDA,aAEP,eAFOA;0DAEK;0BAhBF,SAkBR80R,OAAO9qY,EAAG1E;4BACL,mBADKA;6BAEZ,uBAFS0E,EAAG1E;0DAEqB;0BApBvB,SAsBRujiB,eAAe7+hB,EAAG1E;4BACb,mBADaA;6BAEpB,+BAFiB0E,EAAG1E;0DAEqB;0BAxB/B;;;;;;;;;;;;;;;;;;;;;6BADRsjiB;6BAeA/tM;6BAIAi6C;6BAIA+zJ;2BAtBQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAiCAphiB;4BAAsB,gCAAtBA;4BAAsB,mCAAqB;0BAFrD;2BADE6/K;4BACF,OACiB,WJnFSj3I,IImFK,eJnFlB8gf;0BIkFb,SAIE/qV,SAASx9L,GAAGE;4BAC8B;wDADjCF;6BACa;6BACoB,2BAF9BE;6BAEU;2CAGdrB;8BAAsB,gCAAtBA;8BAAsB,mCAAqB;4BADpC,yBAHbqhiB,UACAC,iBAGkD;0BATtD,eAcUthiB;4BAAsB,gCAAtBA;4BAAsB,mCAAqB;0BAFrD;2BADEuhiB;4BACF;8BACiB,mBJ/FS34f,II+Fa,eJ/F1B8gf;0BI8Fb,SAIEx3U,iBAAiB/wM,GAAGE;4BACsB;wDADzBF;6BACK;6BACoB,2BAFtBE;6BAEE;2CAGdrB;8BAAsB,gCAAtBA;8BAAsB,mCAAqB;4BADpC,iCAHbqhiB,UACAC,iBAGkD;0BATtD;mCAeEE,OAAOxhiB;4BAAqB,+BAArBA;4BAAqB,oCAAe;0BAf7C;;;;;;;;;;;;;;;;;;;;;;;mCAsBIomN,MAAIpmN,EAAEzB,GAAI,4BAANyB,GAAEzB,EAA8C;0BAtBxD,SAwBIkjiB,SAAOzhiB,GAAI,oBAAJA,EAAkD;0BAxB7D,SA0BIqmN,MAAIrmN,EAAEzB,GAAI,4BAANyB,GAAEzB,EAA8C;0BA1BxD,SA4BI26I,MAAIl5I,GAAI,iBAAJA,EAA4C;0BA5BpD,SA8BI0hiB,KAAM1hiB;4BACR,SADQA;8BAGJ,QAHIA,KAG0B,gCADvB65D;8BACQ,kBA7JnB0zD,SA6JmB;4BAEf,eAEShvH;oDAIT,OAJSA,CAIR;8BADY,qBApKjBw0hB,gBAiKax0hB,EAPLyB;8BAUS;4BALb;;6BAGiC,iCAR7BA;6BAQF;;gCAlKNm+hB;;mCAkKiC;;4BAA3B,iDAGD;0BAzCP;2BA2CIwD;;;+B,IAEY5jiB;+BACT;iCAAQ,IAAJiC,EAAI,0BADCjC;iCAEF,6BADHiC;mCAC2C,QAFtCjC;iCAEuB,OAD5BiC;0BA9CX,SAmEI4hiB,WAAW5hiB;4BACb,eAES6hiB;6CAKAtjiB;gCAUT;oDA1CEojiB;iCA0CF;;oCA1CEA;;sCkIpNN5yd,iBlIoNM4yd;;iCA0CM,mBAlBK3hiB;gCAkBL,eACCuD;wDAET,UAbShF,EALAsjiB,UAkBK;kCADD;;+CAnNb9O,gBAuMSx0hB,EAYoB,iBADpBgF,EADLpD;kCAES;gCADyB;wDAnBzBH,EAkBTG;iCACS,uBAhBJ0hiB;gCAgBI,iDAEC;8BARgB;;uEAVrBA;+BAWS,0CAdL7hiB;8BAcK;oCAAJA,WADI6hiB;6CAEU,iCADd7hiB;gCAEC;oDAxCb2hiB;iCAwCa;;oCAxCbA;;sCkIpNN5yd,iBlIoNM4yd;;iCAwCyB,sCAFb3hiB;gCAEa;8BAPzB;;;wDAIgB27hB,eACJ57X;+BALZ;;kCAxMFo+X;;;;8BAwME;4BARF;;;6BAI4B,iCALfn+hB;6BAIX;;gCAnMFm+hB;;mCAoMwB;;4BADtB,iDAiBY;0BAxFhB,SA0FI0D,UAAU7hiB;4BACZ,sB,IACWG;4BAAI,qBAFHH;4BAEG,iDACd;;;;;;;;;;8BAGO;;;+BAEC,6BAFLA;+BAGiB,gCAHjBA;8BAGW,mCADXk5B;gCAEJ;iCAAI6wF;2CAAIk6C;oCAII;mDAGUjkK,GACT,iBADSA,EACE;oCADE;;;wCAvO1Bm+hB,cAuO+C,0BAPvCl6X,MAHJ69X;qCAKA;;;0CknBwLN5M;0ClnBvLQ;4CAnONzzO;oCAkOI,OADEsgP,MAUE;gCAED,OAfH7ogB;kCAgBJ;sDAvEEyogB;mCAuEF;;sCAvEEA;;wCkIpNN5yd,iBlIoNM4yd;;kCAuEU,OAAK,gCAhBbzogB;;;;4DAgB+D;mCASjEwgD,QAAS0jd,WAAWl9hB,EAAEC;4BAmBX,GAnBFi9hB;8BAoBX;;;kCAIqB;oDAxBVA;mCAwBC;mEAxBYj9hB;mCAwBZ,uCAxBUD;kCAwBV,eAECk/W;oCAED;mDAFCA,MA1BFg+K;qCA4BC;;;0CACCt6hB,WAALqT,WAFQmnhB,cAEHx6hB,EAFL0lC,OAEAryB;;oCkHoLR;qClHjLU;;sCALMmnhB;sCAAR90f;mDAOKy5f;qDACD5E,MACR,UADQA,KARIC,cASW;sCADC;;8DARZA,cAOH2E;sCACe;oCADC,iCAPrBz5f;oCAOqB,iDAEF;kCAVN,2BAHbw5f,aAvBG5E;kCA0BU,iDAUM;8BAd3B;kDA7QAlK,WA6Qc;;0DAce;mCAGzBx4c,GAAI0id,WAAYp9hB,EAAazB;4B,SAAbyB,cAAazB;kCAER2tC,IAFQ3tC,KAEpBs7D,IAFO75D;8BAGP,mBAAC,yBADD65D,IAAY3tB;+BAEnB,kBAlSNqhF;;4BAoSM;8B,IAEW8va;4BAAY,kBARrBD,WAAYp9hB,EAAazB;4BAQJ,iDACI;mCAE7B2jiB,IAAK9E,WAAYp9hB,EAAazB;4B,SAAbyB,cAAazB;kCAET2tC,IAFS3tC,KAErBs7D,IAFQ75D;8BAGR,mBAAC,yBADD65D,IAAY3tB;+BAEnB,kBA7SNqhF;;4BA+SM;8B,IAEW+va;;4BAAqB,kBAR7BF,WAAYp9hB,EAAazB;4BAQI,iDACI;mCAEtC4jiB,GAAI/E,WAAWp9hB,EAAEzB,GAAI,UAAjB6+hB,WAAa7+hB,EAAFyB,EAAwB;mCAEvCoiiB,IAAKhF,WAAWp9hB,EAAEzB,GAAI,WAAjB6+hB,WAAa7+hB,EAAFyB,EAAyB;mCAEzCqiiB,SAAU9/hB;4BACZ,SADYA;8BAGR,IADO24E,IAFC34E;8BAGE,4CADH24E;gCAGH,oCAHGA;gCAEL;8BACwB,kBA7ThCqyC;4BAgUM,uBARQhrH,EAQiB;mCAE3BgjH,QAAMvlH,EAAEzB;4BAAI,kBAlUhBs0hB,mBAkUU7yhB,EAAEzB,EAA0D;mCAElE+jiB,UAAWtiiB,EAAQzB;4B,SAARyB,cAAQzB;kCAEE2tC,IAFF3tC,KAEVs7D,IAFE75D;8BAGC,6BADH65D,IAAY3tB;gCAGK;iEAHLA;iCAGf,gCAHG2tB;gCAEL;8BAC4C,kBAzUpD0zD;4BA4UM;qCA5UN2la;;qDA6UmB,iCATJlzhB,EAAQzB,GASK,EAAE;0CA/C1Bm8E,GAWAwnd,IAWAC,GAEAC,IAEAC,SAUA98a,QAEA+8a;mCAsBQC;4BAAkC;qCAEpC,IADEviiB,WACF,UADEA;;;;qCAEYgjH,aAAHzkH;iCACS,6BADTA,MACS,UADNykH;mCAIRz/G;+BACO,oCADPA;;;;qCAFMknH,aAAHv+E;iCACU,6BADVA,QACU,UADPu+E;mCAIPD;+BACO,oCADPA,UACoB;mCAEvBg4a;4BAEN;qCAEI,IADExiiB,WACF,kCADEA;;+BAGF;;;0DADE8xE,GALA0wd;+BAMF;;+BAEA;;;0DADCvmZ,KAPCumZ;+BAQF,+CAA2C;mCAG7CC,UAAU3wd,GAAGw5C;4BACnB,GADgBx5C;;;iDAAGw5C;;;;oCASX;;6CATWA;wEAWf;;kCAXeA;;6CAOX;;sCAPWA,MAKf;iCALeA;;kCAeI,IADJo3a,KAdAp3a,MAeI,sBADJo3a;kCACX;gCAFgB,IADJC,KAZDr3a,MAaK,sBADJq3a;gCACX;;6BAVL,KAHer3a,GAGf;4BAcA,sBAAyD;mCAlD7Ds3a,mBAoDG9wd,GACAw5C;4BAGD,wBAAW,UAJVx5C,GACAw5C,KAGiE;;2BAEpEu3a;;;8CAEuC9kiB;iCACjC;mEADiCA;kCACjC;;;0CqHqYVitE,kBrHnY+C;+BAHzC;mCAMF83d,YAAY9iiB;4BACd,eAESwF;oDAUT,OAVSA,GAUN;8BALD;;kDAhBAq9hB;;;;;oCkIvbN9zd,iBlIubM8zd;;+BAgBA,yBACE,MANKr9hB;+BAKP;;4BAJA;mDAJYxF;6BAIZ,uCsmBjJA8shB;4BtmBiJA,iDASC;mCAEDiW,SAAQlliB,OAAOmC;4BACjB,SAEMgjiB,cAAYhjiB;8BACd,kBAraJ4sH,aAqaI,YADc5sH,aAC6C;4BAH/D,GADUnC;6BAUJ;uCAVIA;8BAUS,eADV22H;8BAEA;+BADC7uB;iCAPJq9b;iD,OA5XN9C,sBAmYUv6b;8BARN0nS,OACE41J;;iCADF51J,OACE21J;4BAWN,kBA/aAp2a,aA+aA,OAdiB5sH,G2H5crB8rE,G3H0diC;;;;;;;;;;;;;;;;;;;;;;;;;;6BA/R3B6E;6BAEAy1I;6BAEAq7U;6BAEAp7U;6BAEAntE;6BAEAwoZ;6BAaAC;6BAwBAC;6BAuBAC;6BA9KF3B;6BA6MEjF;6BAEAvhd;;6BAyFAkpd;6BA0DAC;6BAQAC;6BAeAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAlTFljX;6BAKA8e;6BAOA4iW;6BAKArvV;;6BAWAsvV;;2BA2SA0B;mCAEAC,mBAEavwd,GAAGF;4BADlB,iCACW9pC,MAAI4oB,QAAGD;4BAChB;8BAEI,KAHSC,UAAGD,KAGZ,OAHK3oB;8BAKY;6CALR4oB,KADX4xe;+BAMmB;;+BACA,gBANL7xe,KADd6xe;+BAOmB;;2CADbE,KACAC,MANC36f;;+BAAI4oB,KAKC6xe;+BALE9xe;uCASP;mCAETiye,QAAM5wd,GAAGF;4BACX;;8BAE+C,4BAClB,2BAD4Bx5C;8BAC5C,kCADwCD,UACP;4BAF9C;qCAvcE0zF;qCAucF,WAvcEmja,MAwcA,OAAe,mBAHTl9c,GAAGF;2CAKI;mCAEb+wd,kBAAkB7wd,GAAGF;4BACvB;;8BAEsD;;;+BAItB,2BAJgCx5C;+BAI1C,2BAJsCD;+BAItC;;oCACHkgH,aAAHv3I;sDAoBT,iCApBSA,EAoBe;gCADX,4BApBTo2B,EACQmhH,IAAHv3I;gCAmBI;8BAjBJ;;+BAIC;;kCAX2Cq3B;kCAAIC;2CAWXD,GAAGC;oCACtB;+EADmBD;qCAEvB,0CAF0BC;oCAE1B;0CAALA,YADID;qEACJC;;;oEADI8igB,eACJ36X;;8BAFR;+BAMiB;gCADd77J;;0CACQA;mCACN,iBADMA,oBACT,YAEiB;4CADf;4CACG,WAhBbwyB,EAgByB;gCAHF,gCADdxyB;;;yCAMD,WAlBRwyB;8BAGK,UADP,WArdPmmgB;8BAqdO,8CAmBwB;4BA1BjC;qCA9cExxa;qCA8cF,WA9cEmja,MA+cA,OAAsB,mBAHJl9c,GAAGF;2CA6BR;mCAGXgxd,QAAM9wd,GAAGF;4BACX;8BAC4C;;;+BACP,2BADiBx5C;+BACjC,2BAD6BD;8BAC7B,8CAAiC;4BADtD,iBAAc,mBAFN25C,GAAGF;4BAIR,6BAhfHogd,wBAgf6C;;uCAJ3C4Q;;;6BAtDFR;6BAEAC;6BAaAK;6BAOAC;;;;;;;;;;;8BAyCJ,eAGW5liB;gCACG;mEADHA,OgG2hCP+gK;iChGzhCM,kCAFC/gK,OgG2hCP+gK;gChGzhCM;sCAAJrgK,WADIyB,uBACJzB;;;gEADI+iK,eACJ+6X;;;+BALFx8W;8DzFvaFrgB;;;;;;;;;;uCyFuaEqgB;;yCAQmB;;;0CACE;2DAAgB,gCADZ7/K,EAAGzB;0CAKlB;;0CAGG;kDARYyB,kB,OAnhB3B+0X;0CAshBI;;;+CknBtGJmgK;+ClnBuGM,WAjgBJzzO,MAmgBO,+BANqBljT;yCAYrB,GAVHm8E,OADAipd;uEAWmC;mCAI7CC,KAAoBzjiB,QACd+6hB,KAAgBC;4B,IADyBz9R;;8BAEvB;gDAFuBA,OACzCw9R;+BACkB;;+BACA,mBAHuBx9R,OACzBy9R;+BAEE;;6CACb31hB;gC,IAOHw+hB;+CAFEA;kCAeR,kBAxB6CtmS,UAIpCl4P,IAKDw+hB,SAewB;;kCAN9B,UAPIA;kCAOJ,UAEI,IADGC,mBACH,OADGA;kCAGH,kBAtBuCvmS,SAsBL;;kC;4CAXlCsmS,gBATKH;4CASLG,gBARKF;gCAYI;8EAfG3jiB;iCAad;;oCA1hBAqyhB;;;8BAmhBA;;;kCAJAiM;kCACAsF;2CAGgD7I,KAAMC,QACjD,YAPSh7hB,EAMkC+6hB,KAAMC,OAC9B;+BAF1B;4EAmB8B;8CAriB5BjI,WqH6vBF5nd;mCrHrNE44d,qBAAqB9K,KAAKC,KAAKpD,QAAQ9+f;4BACzC,eAGaA;6CACDhe;gCACR,kCANwBkghB,KAKhBlghB,OACkB;8BADT,qBALY88gB,QAIpB9+f;8BACQ;4BADA;;;gCA5iBnBgngB,cA4iBwC,0BAJDhngB,QAAlBiigB;6BAErB;;;kCknBhJFlE;4BlnBgJE,OADEiP,cAQU;mCAEZC;4BAAsB73f,UACtB6sf,KAAKC,KAAKpD,QAAQoO,UAAUltgB;4BAC9B,GAFwBoV;6BAAY,QAAZA,iBAAYypC;;iCAAZk6C;4BAExB;6BAF8D,mBAARv/C,MAAQ0vB;;iCAAR1vB;4BAEjC;qDADnByod,KAAKC,KAAKpD,QAAkB9+f;6BAID,cAJTktgB,UAAUltgB;6BAID;;6BAAlBke;;8BADY,kBAJ+Bs7B,MAK3C6pG,gBAAC;;qCAADzyH,MALamoE,UAKb+C,sCAAmC;;mCAhB5Cixa,qBAWAE;;2BJ5jBJ1td;;;;;;;;;;;;;;;;;;;;kCsnB9CEsnd;kCAEAC;kCAIA1J;kCAGAC;kCAGAC;;kCAkBAC;kCAsBAG;kCAOAC;kCAuBAC;;;kCA4WAtzb;kCAGAg2b;kCAGAjB;kCAEAoB;kCAGAF;kCAGApB;kCAGAtB;kCAEAE;kCAEAD;kCAEAjyf;kCAEAmyf;;;;;;;kClnBtbApgK;;;;mCAsBEpoQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAIA0xa;;mCA4IE1td;mCAqGAsqd;;;;;;;;;;;mCAvOF0B;;mCAQAqD;mCAWAC;mCAOAC;mCASAE;;;;;;kCAjDAzza;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAIA0xa;;kCA4IE1td;;;;;;;;;;;kCAlIFgsd;;kCAQAqD;kCAWAC;kCAOAC;kCASAE;;;kCA4dNwD;;;uBAplBF;;;;;;;;;;;;;;;;;;;;mCJkGQe,iBAAiB9hiB;4BAAsB,iDAAtBA,GAAiD;mCAElE+hiB,iBAAiB/hiB;gCACR9E,IAAE8miB,4BAAal1e;4BACxB;8BAAG,mBADM5xD,kBACsB,OADP4xD;8BAIjB;;oDALU9sD,EACR9E;kCAI+B,SAJhB4xD,MAAbk1e;kCAAal1e;+BAMI,wBANjBk1e;+BAMiB,IANnB9miB;;+BAAE8miB;+BAAal1e,MAGlBkgB;uCAKiC;0BAMhC;;;;;;;;;;;;;;;;;;;6BAjBP80d;6BAEAC;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAeO;mCAEPzrZ,IAAIn5I;4BAAO,wBAAPA;qCAAyB;qCAAgC,iBAAzDA,EAA8D;0BAF3D,SAKP6kN,IAAI7kN,EAAEzB,GAAU,wBAAZyB,EAAY,IAAVzB,GAAiB;0BALhB,SAOPwmiB,SAAO/kiB,GAAI,8BAAJA,EAAc;0BAPd,SASPqtY,OAAOrtY;4BACD,IAAJ6C,EAAI,qBADC7C;4BACD;oDACuBjC,GAAK,4BADhC8E,EAC2B9E,EAAwB,EAAC;0BAX/C,SA4CPojiB,QAxBEhE;;;;gCAFK;iCADAj+S;iCAAL/+O;yCACgC;iCAA3B;;;uCADA++O;;8BADH,WAI8B;0BApB3B,SA8CPlpI,UAAQpjC,GAAGF;4BAAmC;wDAAnCA;6BAAqB,2BAAxBE;4BAAwB,yCAA4B;0BA9CrD,SAgDPs3C,YAAY3pH,EAAEP;4BACqC,+BADrCA;4BACoB,sBADtBO,EACsB,6BAA8B;0BAEzD,SAAPw1F,Y,OsLcFk0B,QtLjBEC;0BAGO;0BAEY,SAAnB86a;4B,OkGOEx1a;0BlGPiB;0BAEA,SAAnBy1a;4B,OkGKEz1a;0BlGHU,SDTpB0+Z;4B,OmGYU1+Z,UrG6HGk7Z,aGpILsa;0BAMY,SDXpBE;4B,OmGYU11a,UlGLFy1a,mBHkIKxa;;;;;;;;;;8BG3HP,eAGUvrS;gCAGJ;qDAAC,QAHGA;iCAEJ,oBAAC,QAFGA;iCAEJ;;iCADS7pM;;oD8GtJb+xI,W9GsJapR,YAAM;;yCAANvuH,M8GtJby/H,a9GsJaj0D,oCAE0B;8BAJrC;;;;;;;;;;;yCrF9BJusC;kDqF8B+Bx/J,GAAK,0BAALA,EoGu6C7B4+J,epGv6CyD;6CAIhB;mCFtJ/Csd;4B,kBAxBF+xW,aC0JAiX,ODlIE3hiB;gD,OAxBF4qhB,aC0JAD,KDlIE3rhB;mCAEI1E,cAAW,sBAAe;0BAIhB;mCAEVkrJ,aAA8Cg+E;4B,IAATqlF;qCAE/Bz4F;8B;8BAAK;;;;;;qCAEP,IADe7uG,eACf,8BADeA;mCAGf;;;;qCAEA,IADU2yF;qCACV,mCARiC20G,eAOvB30G;mCAGV,kBAViC20G;;;;qCAgBjC,qBAAiB;qCAAjB;qEAAC,uBADgB+4O;mCAGD;mCAAhB;;;;qCANA;;sCAAY,qCADKC;;;mCAGjB;6CAI6B;mCAhB3BzxU,MAFwCoT;0BAFpC,SAwBVq1B,SAAS54P,GAAI,UAAJA,EAAc;0BAxBb,SA2BJmwN;;;;;;;;;gCAEF,IADOnwN;gCACN;oEAAmB,yBADbA;;;gCAGP,IADEjB;gCACF,mCADEA;;gCAKe;iCADV22B;iCAAJD;iCACc,oCADdA;iCACc;;4CAAb+ra;yCAAIqgG;yCADDnsgB;;;gCADJ;iCADK31B;iCAAHhD;iCACF,yBADEA;;yCAAGgD;;0BAhCF,SA0BV+hiB,sBAYE/hiB;4BACU;oDADVA;6BACU;;6BACD,qBADPC;4BAC+C,UAA/CsvE,IADGm6C,GAEA;0BAzCG,SAiFV9/C,SAtCIntE,EAAEzB;4BACR,SADMyB;8BAEe,IAAV65D,IAFL75D,KAEsB,oBAAjB65D,WACP,OAHIt7D;;8BAIa,IAAP2tC,IAJN3tC;8BAIoB,oBAAd2tC,WACV,OALElsC;;oCAMiB21E,IANfp3E,KAMG+gG,IANLt/F,KAOO,2BADFs/F,IAAY3pB;4BAGnB,UATE31E,EAAEzB,EASM;0BApDF,SAsDVumH,MAAM9kH,EAAEO;4BACA,oBADAA,SACmB;4BACd,oBAFLA,SAEuB,OAFzBP;4BAIN,OAJMA;qCAMF,IADO65D,IALL75D,KAMO,2BADF65D,IALHt5D;;mCAOK++F,IAPPt/F,KAOGu0E,GAPHv0E,KAQK,2BADFu0E,GAPDh0E,GAOK++F;sCAGT,UAVI/+F,EAAFP,GAUU;0BAEC,IAAjBuliB,QAAiB;mCAiBjBxgb,SAfInyC,GAAGF;4B,SAAHE,eAAGF;kCAEcn0E,EAFdm0E,MAEE1yE,EAFL4yE,MAGO,2BADF5yE,EAAYzB;4BAGZ,gBALLq0E,GAKK,MALFF,GAFP6yd,SAO2B;0BAPV,SASjBC,mBAAoBC;4BACA;qCADAA;;8CAC8B78f;uCAAL,0BACnC,gBADwCA,IACxC,MADgDrlC,EAAHC,GAChC;0BAXN,SAajBk9B,IAAIksE;4BAAwB;4CAAxBA,YAA6CrqG,GAAK,gBAALA,EAAmB,GAAE;0BAbrD,SAmBjByiH,SAAMxhH,EAAExD,GAAI,aAAJA,EAAFwD,EAAe;0BAnBJ,SAqBjBwlC,OAAOhpC,GAAI,aAAJA,EArBPuliB,QAqB0B;mCEuExBG,YAAYniiB;4BACC,gCADDA,GACC;;qCAARkiiB,sBACK,IAASljiB,WAAT,OAASA,CAAQ,EAAM;mCAEjC48hB;4BAAoC,mBAElC,IADOn/hB,WACP,UADOA,GAGP,QAAI;mCASVukO;4BDnDJ,SCmDIhhO,KDnDJ,0CCmDIA;4BDnDJ;yCCmDIA;6BDnDJ;;;;;;;;;;;;;;;sCuH4WQ;wCvH5WR;;;;;;;;;0FCmDIA,EDjDa;mDAFjB06I;;;;;;0CACI;oEADJF;;4CACI;;6CAhHA;;yDADkBx9I;mD,gBACR0kK;qDAA+B,qBAA/BA,KDnBZiX,UCkIFgpX,OAhHsB3kiB;qDACW,qBAAnB0kK;kDADQ1kK;4CAiHlBoliB;;yCAAwB;mEAD5B5nZ;;2CAC4B;;qD0HsatBv7B,eA2FAP,e1HjgBsBg7E;;wCAD5B;;;;sFCmDI15L;8BDnDJ;6ECmDIA;8BDnDJ,UACIoiiB,eADJ,MAC4BC;;8DAAxBE;sDAAwBD;8BAD5B;;uCCmDItiiB;;iDDlDAoiiB;oDAAwBC;mCCkDxBh/W;4BDnDJ;0CCmDIrkL;6BDnDJ,QCmDIA;6BDlDwB2D,I0H4atB06G,eAsFAH,e1HlgBsBslb;;6BAAxBvwf,MA5EA46e,cDvDFlga,UCkIFg+Z,KACI8X;iEAAwB9mZ;sCAAxBC;;2BA9GiB8mZ;;6BA6GrBf;;;;;;;;;;;;;;;;;;6BC9CQ/rZ;;;;;;;;;mCAqGAqpZ,aAAkB7R;4B,IAAXG;4BDlKX;8CAAU7rX;uCAAc,qBAAdA,KCkKC6rX;;gDyMsIa97Z,a1MxS8B,WAA5CiwC,KAFOghY,GCoKKtV;;;;;;8BAvDlBzma;8BAGAn0B;8BALAigB;8BDERkvb;;;;;;;;;;;;;;;;8BC9CQ/rZ;;;;;;;;;8BAKA4rZ;;;;8BAFAlgV;;;8BALA7/M;8BASAqoY;8BAmCA8zJ;;;;8BF9HNjlX;;8BAEIr+K;;8BAMAkrJ;8BAsBAqzG;8BAEAkpS;8BAuDAn4d;8BAMAnkC;8BAjCA87E;8BA6BAC;8BARAygb;8BAIA9kgB;8BAEAysC;8BAEA43C;8BAEAC;8BEyEE0gb;8BAIAvG;;;8BAaJ56T;;8BDnCEysT;8BAFAD;8BAIAE;8BAEAhvf;8BAEAivf;8BCiCEsR;2BC6HF0D;mCAEAlI,sBAAsBh7hB;4BAAI,0BAAJA,GAAI,QAA2B;mCAErDi7hB;4BAA6B,iCAAyB;;;;;;2BArPpD1ud,kB4mB8F0B2kd;gD5mB5F1BF,QAFAzkd,IAIA0kd;2B4mB0F0Bxna;;;;;;;;;;;mC5mBpF5Bkka,UAAWpthB;4BACb,SAAIoxhB,QAAQ52hB,GAAI,0BADHwF,EACDxF,EAAoC;4BAAhD;0EAAI42hB,SAC8C;mCAEhDwR,cAAcnmiB,EAAE6iB;4BACR,UADQA;+BAAF7iB;8BAGZ,QAHYA,KAGF,cAHI6iB;8BAId,cAJcA;8BAGd,IAEItkB,EAAI,MAHLs7D,IAGqB,UALVh3C;8BAMd,cANcA,MAGV9H;8BAGJ,UANc8H,SAKVtkB;4BAIJ,UATcskB,QASD;mCAEfujhB,YAAUpmiB;4BACZ;6CACOO;sCACyB,2BAHpBP,GAELO,GACyB;gDAAxBk8D,MACI,EAAE;mCAEZ62d,QAAQtzhB;4BACV;6CACOO;sCACa,IAAZ8liB,UADD9liB;sCAGD;8CAHCA;8CAGD;;kDACgB;yDAJfA;mDAsBO,gBAtBPA,EAsB8B,UArB7B8liB,aAkBM3+e,QAfAtzC;mDAiBF,uBAAY,WAvBdpU;mDAuBE;yDADOzB,CAIR,GAAI,EAAE;mCAEf20hB,WAAWl7a,IAAIz0G;4BACjB;6CACOhD;sCACS,IAAR6T,MADD7T;sCACS,eACqCyC;wCAC7C,kBAD6CA,kBAJxCg1G,QAKkC;sCAD3C,OAFGz3G;sCAI4B;uDAJ5BA,KAFMy3G,IAGL5jG;uCAGQ,uBAAY,WANX7Q;uCAMD;;qDACqCP;wCAC7C,kBAD6CA,gBAPxCg1G,QAQgC;sCADzC,OALGz3G;sCAOF,oBAHGk8D,IAHAroD,OAGI7V,EAGyB,EAAE;mCAErCyzhB,qBAA4BzxhB;4B,IAAXuwhB;;8BAGf;qCAHeA;+BAGgC,2BAHrBvwhB,GAEpB4nH;+BACwB;;+BAHf2oa;8BAQM;+BAJVwV,KAJIxV;+BAIVyV,KAJUzV;+BAQM,2BARKvwhB,GAIf+liB;+BAIP;+BADiB,2BAPK/liB,GAIrBgmiB;+BAGD;;+BAPWzV;8BAaM;+BAJT0V,OATG1V;+BAST2V,OATS3V;+BAaM,2BAbKvwhB,GASdimiB;+BAIR;+BADiB,2BAZKjmiB,GASpBkmiB;+BAGF;;+BAZW3V;8BAmBM;+BALL4V,KAdD5V;+BAcL6V,OAdK7V;+BAcX8V,OAdW9V;+BAmBM,2BAnBKvwhB,GAcVmmiB;+BAKZ;+BADiB,2BAlBKnmiB,GAchBomiB;+BAIN;+BADiB,2BAjBKpmiB,GActBqmiB;+BAGA;;4BAM8B;yCAvBRrmiB;6BFjH9B;;yCAAU0kK;kCACN,qBADMA,KEiHS6rX;;2CwMoLK97Z;;oD1MpSezxH;6CAAgB,qBAD7C0hK,KAC6B1hK,EAF9BP;6CAE8C,kBAD7CiiK,WACyD;;;;;;;wDEsI5DrpB;2C;;oDF1GPw0Y;;;sDE0GOx0Y,mBAA8C;;;;mCAQnD0oZ,eAAe9giB;4BACjB;6CACOjD;sCACA,aADAA,GAGD,UAHCA;sCAIE,eAC8CyC,GAAK,kBAALA,OAPtCQ,GAOqD;sCAAhE,OALCjD;sCAOC,UAPDA;sCAOC;kDA5MRkzhB;;yCA8MkC;0DAT3BlzhB;oDASQ,kCAXEiD;;;;;sCAaT;wCAWE;8DAxBOA,EAEVjD;yCAqBG,kBAAgB,kCAvBTiD;yCAsBP,sBApBHjD;yCAmBG,wCArBOiD;wCAaT;sCAYK,iBAvBNjD;wCAwBC;;mDAAyCsmiB;4CACf;6CA/BE/U,OA8Ba+U;6CA9BzBC,EA8ByBD;6CA/Bf3V,WAKjB1thB;6CALUsthB,MAKVtthB;6CA2BiB,MAzB3BjD;6CALK,cAFsB2whB;6CAGG,4BADjCx8e;4CACiC,kBAFboyf,WAAYhV,OADThB,MAgCmC;wCADtD,OAxBDvwhB;sCAyByD,UAzBzDA,IA0BQ,EAAE;mCAEfwmiB,aAAa1miB,EAAEkD;4BACjB;6CACOhD;sCACW;+CADXA;uCAIC,kBAJDA,KAFQF,EAGP8iH;uCAEF,uBAAY,WALD5/G;uCAKX;;sCAGD,sBAJGk5D,IADA0mD,SACI5kH,EAI6B,EAAE;mCAEzC87E,aASwClkE;;;6BAJnC6sB;6BACA2yf;6BAFAC;6BADAa;6BADAZ;;6CASAt1hB;sCACA,GADAA;wCAES,IAANwa,IAAM,UAFTxa;wCAGD,cAHCA;wCAES;yCAIiC,MAN1CA;yCAM4B,gBAN5BA;yCAMG,6BARgC4V;wCAQhC;yCAGE,eALFuS,MAIK1oB;;6CAJL0oB,MAOE,SACE,aACE,eAbTnoB;wCAeD,cAfCA,EAEGwa;wCAAM;yCAgBH;oDAlBNxa;;4D,OinBnKP+xhB,gBjnBmKO/xhB;yCAyBmB,mBAjCnBk2hB,gBAYG/tgB;yCAqBgB;;yCACD,gBADbuqN,OARA+sE;yCAUJ,iBApCD61O,iBAmCKxG,WADQ/7c;yCAKF,yBAAY,WApCvBtwC,MAsBGmlF,QAhBH5nH;yCA8BW;kDAARk8D,OAdA0rD,SAZAz/F;sCAiCE;wDA1CLitgB;uCAuCC;;0CA3CDE;;2CA4CK;6CA1CLD;6DA2CS,iBApCTr1hB,IAoCiC;;uCAItB,yBAAY,WA9CvByiC,MAuCGm9G,QAjCH5/I;uCAwCW;gDAARi8D,OAPA2jF,SAQ6B;mCAErC0xY;4BACF;6CAActxhB;sC,IinB7KGsxhB,ejnB6KHtxhB,iBinB7KGsxhB,kBjnB6KiC,EAAC;mCAEjDx0M,OAAOr6U,GAAiB,UAAjBA,EAA2B;mCAElC4vhB,iBAAmBrmf;4B,GAAAA;6BAAS,QAATA,cAASypC;;yCAATkoF,uB;4BAAmB;6BAC9B,mBAAN8xF,IAAM3vJ;;iCAAN2vJ,mBAAmBh4I,IAAK/8F,KAAQ,QAAE;4BAA5B,IAEN1S;4BAFM,SAGNyphB,eAAgBgV,kBAAkBxjiB;8BACpC,GADkBwjiB;;;iCAILhvb;iCAAL/8F;iCACAurB,oBADAvrB;gCAEJ,WATF+0O,OAQMxpN,OADKwxE,IALXzvG;8BAQgB,iBAPkB/E,IAJjB06J;8BAWD,WARhB31J;8BAQgB,QAAuC;4BAGzD;6BADEsa;8BACF;;gCA6DA2ugB;;;;;mCAvEEQ;;;;;;4BAcI,iBAAY,iBALhBnvgB;4BAKI,OAfJta;;;;;6BAsEFmrhB;6B4mBlL4Bjna;;;;;;;;;;;6B5mBpF5Bkka;6BAIAwV;6BAWAC;6BAMA9S;6BA4BAJ;6BAWAlB;6BA8BAsS;6BA8BAyC;6BAUA1sd;6BAsDAw3c;6BAGAx0M;6BAEAu1M;2BAiEIqU;;2BALAE;;;;;;;;;;;;;;;;;;;;mCAiBJQ,WAAW9V,eAAez9gB;4BAC5B;;qCAHEo9gB;qCAEWK;qCAFXL;;;;;;wCAE0Bp9gB;;uCAGJ;mCAGpBqhL;4BAAMm8V;4BAAYz6f;4BAAO06f;4BAAgBv+c;4BAAKw+c;4BAC5Cvlf;4BAA2C42E;4BAAS8ua;4BACrDD;;4BACH,GAFIzlf;6BAAmB,QAAnBA,wBAAmBypC;;iCAAnB+7c,iBA1XN0B;4BA4XE;8CADGzB,kBA3CHkU;6BAoDA;8BAVInU,iBAAoDE,aAApDF;4BAWJ;8BAZgDD;uCActCA;gCACN,yCADMA,OAdFF,WAe2D;4BAZnE;6BAaIiV;8BACF;gCwMjDoB7xa;gCxMgC0B88Z;yCAiBpB+V;kCACtB;;;;;;;;;;;;;;2CDpVRnxd;;;;;;;;0CCmV8Bmxd,IAQe;4BARzC;qCAjBMjW;qCAAYz6f;qCAAO06f;qCAAgBv+c;qCAgBvCuzd;qCALA1U;qCARAyV;qCAF2Czkb;qCAAS8ua;;;uCA2BK;;oCA5B3Dx8V;;;6BAzCFywW;6BAEAlI;6BAEAC;;6BAcItxa;;;;;;;;;;;;;;;;;;;;6BAKAu6a;;6BAQJxT;6BAEAlC;6BAEAmW;;;2BknB3VJG;2BAHAC;2BAFAC;;2BARAC;2BAFAC;2BAFAC;2BAFAC;2BAHAC;;2BAFQhI;;;;;;;;;;;;;;mCJOJhN,gBAAiB31R,IAChB97P;2CACKvB,GACR,OADQA,IACI;4BADA,2BAFOq9P,OAChB97P;4BACS;mCAGVgthB,QAAS2Z,UAAU7qS,IAAI97P;4BACzB,GADW2miB;8BAKP;2CALOA;+BAKP;yCACSvoiB;wDAET,OAFSA,CAER;kCADY,qBAHVwoiB,YAEMxoiB;kCACI;+BADA,sBANI09P,IAMgB,WEqE5BgyR,UF3EgB9thB;8BAMR;4BAHO,uBAHH87P,IAGG,WEwEfgyR,UF3EgB9thB,GAQpB;mCAEHwxhB,cAAexE,QAASzyK,QAAQz+G;4BAG9B,IADE+qS,UACF,QAHa7Z,QAGiB,WE8DzBc;4BF9DL,GAHsBvzK;6BASpB,MAToBA,WACtBusL,YACED,UAMGjliB;;iCAPLkliB,YACED;4BAKA,wBAP4B/qS,IAC9BgrS,SAUe;mCAEjBvK,SAAQvP,QAASzyK,QAAQz+G;2CACnBr9P,GACR,OADQA,IACI;4BADA,wBADFuuhB,QAASzyK,QAAQz+G;4BACf;mCAYVw3L,OAAO3xb,EAAErB;4BAAiB,kBIrC9B+liB,eJqC8B,cAAjB/liB,GAAFqB,EAAsD;mCAE7D4vhB,iBAAiB5vhB,EAAErB;4BACrB,IAAIihH;4BAAJ;8BAOA;uCARmB5/G;gDAQLqrhB;yCAAW,kCAPrBzra,YAOUyra,QAA8C,EAAC;4BAP7D,eAIcvuhB,GACR,gBADQA,GACR,QAAiB;4BAHrB;;yCIhDJ+niB,uCJ6CuBlmiB;4BAGnB,8CAK2D;mCAE3D+whB,OAASv+e,MAAMlxC;4BAAmB,kBI1DtC6kiB,iBJ0DsC,eAAnB7kiB,EAANkxC,OAA4D;mCAErEs+e,YAAat+e,MAAMx0C,EAAEC,EAAEqD;4BAAY,qBAAtBkxC,MAAMx0C,EAAEC,EAAEqD,GAA0C;mCAEjEuvhB,cAAer+e,MAAMx0C,EAAEsD;4BAAY,uBAApBkxC,MAAMx0C,EAAEsD,GAA0C;mCAEjEsvhB,WAAYp+e,MAAMoP;4BACK,qBInEnByqe;4BJmEmB;qCADLzqe;8CACyBtgD,EAAGolC;uCAC5C;gDIpEE0lf;gDJmE0C1lf;;kDAEzB,kBInEzBy/f,iBJmEyB,eAFsB7kiB,EAD/BkxC,OAG4C,EAAE;2CAAE;mCAE5Dm+e,aAAcn+e,MAAM10C,EAAEzB;4B,SAAFyB,cAAEzB;kCAES2tC,IAFT3tC,KAERs7D,IAFM75D;8BAGf,oBADS65D,IAAiB3tB,KACL,kBI1EtBqif;8BJ4EA;;;;;;;;iDAAW3yY;+FAAoD;;8BAA/D;;;;;;;2DAAW+sZ;yGAAoD;;;uCAHrD9ue;uCAAiB3tB;;4BAKrB,yBAPIwI,MAAM10C,EAAEzB,GAOiB;;;;;6BI9EnCsuH;;;;;;;;;;;6BAKRu7a;6BAEAD;6BJAI9U;6BAKAzE;6BAUAwE;6BAaA+K;6BAMA3P;6BAOAt5F;6BAEAi+F;6BI/BJ6U;6BAVAE;6BJmDIjV;6BAEAD;6BAEAD;6BAEAD;6BAKAD;6BIlDJkV;6BAGAD;;;;6BF+DWvY;;;;;;;;;;;;;;;;;;mCG7CP74c,OAAQ12E;4BAEV,IAAI4B;4BAAJ,sBAKA,OALIA,CAKH;4BAFmB;;yCHwCX+thB,OG7CC3vhB,WAKmCA,GAAK,UAALA,GAAK,QAAW;6BAA3D;0EAED;mCAICtF,IAAKkH;kDAEP,uBAFOA,KAEY;4BADN,qBHiCJ8thB;4BGjCI;mCAGXnpY,IAAK3kJ,EAAU5B;kDAEjB,UAFiBA,GAEjB,QAAW;4BADE,qBH6BJ0vhB;4BG7BI;;wCAhBXh5c,OAWAh8E,IAIA6rJ;;2BhnB+lBE1xB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BASA9K;;;;6BATA8K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BASA9K;;;;;;;;;;;;;;;2BknBxpBFigb;2BAEAC;2BAIA1V;2BAGAC;2BAGAC;;2BAkBAC;2BAsBAG;2BAOAC;2BAuBAC;;;2BA4WAtzb;2BAGAg2b;2BAGAjB;2BAEAoB;2BAGAF;2BAGApB;2BAGAtB;2BAEAE;2BAEAD;2BAEAjyf;2BAEAmyf;;;;;;;2BlnBtbApgK;;;;;;;2BAsBEm1K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIA7L;;;;;;;;;;;;;2BAUA1B;;2BAQAqD;2BAWAC;2BAOAC;2BASAE;;;2BA4dNnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qD;;;;;;;;;;;kCknBpkBI+O;kCAEAC;kCAIA1V;kCAGAC;kCAGAC;;kCAkBAC;kCAsBAG;kCAOAC;kCAuBAC;;;kCA4WAtzb;kCAGAg2b;kCAGAjB;kCAEAoB;kCAGAF;kCAGApB;kCAGAtB;kCAEAE;kCAEAD;kCAEAjyf;kCAEAmyf;;;;;;;kClnBtbApgK;;;;;;;kCAsBEm1K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAIA7L;;;;;;;;;;;;;kCAUA1B;;kCAQAqD;kCAWAC;kCAOAC;kCASAE;;;kCA4dNnF;;;;;uBAplBF;;;iCA0rB2BnyhB;0BACvB,UAHE4iiB;0BAGF,UAMI,IADFtgT,gBACE,OADFA,WANqBtiP;0BAKnB,QAEoB;uBAjsB5B;;;;2BA0sBQk1hB;2BAEAC;0BAtBFwN;0BA4B6C;iCA5B7CA;2BA4B6C;2BAA3C;;;;+BAAuB;;;;;;;;;;;0BAAvB,SAIAz+B;4BAAU;mCANVnqf;6B8mBhoBN;;;;;;;0F9mBsoBqC;0BAJ/B,SAMA+ohB,iBAAsB,OARtB/ohB,WAQkD;0BANlD,SAQAgphB;4BACF;yCAXEhphB,kBAWiE;0BATjE,SAWAknG,IAAKksa;4BACP,SADOA,YAGH,IADG/1hB,EAFA+1hB,WAGH,OADG/1hB;4BAGI;8BAOK,OAzBd2iB,aA0BI;;8BAvCiB,aAXvB6ohB;8BA2CM;4BASc;2DAfbzV,QAbLpzgB;6BA4BkB;;uCAAZmkC;4BAAY,OAAJhnD,CAEX;0BA5BH,SA8BA8riB,YAAY9riB,EAAEgnD;4BAChB,WADgBA;4BAER,IAAJ9mD,EAAI,WAFMF;4BAEN,UAlCN6iB,SAkCE3iB,EACO;0BAjCT,SAmCA6riB,aAAuB/oiB;4BACY,SAAjCiC,S,OANF6miB,YAKuB9oiB,SACY,UAAjCiC,EACM;0BArCR;;;;;;;;;;;;;;6BAmDE01B;6BAEA2mE;6BAEA68E;6BAEA7yG;6BAEAkzG;6BAEAz1D;6BAEAv6G;6BAEAyqhB;6BAEAP;6BAEAG;6BAEAgB;0BAvEF,SA4EAz9R,eAA6Bp8P;4BACb;6BADF09P;6BACE,iBADFA,OAAe19P;6BACb;;6BACD,gBADbizO;4BACa,kBAFDyqB,UAEZ2xR,WADQ/7c;0BA7EV;mCA4FE2nd,KAAI96hB,EAAG+6hB,KAAOC;4BAAY,mCAAtBh7hB,EAAG+6hB,KAAOC,QAAiC;0BA5FjD,IA8FEyD;0BA9FF,SAgGEzxd,SAAOntE,EAAEzB;4BAAQ,mCAAVyB,EAAEzB,GAAgB;0BAhG3B,SAoGEwmH,SAAO/kH,EAAEzB;4BAAQ,mCAAVyB,EAAEzB,GAAgB;0BApG3B,SAwGEspH,KAAS7nH,EAAEzB;4BAAQ,oCAAVyB,EAAEzB,GAAkB;0BAxG/B,SA0GE0giB,IAAIn8hB,GAAQ,oCAARA,GAAe;0BA1GrB,SA4GEoqH,IAAIpqH,GAAQ,oCAARA,GAAe;0BA5GrB,SA8GEg4hB,SAAS96hB;4BAAQ,oCAARA,GAAoB;0BA9G/B;;;;mCAsHE2wE,MAAM3wE,EAAEzB;4BAAQ,oCAAVyB,EAAEzB,GAAmB;0BAtH7B;;;;;;;;mCA6IIwqJ,OAAK/oJ;4BAAQ,uCAARA,GAAgB;0BA7IzB,SA+IIizhB,OAAQjzhB;4BAAQ,uCAARA,GAAmB;0BA/I/B;;;6BA6HIglH;6BAEAC;;6BAIAC;6BAEAC;6BAEAo6a;6BAEAv1B;6BAEA81B;6BAEA/2Y;6BAEAkqY;0BA/IJ,SAuJI7ta,SAAMplH,EAAEzB;4BAAQ,uCAAVyB,EAAEzB,GAAe;0BAvJ3B,SAyJIohiB,QAAQ3/hB;4BAAQ,uCAARA,GAAmB;0BAzJ/B,SA2JIw/hB,MAAI18hB;4BAAQ,uCAARA,GAAe;0BA3JvB,SA6JI28hB,MAAI38hB;4BAAQ,uCAARA,GAAe;0BA7JvB,SA+JI+8hB,YAAY/8hB;4BAAQ,uCAARA,GAAuB;0BA/JvC,cAuJIsiH,SAEAu6a,QAEAH,MAEAC,MAEAI;0BA/JJ,SAqKID,MAAI5/hB;4BAAQ,uCAARA,GAAe;0BArKvB,SAuKIqzC,MAAIrzC;4BAAQ,uCAARA,GAAe;0BAvKvB,SA0KM+/hB,MAAI//hB;4BAAQ,0CAARA,GAAsB;0BA1KhC,SA4KMy3O,MAAIz3O;4BAAQ,0CAARA,GAAsB;0BA5KhC;uCA0KM+/hB,MAEAtoT;2BA5KN,SAqKImoT,MAEAvsf;2BAvKJ;;6BAwFEqrf;6BAEAC;6BAEA1D;6BAEA2D;6BAEAzxd;;6BAIA43C;;6BAIA8C;6BAEAo3a;6BAEA/xa;6BAEA4ta;6BAEAsE;6BAEA1hS;6BAEA2hS;6BAEA1ud;;;;2BAtHF;;;;4BAwOM6zJ,iBA/CNxkO,G,gCAAAA,EAAmE;0BAzLnE;2BAyLA;2BAOMu2K,iBAPNjwB;2BAaMivB;2BAFAC;2BAFAC,gBAIAF,WAFAC;2BAMAE;2BAEAE;2BAJAC,gBAIAD,aAFAF;2BAIAI,SAdAS,cAEAd,aAMAI;2BAUAqG;2BAFAhsD;2BAvBNhG;;sEAAmE;;2BAAnExwC;2BAEImmG;2BAEA0hX;2BAuBE0K;2BAEA/hiB;2BAEA2qE;2BAEAvxD;2BAEAo4D;2BAEAvxE;2BAEAgvI;2BAEAl3G;2BAEAy/f;2BAEAG;2BAMA76S;2BAoBAzuH;2BAhBAnzB;2BAIAp8D;2BAEA08E;2BAEAC;2BAEAC;2BAEAC;2BAEA2V;2BAIA6xQ;2BAEA8zJ;2BAEAK;;;6BAtEAjrX;6BAEAd;6BAEAD;6BAEAD;6BAEAM;6BAEAH;6BAEAE;6BAEAE;6BAEA5lD;6BAEAgsD;6BAEA+vX;6BAEA/hiB;6BAEA2qE;6BAEAvxD;6BAEAo4D;6BAEAvxE;6BAEAgvI;6BAEAl3G;6BAEAy/f;6BAEAG;6BAEAr9T;6BApDJwnU;6BAwDIhlT;6BAIA5hJ;6BAIAp8D;6BAEA08E;6BAEAC;6BAEAC;6BAEAC;6BAEA2V;6BAEAjD;6BAEA80Q;6BAEA8zJ;6BAEAK;2BAtEAxsX;2BAEA0B;2BAEAD;2BAEAD;2BAEAK;2BAEAF;2BAEAC;2BAEAE;2BAEA8P;2BAEA29C;2BAEA/lG;2BAEAiM;2BAEAx+F;2BAEA6oJ;2BAEA2oN;2BAEAr3L;2BAEAltE;2BAEAuoZ;2BAEAyK;2BAEAC;2BAEA5mb;2BAEA6mb;2BAEAllT;2BAIAmlT;2BAIAtH;2BAEAj/a;2BAEAC;2BAEAO;2BAEAC;2BAEA+lb;2BAEA54d;2BAEA64d;2BAEAC;2BAEAzJ;;;6BA7EN74a;;;6BAEI21D;6BAEA0hX;;6BAGEvsX;6BAEA0B;6BAEAD;6BAEAD;6BAEAK;6BAEAF;6BAEAC;6BAEAE;6BAEA8P;6BAEA29C;6BAEA/lG;6BAEAiM;6BAEAx+F;6BAEA6oJ;6BAEA2oN;6BAEAr3L;6BAEAltE;6BAEAuoZ;6BAEAyK;6BAEAC;6BAEA5mb;6BAEA6mb;6BAEAllT;6BAIAmlT;6BAIAtH;6BAEAj/a;6BAEAC;6BAEAO;6BAEAC;6BAEA+lb;6BAEA54d;6BAEA64d;6BAEAC;6BAEAzJ;;;;;;;;;;;;;;mCAsCJ7zZ,SAAOnxI;4BAAa,gDAAbA,GAAgC;0BAEjC;;2BAEC;mCAIP2uiB,MAAI1siB,EAAEzB;4BAAQ,wCAAVyB,EAAEzB,GAAiB;0BAJhB,SAMPouiB,SAAO3siB;4BAAQ,wCAARA,GAAkB;0BANlB,SAQP6kN,IAAI7kN,EAAEzB;4BAAQ,wCAAVyB,EAAEzB,GAAiB;0BARhB,SAUPquiB,MAAI5siB;4BAAQ,wCAARA,GAAe;0BAVZ,SAYP6siB,YAAU7siB;4BAAQ,wCAARA,GAAqB;0BAZxB,SAcP8siB,OAAK9siB;4BAAQ,wCAARA,GAAgB;0BAdd,SAgBP4hiB,WAAW5hiB;4BAAQ,wCAARA,GAAsB;0BAhB1B,SAkBPwjiB,QAAMxjiB,EAAEzB;4BAAQ,wCAAVyB,EAAEzB,GAAmB;0BAlBpB,SAoBPwuiB,SAAO/siB,EAAGnC;4BAAa,wCAAhBmC,EAAGnC,QAA+B;0BApBlC,SAsBPujiB,eAAephiB,EAAGnC;4BAAa,wCAAhBmC,EAAGnC,QAAuC;0BAtBlD,SAwBPiliB,YAAY9iiB;4BAAQ,wCAARA,GAAuB;0BAxB5B,SA0BPgtiB,SAAQnviB,OAAOmC;4BAAQ,wCAAfnC,OAAOmC,GAA0B;0BA1BlC,SA4BPitiB,oBAAoBjtiB,EAAGnC;4BAAa,wCAAhBmC,EAAGnC,QAA4C;0BA5B5D,SAiCPm4G,UAASonb,WAAWp9hB,EAAEzB;4BAAQ,wCAArB6+hB,WAAWp9hB,EAAEzB,GAAiC;0BAjChD,SAmCPsgiB,KAAI1+hB,EAAG+6hB,KAAOC;4BAAY,wCAAtBh7hB,EAAG+6hB,KAAOC,QAAiC;0BAnCxC;mCAkDL+G,IAAK9E,WAAWp9hB,EAAEzB;4BAAQ,2CAArB6+hB,WAAWp9hB,EAAEzB,GAA6B;0BAlD1C,SAoDL6jiB,IAAKhF,WAAWp9hB,EAAEzB;4BAAQ,2CAArB6+hB,WAAWp9hB,EAAEzB,GAA6B;0BApD1C,SAsDLm8E,GAAI0id,WAAWp9hB,EAAEzB;4BAAQ,2CAArB6+hB,WAAWp9hB,EAAEzB,GAA4B;0BAtDxC,SAwDL4jiB,GAAI/E,WAAWp9hB,EAAEzB;4BAAQ,2CAArB6+hB,WAAWp9hB,EAAEzB,GAA4B;0BAxDxC,SA0DL+jiB,UAAUtiiB,EAAEzB;4BAAQ,2CAAVyB,EAAEzB,GAAuB;0BA1D9B,SA4DLmliB,QAAM1jiB,EAAEzB;4BAAQ,2CAAVyB,EAAEzB,GAAmB;0BA5DtB,SA8DL8jiB,SAASriiB;4BAAQ,2CAARA,GAAoB;0BA9DxB;uCAkDLkiiB,IAEAE,IAEA1nd,GAEAynd,GAEAG,UAEAoB,QAEArB;2BA9DK;;;6BA5HP2J;6BAEAhniB;;;;;;;;;;;;;;;6BAsHAkqI;6BAEAzB;6BAEAg/Z;6BAIAC;6BAEAC;6BAEA9nV;6BAEA+nV;6BAEAC;6BAEAC;6BAEAlL;6BAEA4B;6BAEAuJ;6BAEA3L;6BAEA0B;6BAEAkK;6BAEAC;6BAKAj3b;6BAEA6ob;6BAEAr4a;6BAEAC;6BAnCAimb;6BAIA7nV;;6BAyDAokK;0BAjEO,SA2EPh3P,QAAMjyH,EAAEzB;4BAAQ,mCAAVyB,EAAEzB,GAAmB;0BA3EpB,SA6EPkliB,kBAAkBzjiB,EAAEzB;4BAAQ,mCAAVyB,EAAEzB,GAA+B;0BA7E5C,SA+EP2kiB,SAASljiB,EAAEzB;4BAAQ,mCAAVyB,EAAEzB,GAAsB;0BA/E1B,SAoFL2uiB,QAAMltiB,EAAEzB;4BAAQ,sCAAVyB,EAAEzB,GAAmB;0BApFtB;uCAoFL2uiB;2BApFK;+BA2EPj7a,QAEAwxa,kBAEAP;0BA/EO,SA6FPiK,eAAenqiB;4BACgB,GAA9B,UAhZH6f;8BAiZU,IAAJ3iB,EAAI,WAFO8C,EAEL,wBAjZZ6f;8BAiZU,OAAJ3iB;4BAED,sBAAgE;0BAjG5D,SAmGPktiB,uBAAqB,iBArZvBvqhB,SAqZiD;0BAnGxC,SAqGPosgB,SAAS9ma;4BAAqB,+CAArBA,OAA6C;0BArG/C,SAuGPhyC,KAAKunL,IAAIv1I;4BAAqB,+CAAzBu1I,IAAIv1I,OAA6C;0BAvG/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA8GLzxC,OAAO1zE;4BAAmC;;6BAAL,oCAA9BA;4BAAmB,8CAAgC;0BA9GrD,SAgHLtI,IAAIkH;4BAAmB,kDAAnBA,GAAwC;0BAhHvC,SAkHL2kJ,IAAI3kJ,EAAE5B;4BAAmB,kDAArB4B,EAAE5B,GAA0C;0BAlH3C,WA8GL02E,OAEAh8E,IAEA6rJ;0BAlHK,SAqHP8nZ,WAAWrriB,EAAE8e;4BAIL,IAAN/G,IAAM,UA3aV8H;4BA4aA,cA5aAA;4BA2aU,IAEN3iB,EAAI,WANK8C;4BAOb,cA9aA6f,SA2aI9H;4BAGJ,OADI7a,CAEH;0BA7HQ;;;6BA6FPitiB;6BAMAC;6BAEAne;6BAEA94c;6BAvNIm/F;6BAEAoC;6BAEAD;6BAEAD;6BAEAK;6BAEAF;6BAEAC;6BAEAE;6BAEAgc;6BAEA7wE;6BAEAoqb;6BAEAC;6BAEArva;6BAEAzc;6BAEAorS;6BAEA2gJ;6BAEAC;6BAEAC;6BAEAC;6BAEAC;6BAEA31a;6BAEA41a;6BAEAC;6BAIAC;6BAIAC;6BAEArnb;6BAEAC;6BAEAqnb;6BAEAC;6BAEA77a;6BAEA5wB;6BAEA0sc;6BAEAC;6BAEAC;;6BA+JJC;0BArHO,SAmIP3lhB,MAAMwsa;4BAAqC,kCAArCA;4BAAqC,qCAAqB;0BAnIzD,iCAmIPxsa,MAEAy/F;0BArIO,SAwITmmb,YAAatriB;4BACf,IAAIuriB,SAndJ7C;4BAmdA,8BAAI6C;4BAAJ;8BAGY,IAANpjb,IAAM,WAJGnoH;8BAIH,qBAHRuriB;8BAOF,OAJIpjb;kCAGDh5F;;8BACH,qBAPEo8gB;8BAOF,MADGp8gB,IAEM;0BAjJA,SAmJTq8gB,qBAAmCj/d,IAA+BvsE;4BACpE,IAAIuriB,SA9dJ7C;4BA8dA,8BAAI6C;4BAAJ;8BAGE;;yCAAoBpjb,KAChB,qBAJFojb,SAIE,OADgBpjb,GAEb;+BAFP,iBAJmC57C,IAI/B,WAJ8DvsE;8BAQlE;kCADGmvB;;8BACH,qBAPEo8gB;8BAOF,MADGp8gB,IAEM;0BA5JA,SA8JT+rgB,SAASxpf,MAAMlxC;4BAAQ,gCAAdkxC,MAAMlxC,GAA0B;0BA9JhC,SAgKTsvhB,WAAYp+e,MAAMlxC;4BAAQ,gCAAdkxC,MAAMlxC,GAA6B;0BAhKtC,SAkKTwvhB,YAAat+e,MAAMx0C,EAAEC,EAAEqD;4BAAQ,gCAAlBkxC,MAAMx0C,EAAEC,EAAEqD,GAAkC;0BAlKhD,SAoKTuvhB,cAAer+e,MAAM10C,EAAEzB;4BAAQ,gCAAhBm2C,MAAM10C,EAAEzB,GAAkC;0BApKhD,SAsKT6niB,YAAUjwhB;4BAAmB,mCAAnBA;4BAAQ,uCAAoC;0BAtK7C,SAwKT07gB;4BAAwB,mCAAmB;0BAxKlC,SA0KTwB,gBAAgB31R,IAAIvnP;4BACG,mCADHA;4BAClB,gCADcunP,WACgC;0BA3KvC,SA6KT2gS,QAAQlohB;4BAAiB,mCAAjBA;4BAAQ,uCAAkC;0BA7KzC,SA+KTy4gB,QAAS2Z,UAAU7qS,IAAI97P;4BACzB,GADW2miB;8BAKP;2CALOA;+BAKC,kBALS7qS,oBAKsB,OALlB97P,CAKmB;8BACxC,WAFG4miB,YACCxoiB;8BACJ,OADIA;4BAFJ,uBAHiB09P,oBAGc,OAHV97P,CAGW,EAGjB;0BArLR,SAuLTy4E,OAAQu0c,QAASzyK,QAAQz+G;4BACb;kDqM11BQ1oI,OrMy1BZ45Z;6BAEI,qBqM31BQ55Z,OrMy1BHmnP;4BAGf,gCAFAssL,UACAlrL,UAFuB7/G,KAGO;0BA1LvB,SA4LT01R,cAAexE,QAASzyK,QAAQz+G;4BACpB;kDqM/1BQ1oI,OrM81BL45Z;6BAEH,qBqMh2BQ55Z,OrM81BImnP;4BAGtB,gCAFAssL,UACAlrL,UAF8B7/G,KAGO;0BA/L9B,IAmMT8wR;0BAnMS,SA8MTt5F,OAAOl1b,EAAEK;4BACH,sBADGA,GAEG,QAlgBZwiB;4BAmgBO,uBAngBPA,YAigBE+zD,IACAusC;4BADI,IAGJjjH,EAAI,WAJCF;4BAKA,uBArgBP6iB,SAkgBEsgG;4BAGK,OADLjjH,CAEH;0BApNU,SAsNTizhB,iBAAiBnzhB,EAAEK;4BACb,IAAJu2E,IAAI,WADav2E,KACb,cADWL,EACf42E,IACM;0BAxNC,SA0NTgtd,KAAIzjiB,EAAGu9P,IAAKw9R,KAAOC;4BAAY,gCAA3Bh7hB,EAAGu9P,IAAKw9R,KAAOC,QAAsC;0BA1NhD,SA4NTjI,WAAW/pR,IAAInpQ;4BACL,UA/gBV6iB,YAghBmB,eAhhBnBA;4BAihBO,qBAjhBPA,YA8gBWsmP,IACT/0P;4BAGJ;8BAFI49gB;uCAE+BhvhB,GAC/B,kBAD+BA,kBAJtBmmQ,QAK8B;4BAJ/B,IAKRjpQ,EAAI,WANSF;4BAOjB;8BALIgyhB;uCAK+BhvhB,GAC/B,kBAD+BA,gBAPtBmmQ,QAQ4B;4BAChC,qBAvhBPtmP,SA+gBEzO;4BAQK,OAHLlU,CAIH;0BAtOU,SAwOTuuiB,eAGEzriB,EAAEhD,EAAEE;4BAEU,IADI25D,IACJ,WAFZ75D,EAAEE,GACkB,kBADtB8C,EACkB62D,IACC;0BA7OZ,SAkPT60e,oBAAoB1riB;4BACtB,IAAI2riB,aAriBF9rhB;4BAqiBF;8BAEQ,IADJ7iB,EACI,WAHcgD;kCAIRsP;yDAIR,WAPFq8hB,aAOE,MAJQr8hB;4BAOR,WAVFq8hB;4BAUE,OATF3uiB,CAYH;0BAhQU,SAkQTs2hB,kBAAmBb,UAAWD,WAAWx1hB;4BAC3C;;uCACI,eAAiCA,SAAQ,mBAARA,EAAwB;uCAAjD,SAAJ65D,W,OA5BN40e,qBA0ByCzuiB;uCAE/B;6DAthBV8riB,YAohBmBrW,UAAWD,WAExB37d,IAC+D,EAAE;0BArQ9D,SA4QT+0e,yBAA0BnZ,UAAWD;4BAErC;gEAF0BC,UAAWD;6BAErC;;qCAKEsZ,YAAYC;8BAGZ;6CALAJ;+BAKA,eAAgC,QAJhCE;8BAIsE,SACnE;8BAA+C,qBAzkBpDhshB;8BAykBoD,eAGvBsU,MAAM6vB;gCAE/B,WAF+BA;gCAE/B,IAEIunf,SAxmBV7C;gCAsmBM,+BAEI6C;gCAFJ,8BAEIA;gCAFJ,kBATUQ,QAOe53gB,QAQT;8BAXgC,kBAVlDo/f,iBAqBoB;4BApBtB,SAsBEJ,mBAAmB6Y;8BAGnB;+CAtBAL;+BAsBA,eAAgC,UArBhCE;8BAqBsE,SACnE;8BAEc;;8CAxBjBA;8BAwBiB;8BAHjB;+BAGiB,QA5lBnBhshB;+BAimBU,eAlCR0zgB,cAiCEvve,QAViBgof;8BAaZ,2BAhCPL;8BAgCO,OAFLnpiB,GAGD;4BApCH,UAKEspiB,YAiBA3Y,mBAgB+B;0BApTxB,SAsTTK,sBAAsBjzhB,EAAEvD;4BAC1B;qDAA+B,4BADPuD,EAAEvD,EAC8B,EAAC;0BAvT9C,SAyTT43hB,iBAAkBnC,UAAWD,WAAWx1hB,EAAEE;4BAC5C;;uCACI,eAAiCF,SAAQ,mBAARA,EAAwB;uCAAjD,SAAJ65D,W,OAnFN40e,qBAiFwCzuiB;uCAE9B;6DA7kBV8riB,YA6kBMjye,IAFuB27d,WAAat1hB,EAAxBu1hB,UAGoD,EAAE;0BA5T/D,SA8TTiC;4BACE10hB,EAAwCyyhB,UAAWD,WAAWx1hB,EAAEm3B;4BAEpE;;uCACI,eAAiCn3B,SAAQ,mBAARA,EAAwB;uCAAjD,SAAJ65D,W,OA1FN40e,qBAuFgEzuiB;uCAGtD;6DAplBV8riB,YAilBE9oiB,EAGI62D,IAH+C27d,WAAar+f,MAAxBs+f,UAKnB,EAAE;0BApUhB,SAsUTwZ;4BAAyBrhI,SAAU6nH,UAAWD,WAAWr+f;4BAEzD;;;gDAFyBy2Y,SAAU6nH,UAAWD,WAAWr+f;6BAEzD;;qCAME23gB,YAAYC;8BAGZ;6CALAJ;+BAKA,eAAgC,QAJhCE;8BAIsE,SACnE;8BAA+C,qBApoBpDhshB;8BAooBoD,eAGvBsU,MAAM6vB;gCAE/B,WAF+BA;gCAE/B,IAEIunf,SAnqBV7C;gCAiqBM,+BAEI6C;gCAFJ,8BAEIA;gCAFJ,kBATUQ,QAOe53gB,QAQT;8BAXgC,kBAXlDo/f,iBAsBoB;4BArBtB,SAuBEJ,mBAAmB6Y;8BAGnB;+CAtBAL;+BAsBA,eAAgC,UArBhCE;8BAqBsE,SACnE;8BAEc;;8CAxBjBA;8BAwBiB;8BAHjB;+BAGiB,QAvpBnBhshB;+BA4pBU,eAnCR0zgB,cAkCEvve,QAViBgof;8BAaZ,2BAhCPL;8BAgCO,OAFLnpiB,GAGD;4BArCH,UAMEspiB,YAiBA3Y,mBAgB+B;0BA/WxB,SAkXT+Y,iBAAkBC;4BAEpB,MAtqBEtshB,SAuqBkB,wBADhBtiB;4BAGJ,cAHIA;4BAGJ,SAEI41hB,mBAAoBkZ;8BAEtB,cAPE9uiB,EACA6uiB;8BASK,UAVL7uiB;8BAUK;mCALe8uiB;;mCAWTC,oBAXSD;mCAYdrvP;oCAhBNovP;;sD,O8mB7xCN9c,gB9mB4xCM/xhB;kCAqBoC,YALzB+uiB,oBACLtvP;gCAWJ;8BAFA,OArBkBqvP;uCAqBlB;uCAbA;yCAfcF,gCAgBV,iBAdN5uiB,IAc8B,EAcS;4BAzB3C,OAEI41hB,kBAyB2B;0BAlZpB,SAoZToZ,eAAgBh2L;4BAC6B,qBAD7BA;uDAClB,MAvsBE12V,oBAwsB8C;0BAtZrC;qCAyZPwrhB,WAAalT,OAAqBn4hB;8BAEjC,GA7sBH6f;gCA8sBY,IAAN9H,IAAM,UA9sBZ8H;gCA+sBE,cA/sBFA;gCA8sBY;iCACV;2CACgB1J,QAChB,cAjtBF0J,SA8sBM9H,KAGJ,OADgB5B,MAEV;iCAFmB,iBALSnW;gCAKT;8BAGP,qBARLm4hB;8BAQK,mCAAU;qCAE5BiL,YAAWpjiB;8BACb,kCAA6B,QAAE,EADlBA,EACqB;qCAEhCwsiB,aAAaj2L;8BAAgB;uD,OAlB/Bg2L,eAkBeh2L,YAAoC;sCAbjD80L,WAUAjI,YAGAoJ;0BAtaO,SAyaTxa,cAAch1hB;4BAChB;;uCACI,sBAAkD,mBAFtCA,EAEsD;uCAAlE,+BA7rBF8riB,kBA6rBqE,EAAE;0BA3a9D,SA6aTpX,kBAA4B10hB;4BAC9B;;uCACI;yCAEM;;oDACuB,IAAfyviB,aAAe,WALHzviB;oDAMhB,cAruBZ6iB;oDAquBY,gCADI4shB,aAE6B,EAAE;uCAJ3C,IADEjqiB,IACF,wBAlsBJsmiB;uCAwsBE,cAxuBFjphB;uCAwuBE,OAPIrd,GAQD,EAAE;0BAvbE,SAybTqvhB,cAAwB70hB;4BAE1B;;uCACI;yCAEM;;oDACuB,IAAfyviB,aAAe,WANPzviB;oDAOZ,cAlvBZ6iB;oDAkvBY,gCADI4shB,aAE6B,EAAE;uCAJ3C,IADEjqiB,IACF,wBA/sBJsmiB;uCAqtBE,cArvBFjphB;uCAqvBE,OAPIrd,GAQD,EAAE;0BApcE;qCAqdQukH,IAQH/pH,EAAEgnD;8BAChB,WADgBA;8BAChB,eACmB9mD,GAAK,UAjxBxB2iB,SAixBmB3iB,EAAgB;8BAA/B,qBAFUF;8BAEV,mCAAgC;qCAElC00hB,kBAA4B10hB;8BAE9B;;yCACI;yCAAkB,SApBGuD;2C,OA7TzBiriB;;;sDAqVc,eAAmBiB;wDACf,cA3xBlB5shB;wDA2xBkB,gCADe4shB,aAEkB;sDAFjC,qBAPYzviB;sDAOZ,mCAEmC,EAAE;yCAzBvD;2CAAiD;;;4CACrC,gCAD2CA,EAAG2whB;2CAC9C,OAAJ92d,GACD;yCAFH;0EAIakwD,IALQxmH;0CACrB;yCA2BA,cA9xBJsf;yCA8xBI,OAPIrd,GAQD,EAAE;qCAEPqvhB,cAAwB70hB;8BAE1B;;yCACI;yCAAkB,SA7BDuD;2C,OAlUrBiriB;;;sDAmWc,eAAmBiB;wDACf,cAzyBlB5shB;wDAyyBkB,gCADe4shB,aAEkB;sDAFjC,qBAPQzviB;sDAOR,mCAEmC,EAAE;yCAlCvD;2CAGqB;;;4CACJ,gCADUA,EAAG2whB;2CACb,OAAJ92d,GACD;yCALZ,sB;yCACE;+EAFekwD,IAAIxmH;0CAEnB;yCAmCE,cA5yBJsf;yCA4yBI,OAPIrd,GAQD,EAAE;sCAtCQukH,IAYf2qa,kBAcAG;0BA/eO,SA8fTM,UAAUn1hB;4BACZ;;uCAA+B,+BAjxB7B8riB,YAgxBU9riB,EACuD,EAAC;0BA/fzD,SAigBTgjC,MAAMhjC;4BACR;;uCAA+B,+BApxB7B8riB,YAmxBM9riB,EACuD,EAAC;0BAlgBrD,SAogBT4yhB,iBAAmBrmf,IAAsByjN,IAAIhwP;4BAC/C,GADqBusC;6BAAS,QAATA,cAASypC;;yCAATkoF,uB;4BAAmB,IACpC31J;4BADoC,SAEpCyphB,eAAgBgV,kBAAkBxjiB;8BACpC,GADkBwjiB;+DAILhvb,aAAL/8F;gCACJ;kCAPqC+0O;2CAObhtP;oCACpB,wBAFAiY,QAGE;sDAFkBjY,EAChBwjC,MAFCwxE,IALXzvG,SAUyB;8BACT,iBAVkB/E,IAFjB06J;8BAYD,WAXhB31J;8BAWgB,QAAuC;4BAZnB,IAepCwS,IAr0BF8H;4BAu0BA;;;;;8BH/pCF2ugB;;;;;;;iCGgpCIQ;;4BAkBG,YApBwChyhB;4BAoBxC,WALH+a;4BAKG,OAnBHxS,QAqBE;0BA1hBK;;kCAxTTy1hB;kCAEAC;;kCAIAp7gB;kCAMAmqf;kCAEA4+B;kCAEAC;kCAGA9hb;kCAmBA+hb;kCAKAC;;kCAyCA3vS;;;;;;kCA4WAkyS;kCAWAE;kCAWAtQ;kCAEApL;kCAEAE;kCAEAD;kCAEAqT;kCAEAvU;kCAEAwB;kCAGAgL;kCAEAzP;kCAQAv0c;kCAKA+4c;kCAOA5E;kCAWAt5F;kCAQAi+F;kCAIAyQ;kCAEA1Q;kCAYAub;kCAUAC;kCAgBApY;kCAUAsY;kCA0CApY;kCAGAoB;kCAKAF;kCAQAuX;kCA4CAC;kCAkCAK;;kCAqBAva;kCAIAN;kCAYAG;;kCAqEAM;kCAGAnyf;kCAGA4vf;kCAzyBA7oa;uBA7tBR;;;;;2BA0sBQi0a;2BAEAC;2BAEAyR;2BAEA7shB;2BAMAmqf;2BAEA4+B;2BAEAC;2BAGA9hb;2BAmBA+hb;2BAKAC;;2BAyCAh3K;;;;;;2BA4WAu5K;2BAWAE;2BAWAvb;2BAEAH;2BAEAE;2BAEAD;2BAEAP;2BAEAX;2BAEAwB;2BAGAgL;2BAEAzP;2BAQAv0c;2BAKA+4c;2BAOA5E;2BAWAt5F;2BAQAi+F;2BAIA0L;2BAEA3L;2BAYAub;2BAUAC;2BAgBApY;2BAUAsY;2BA0CApY;2BAGAoB;2BAKAF;2BAQAuX;2BA4CAC;2BAkCAK;;2BAqBAva;2BAIAN;2BAYAG;;2BAqEAM;2BAGAnyf;2BAGA4vf;2BA0BA+c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BsnB5/CF/S;2BA0GAW;2BAEAnhS;2BAYAlyP;2BAEA2qE;2BAEA4od;2BAWAnyd;2BA8BA6B;;;;;;;;;;;;;;;;mCAsDE43C,SAAM/kH,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAAuB;mCAE/B08hB,KAAIj7hB,EAAGk7hB,KAAOC;4BAAoB,yCAA9Bn7hB,EAAGk7hB,KAAOC,QAAyC;mCAEvDn2a,SAAMhlH,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAAuB;mCAE/B0mH,SAAMjlH,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAAuB;mCAE/B2mH,SAAOllH,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAAwB;mCAEjC4mH,SAAOnlH,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAAwB;mCAEjC6mH,SAAMplH,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAAuB;mCAE/BinC,IAAIxlC,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAAyB;mCAE/BgnC,IAAIvlC,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAAyB;mCAE/Bw8hB,QAAQ/6hB;4BAAgB,yCAAhBA,GAA2B;mCAEnC+8hB,UAAU/8hB,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAA+B;mCAE3Cm/hB,eAAe19hB,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAAoC;mCAErDs+hB,UAAU78hB,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAA+B;mCAE3Cs/hB,UAAU79hB,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAA+B;mCAE3C2+hB,gBAAgBl9hB,EAAEzB;4BAAgB,yCAAlByB,EAAEzB,GAAqC;;;;6BAhHzD+sE;6BA8BA6B;6BAsDE43C;6BA/GFq3I;6BAYAlyP;6BAEA2qE;6BAmGEomd;6BAEAj2a;6BAEAC;6BAEAC;6BAEAC;6BAEAC;6BAEA5/E;6BAEAD;6BAjIFg4f;6BA1GAX;6BA6OE7B;6BAEAgC;6BAEAW;6BAEAb;6BAEAgB;6BAzHFJ;6BA2HEP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BDpQFE;6BAaA1/R;6BAaAq9R;6BAIA5ya;;;;;qCAcE0qa,aAAa7yhB,EAAEzB;8BAAgB,yCAAlByB,EAAEzB,GAAkC;qCAEjDuuhB,YAAY9shB;8BAAgB,yCAAhBA,GAA+B;qCAE3Ci7hB,KAAIj7hB,EAAGk7hB,KAAOC;8BAAoB,yCAA9Bn7hB,EAAGk7hB,KAAOC,QAAyC;qCAEvD7vd,OAAMtrE,EAAEzB;8BAAgB,yCAAlByB,EAAEzB,GAAuB;;oCAlDjC6+hB;oCAaA1/R;oCAaAq9R;oCAIA5ya;oCAcE0qa;oCAEA/F;oCAEAmO;oCAEA3vd;;;;kCrnBioBA0yd;kCAEAC;kCAEAyR;kCAEA7shB;kCAMAmqf;kCAEA4+B;kCAEAC;kCAGA9hb;kCAmBA+hb;kCAKAC;;kCAyCAh3K;;;;;;kCA4WAu5K;kCAWAE;kCAWAvb;kCAEAH;kCAEAE;kCAEAD;kCAEAP;kCAEAX;kCAEAwB;kCAGAgL;kCAEAzP;kCAQAv0c;kCAKA+4c;kCAOA5E;kCAWAt5F;kCAQAi+F;kCAIA0L;kCAEA3L;kCAYAub;kCAUAC;kCAgBApY;kCAUAsY;kCA0CApY;kCAGAoB;kCAKAF;kCAQAuX;kCA4CAC;kCAkCAK;;kCAqBAva;kCAIAN;kCAYAG;;kCAqEAM;kCAGAnyf;kCAGA4vf;kCA0BA+c;;;sBAeqB;sBuYh+CT;;;;;;;;;;;;;;;;;;;;4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBgP/EpB;sBAEgC;sBttBoI5Bt/Y;sBJ5HExV;sB2tBVN;;sBjP+EoB;uBiP/EpB;iCAcM76I;8BAFC4oC,MAAI/lC,EAEL7C;0BAFU;+BAAL6C;8BAAoC,QAApCA,KAAoC,MAAxC+lC,sBAAI/lC;4BAAuB,OAA3B+lC,IAEU;uBAdjB;iCAiBK/lC;0BACH,QADGA;4BAEE,SAFFA,EAEgB;4BAEL,mBAJXA,WAIW;yCAALkuE;0BAHK,sBAIL;uBAtBX;uCA+DUt7D,GAAI,UAAJA,IAAe;uBA/DzB;;;0BAiFU;4BAIF;;6BAAiB,YADjB5S;6BACiB,OAAbotiB;6BAAa;;uCAWP1siB;gCACa,qBAZnB0siB,KAWM1siB,GACa;6CAAf4siB,aAAUD,IACS;4BAbV,UASXn0Z,GAFA9qE,IAIA3tD;0BAbN,UAlBFyshB,KAJAh/d,IAEA++d,OAqCa;uBApGnB;;0B,IA6HMjtiB;mCAEAygB,IAAI7N;4BACM,0BADNA,GACM;yCAARvT,MAAGguiB,IACS;oCAJdrtiB,EAEAygB;uBA/HN,QAiEMyshB,KAJAh/d,IAEA++d;uBA/DN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAsMKjtiB,EAAE4S;0BACL,GADG5S;;+BAAE4S;8BAMS,QANTA,KAOK,uBADDgoE;8BACC;gCAEF,IADGyyd,YACH,qBADGA;8BAFG,IAIJ/N;8BACF;;sDAAI,IAAY+N,YAAZ,kBADF/N,GACc+N,GAAY;4BANhC;;oDAAI,6BAAiB;0BAFrB,YAQkC;uBAjNxC;iCAmNYrtiB,EAAE4S;0BACN,qBADI5S,EAAE4S;0BACN,wBAA4B,IAANy6hB,YAAM,OAANA;0BAAsB,sBAAkB;uBApNtE;iCAuOKrtiB,EAAE4S;0BACL,GADG5S;;+BAAE4S;8BAQS,QARTA,KASK,iBADDgoE;8BACC,wBAEF;8BAHM,IAIGz6E;8BACT;;sDAA0B,kBADjBA,IACoB;4BARjC;;oDAAW,6BAAiB;0BAE5B,OAPCyS;;;oDAOU,6BAAiB;wCAMQ;uBApP1C;iCAuPK5S,EAAE4S;0BACC,eADH5S,EAAE4S;0BACC,yBAEF,IADKlS,WACL,OADKA;0BADH,IAIsC,eALvCkS,GAK4B,eAL9B5S;0BAK8B,iDAAwB;sBAEvB;;sB3tBnP9Bi4I;sBI4HFwV;sBsexDgB;;uB7VifNkgZ;;;;;;;;;;;;;;;;;;;;;gC8kB/fRT,KAJAh/d,IAEA++d;;sBvtBuEFz/Y;sBJ5HExV;sB4tBVN;;sBlP+EoB;uBkP/EpB;;0BAKU,UAIF,IADAh4I,WACE,iBADFA,IADA,QAEY;uBATpB;iCAeO+vE,GAAGF;0BACN,GADGE,QAIMn9D,EAJHi9D,MAIF7vE,EAJD+vE,MAKS,MADR/vE,EAAK4S,GACG,SAFR,QAGC;uBArBT;;mCA2BU5X;;8BAIF,gBAAiB,aADdi0E,IACc;2CAATjvE,MAAGsT;4BAFX,YAGY;oCALVtY;sBA0Bc;;sB5tB1ClBi9I;sBI4HFwV;sBADAD;sBJ5HExV;sBqWVN;;sBqI+EoB;uBrI/EpB,qBAgBc36I,GAAI,UAAJA,IAAS;uBAhBvB;iCAqBKqD,EAAGP;0B,IAAHggH;0BAAQ;+BAARA;kCAAqClxC,GAArCkxC,OAAgChjH,EAAhCgjH,OAA2C,WAAxChgH,EAA6BhD,OAAhCgjH,IAAqClxC;4BAAV,SAAgC;uBArBhE;;0BAmCQ,UAIF,IADGA,YACD,oBADCA;0BADH,QAEa;uBAvCnB;iCAsEKc,GAAGF,GAAI1vE;0BACV,GADG4vE;4BAKU;6BADG04C,GAJV54C;6BAIKn0E,EAJLm0E;6BAICZ,GAJJc;6BAID5yE,EAJC4yE;6BAKU,cADNd,GAASw5C,GAJNtoH;4BAKN,qBALMA,EAIRhD,EAASzB;0BADP,QAEsB;uBA3E5B;iCAiFKkqJ;0BACH,GADGA;4BAKgB;6BADJuoZ,MAJZvoZ;;6BAIK32E;6BAAL9xE;6BACgB,kBADJgxiB;6BACI;;yCADhBhxiB,EACKkxiB,QADAp/d,GACKm/d;0BAFT,YAGqB;uBAvF3B;iCA4FKxoZ,IAAKzlJ;0BACR,GADGylJ;;8BAKgB;+CALhBA;+BAKgB;;+BACP,aANJzlJ,EAKAkuiB;+BAEK,QAFAD,IALLjuiB;8BAOK,UADLzE,EACA+sH;4BAJJ;0BAOA,sBAA2B;uBAtGjC;iCAyGK/nH,EAAE6a;8BAAF4kG,MAAEqub;0BACL;+BADGrub;8BAIW,IAAZhjH,EAJCgjH;8BAIW,mBAJTqub,SAKD,UADFrxiB;8BAAY,IAGV,IAPDgjH,OAOC,MAPCqub,cAAFrub,QAAEqub;;4BAGD,SAIe;uBAhHrB;iCAkHQv/d,GAAGw5C;0BAAK,eAARx5C,GAAGw5C,YAAwBtrH,EAAEzB,GAAK,UAAPyB,EAAEzB,EAAW,EAAC;uBAlHjD;iCAqHKgF;0BAAK,GAALA,OAAkCuuE,GAAlCvuE,KAA6BvD,EAA7BuD,KAA6C,UAAhBvD,EAAgB,UAAX8xE;0BAAV,QAA+B;uBArH5D,oBAyHavuE,GAAkB,yBAAlBA,GAA6B;uBAzH1C;iCA4HKxF,EAAE8E,EAAGG;0BAAK,GAARH;4BAAsC,QAAtCA,KAA6C,YAA/C9E,UAAmCgzE,IAA9B/tE;4BAAmC,qBAAnCA,EAALjF;0BAA4B,QAAoC;uBA5HrE,iBA8HS8E,EAAGG,GAAI,eAAPH,EAAGG,EAAe;uBA9H3B;iCA6IKO,EAAGP;0BAAK,GAARO;4BAAkD,IAAbuuE,GAArCvuE,KAAgCvD,EAAhCuD,KAAkD,aAAbuuE,GAAlC9uE;4BAAwC,qBAAxCA,EAA6BhD;0BAAL,QAAgC;uBA7IhE;;0BAyJQ;4BAIW;6BADV8xE;6BAAL9xE;6BACe,gBADV8xE;6BACU;yCADf9xE,EACSi8I;0BAFP,YAGW;uBA9JjB;iCAiKKnqE,GAAGjvE;0BACN,GADGivE;+BAAGjvE;kCAIOkuE,IAJPluE,KAICo5I,KAJJnqE,MAID9xE,EAJC8xE;8BAKM,UADP9xE,EACO,uBADFi8I,KAAMlrE;;2BADT,KAHEluE,EAGF;0BAIA,sBAAkC;uBAxKxC;iCA2KKivE,GAAGjvE;0BACH,mBADAivE,cACmB,SADhBjvE;4BAGF,mBAHEA;4BAEJ,4BAFCivE;0BAIQ;mCAJLjvE;;qC,wBAAHivE,sBAIqB;uBA/K1B;iCA6LKvuE,EAAGP,EAAGmgB;8BAAN6/F,MAAM+0B;0BACT;+BADG/0B;8BAKW;+BADPlxC,GAJJkxC;+BAIDhjH,EAJCgjH;+BAKW,kBALRhgH,EAAG+0I,OAIP/3I;+BAJCgjH,IAIIlxC;+BAJEimE;;4BAGL,OAHKA,OAMe;uBAnM1B;iCAsMKx1I,EAAGS;0BACN;4CAAmBwuE;qCACf;uCAFDjvE;gDAEgBvC;yCAAY,yBAFzBgD,EAEahD;yCAAY,aAAW,WADvBwxE,cACmC;qCAAlD,QACM;uBAzMZ;iCA2MUjuE,EAAGP,EAAGmgB;0BACd,eADcA;0BACV;oCADI5f;mDACqBvD;sCAAd;sCAA2B,UAArBjC,UAAqB,WAD/BiF,EACUjF,EAAG6qC,IAAK5oC,GAAwB;;qCAAiB;uBA5MxE;iCA8MyBuD,EAAeP;0BACtC,GADuBO,OAIbuuE,GAJavuE,KAIrB4f,KAJqB5f,YAnBjBwuiB,QAuBIjge,GAJ4B9uE,EAIpCmgB;0BADE,sBAEgB;uBAnNtB;iCAsNE6xM;0CAAYh1N,gCAAZg1N,OAAYh1N,GAAO,CAAoB;uBAtNzC;iCAsNEg1N;;4B;8BAAY,gCAAZA,SAAYljJ;wCAA2B;uBAtNzC;;mCAoOY9uE,EACHH,EAAEmtH;4BACL,GADGntH;8BAKC;mCALDA;+BAKU,KADTkuE,IAJCi/C;+BASC,sBATDA,GAKGnkD;+BAIF;gDADA,qCAAM7rE,EAAG8xE,GAAe;+BACxB;gDAFA,qCAAU9xE,EAAK8xE,GAAc;8BAE7B;4BANF;kDAAqC,QAAE;4BAAvC,sBAAsB,QAAE;4BAAxB,yCAMgB;oCAVd9uE;uBApOZ;;mCAyQUkrJ,IAAI3qJ;4BAAI,gBI2dW4uiB,WAAWhkZ;8BAG3B;gDAHgBgkZ,WAAWhkZ;+BAE3B,iBJ7dC5qJ,EI2d0B4qJ;iEJ3dA;yCAF9BL,OAEAI;mCAUAkkZ;4BAAU,uB,aAAK;4CAFfhmZ,OAEAgmZ;mCAUAC,MAAIC,OAAOC,OAAQC,QAAQtyiB;4BAAY,kBAApBsyiB,QAAoB,WAAnCF,OAAuBpyiB,GAAsB;yDAAjDmyiB,MGzMNhmZ;mCHmNMomZ,MAAIH,OAAOC,OAAQG,SAAS13hB,IAAKC,IAAI/a;4BAAsB,kBAAxCwyiB,SAAS13hB,IAAKC,IAA0B,WAAvDq3hB,OAAiCpyiB,GAAgC;4CAFrE0pJ,OAEA6oZ,MlIhONzpZ;mCkI0OM2pZ,MAAIL,OAAOC,OAAQG;4BAAW,kBAA1BJ,OAAeI,SAAgD;6CAFnEllZ,OAEAmlZ;mCAUAC,MAAIN,OAAQC,OAAOM;4BAAW,kBAAlBN,OAAOM,SAAgD;6CAFnEllZ,OAEAilZ;mCAUAE,MAAIR,OAAQC,OAAOM,SAAS73hB,IAAKsvI;4BAC5B,kBADOioZ,OACP,WADcM,SAAS73hB,IAAKsvI,SACL;2CC8ElCkB,cD/EMsnZ,MC9NNzoZ;mCDoOI2qB,YAAY+9X;4BAAK,gCAALA,GAAmB;mCAE/Bx9X,WAAW/wK,IAAK,+BAALA,GAAkB;mCAE7BgxK,YAAY3sK;4BAAK,gCAALA,GAAmB;mCAE/B4sK,aAAa5sK;4BAAK,iCAALA,GAAoB;mCAEjCitK,MAAM9lD,IAAK,6BAALA,GAAgB;mCAEtB6lD,aAAavvK;4BAAK,iCAALA,GAAoB;mCAEjCovK,WAAWpvK,IAAK,+BAALA,GAAkB;mCAE7BsvK,aAAe5yK,EAAGgY,IAAMsvI,QAAQqrB;4BAClC,sCAD0BrrB,WACuB;;kCAf/C0qB;kCAEAO;kCAEAC;kCAQAE;kCAEAE;kCARAH;kCAIAI;kCAFAC;uBAnVR;;mCAmWMp8F,QAAQl2E,EAAEovE,GAAGF;4BAAsC,oBAAtCA;4BAAyB,oBAA9BlvE,EAA8B,UAA5BovE,UAAqD;mCAE/Ds3C,YAAYlnH,EAAEzC,EAAEgC;4BAAyB,gCAA7BS,EAAEzC,EAA2B,UAAzBgC,GAAoC;mCAEpDouE,MAAM3tE,EAAE4vE,GAAGF;4BAA+B,oBAA/BA;4BAAkB,kBAAvB1vE,EAAuB,UAArB4vE,UAA8C;mCA9GxDmiJ,UACc/xN,EAAEO;4BAAkB,oBAAlBA;4BAAkB,8BAApBP,SAA+B;mCAD7C6iO,YAGc7iO,EAAEzC;4BACd;4BAAgC;8B,YA7F9BsxiB;4BA6FS,6CADC7uiB,GAAEzC,SACsD;mCAZvC2vH,UAEjBltH,EAAEO,GAAqB,oBAAvBP,EAAuB,UAArBO,GAAgC;mCAFjB24K,UAIjBl5K,EAAEzC;4BAAI;4BAAuB,2CAA7ByC,EAAEzC,SAAmD;mCAuHjEgvE,IAAKhsE;4BAAY,uB,OwXpVjBouiB,OxXoVKpuiB,SAAiB;mCAEtByviB,YAAoCzpc;4BAAM,8BAANA,QAAmC;;kCAXvE7vB;kCAEAwwC;kCAEAv5C;kCA9GFokJ;;kCAR+B74C;;kCA2H7B3sG;kCAEAyje;kCwXlVAxB;uBxX5BN;iCAwXM/uY;0BACF,GADEA;4BAGW;6BADJC,OAFPD;6BAEAwB,IAFAxB;6BAGW,SADJC;6BACI;8CACG,qCAAS1iK,EAAK8xE,GAAa;6BAD9B;kDAEIA,YAAH9xE,uBAAG8xE;4BACb;;sDAAU,iBAJZmyF,IACMp4F,IACA8sd,MACAC;qCADAD;qCACAC;0BAGJ,SAAIqa,eAAW,QAAE;0BAAjB,SACIC,cAAU,QAAE;0BAChB;;oDAAU,oBAFND,QACAC;mCADAD;mCACAC,OAC0D;uBAlYtE;iCAoYQjvY,IAAIphK;0BAAS,qBAATA,kBAA8B,OAAlCohK,GAAqC,GAAE;uBApY/C;iCAyYKrxF,GAAGF,GAAG0ge;0BACT,GADGxge;gCAIUyge,OAJJD,QAIF5hf,KAJJohB,MAID5yE,EAJC4yE;4BAKM,UADP5yE,EACO,SADFwxD,KAJDkhB,GAIO2ge;0BADT,OAHE3ge,EAKoB;uBA9Y5B;iCAiZoBZ;0BAGhB,oBAHgBA,IAGhB;0BADA;2CAFgBA,YAEOlpC,IAAI5oC,GAAK,UAALA,EAAJ4oC,IAAwB,eACpC;uBApZf;iCA+ZKrlC,EAAE6viB;0BACL,GADG7viB;;+BAAE6viB;8BAOD;sCAPCA;+BAOY,oBADJC;+BACI;;iDAATvhe,IAAIw5C;4BAFR,YALD/nH;0BAGC,YAKa;uBAvanB;iCA0aKklJ;0BACH,GADGA;;8BAO0B;;;kCAP1BA;kDAOsC,qCAAMzoJ,EAAK8xE,GAAe;+BA5RtC,aAArBm7C,mB;+BAAM,aAANA,mB;8BA6RK,UADL4pP,MACK,UADE48L;4BAFX;0BAFA,sBAKwB;uBAlb9B;iCAqbKlxiB,EAAE4T;0BAAK,GAALA;gCAA+C67E,IAA/C77E,KAAyC27D,GAA3CvvE,KAAsCvC,EAAtCuC,KAA2D,UAArBvC,EAAqB,KAAhB8xE,GAAMkgB;0BAAhB,QAAmC;uBArbzE,oBAub6BzvF,EAAe4T,GACtC,kBAAM,MADiB5T,GAAe4T,GACtB;uBAxbtB;iCA2bK5T,EAAEkT,EAAEk0N;0BACC,mBADLpnO,GAEK,EADJ24E,eAEK,aAHJzlE;0BAIE,mBAFH5S,EACA46E;4BAEJ,IAAI9/E,QAFA8/E,MADA56E;4BAGJ;qCALK4S;8CAMU1X;uCAAQ,mBAARA,EADXJ,SACoC,OANjCgsO;uCAM4C,UAApC5rO,IADXJ;uCAC+C,wBAL/Cu9E,qBAK8D;wDAAC;uBAjcrE;iCAocK34E,EAAEkT,EAAEy6D;0BACP,GADG3tE;;+BAAEkT;8BASc,IADNgoE,IARRhoE,KASc,0BADNgoE,IARNvN;8BASY,gBAAX2je;4BAFJ;6BAPCp+hB;4BAKD,IADI5S,EAJH4S,KAKU,UALRy6D,UAKQ,aADPrtE,EAJDqtE;0BAGH,QAOa;uBA9cnB;iCA6dK3tE,EAAE4T,EAAGV,EAAEy6D;0BAAW,wBAAlB3tE,EAAKkT,EAAEy6D,UAAuC;uBA7dnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAirBG;;sBrWtqBG4qE;sBI4HFwV;sBsexDgB;;;0B;;;;;;;;;;;;sBteuDhBD;sBJ5HExV;sBoGVN;;sBsY+EoB;uBtY/EpB;iCA0BgCqha;mCACtBvf,WAAW95hB;4BACd,mBADcA,KACH,OAFcq5iB;4BAIlB,IAAJt6iB,EAAI,WAHOiB;4BAGP,kBAJkBq5iB,KAItBt6iB,IACK;iCAJL+6hB;uBA3BV;iCAiGMyf;;;wFAE+C;uBAnGrD;iCAiGMA;;4B;;;;;;;;;;;;;;;;;oCACE;;oDADFv4B,MACE,aADFA,MACuB;oCADvB;wCAE+C;uBAF/C;;;;;;;;;;iCAAQ7ghB,G,UAARs5iB,kBAAQt5iB,KAEuC;uBAF/C;iCAAKy5iB;0BAAL;oEAAKA,UAALrjf,IAE+C;uBAF/C;iCAAKujf,QAAL3hiB;;4CAAK2hiB,QAAL3hiB,aAE+C;uBAF/C;iCAAK6hiB;0BAAL;sCAAKA;4BAAL;8B,OAAAH,oCAE+C;0BAF/C;mEAAKG,gBAALt6iB,EAE+C;;uBAF/C;iCAAK2rhB,KAALlzgB;2EAE+C;uBAF/C;iCAAKkzgB,KAALlzgB;;;iDAAKkzgB,KAALlzgB;mEAE+C;uBAF/C;iCAAKiiiB;0BAAL;4B,OAAAH,cAAKG,gBAALjiiB,iBAE+C;0BAF/C;;oC,OAAA+hiB,cAAKE,gBAALjiiB,YAE+C;;uBAF/C;;;;;yEAE+C;uBAF/C;;;;;;;;;;4BiH8aE,cjH9aF;;;;;;;;;;;;;;;;;;;gEAE+C;uBAF/C;;0CACE,gBADFkzgB,KACEvrhB;yDAC6C;uBAF/C;;;;kDACEq0K,YAC6C;uBAF/C;;;;kDACEoC,YAC6C;uBAF/C;6CACE7nD,IADFrrH;0B,IACEy3iB,GADFz3iB,qCACEqrH;uBADF;;;;wFAE+C;uBAF/C;;;4B;;;;;;;;;;;;;;;;;oCACE;;oDADFsyZ,MACE,aADFA,MACuB;oCADvB;wCAE+C;uBAF/C;;;;;;;;;4BiH8aE,cjH9aF;;;;;;;;;;;;;;;;;;;gEAE+C;uBAF/C;;0CACE,gBADFqK,KACEvrhB;yDAC6C;uBAF/C;;;;kDACE63K,YAC6C;uBAF/C;6CACEjpD,IADFrrH;0B,IACEy3iB,GADFz3iB,qCACEqrH;uBADF;iCAMIvuH;0BACN,SAAI21hB,a,IAAqB34hB;0BAAzB,SACI44hB,KAAK54hB,GAAI,UAAJA,EAAmB;0BAEZ;0DAJVgD,EACF21hB,MACAC,MADAD,MACAC,KAEoD;uBAVtD;uCAYuB51hB,G,IAAJhD,WAAsB,qBAAlBgD,EAAJhD;uBAZnB;iCAuBMuD,EAAGP;0BAAyB,qBAAzBA,EAAHO;0BAAa,qBAAVP,EAAHO,YAAuC;uBAvB7C;iCA0B0B24iB;0BAET;4CAFSA;2BAEb,iBAFaA;2BAEb,MAFaA;2BAEb,MAFaA;2BACjB,4BADiBA;0BACjB,qBADiBA;uBA1B1B,SA0BEkC,UAHAD;uBAvBF;iCAgC0BjC;0B,gBACxB15gB,MAAoBjiC;4BACxB,UADIiiC,SACa,iBAFW05gB,KACJ37iB,EAApBiiC;4BACa,qBAFW05gB,kBAEiB;uBAlC3C;iCAoC0BA;0B,gBACxB15gB;4BACD,IADmCj/B,iBAAlCi/B,SACD,iBAFyB05gB,KACU34iB;4BACnC,kBAFyB24iB;uBApC1B;iCAwCMvre;8BAAwC+B,YAAnBE,8BAArBjC,MAAqBiC,GAAmBF;uBAxC9C;iCA2DA0pe;;;wFAC+C;uBA5D/C;iCA2DAA;;4B;;;;;;;;;;;;;;;;;oCAAY;;oDAAZv4B,MAAY,aAAZA,MAA+B;oCAA/B;wCAC+C;uBAD/C;;;;;;;;;;iCAAQ7ghB,G,UAARw7iB,kBAAQx7iB,KACuC;uBAD/C;iCAAKy5iB;0BAAL;oEAAKA,UAALrjf,IAC+C;uBAD/C;iCAAKujf,QAAL3hiB;;4CAAK2hiB,QAAL3hiB,aAC+C;uBAD/C;iCAAK6hiB;0BAAL;sCAAKA;4BAAL;8B,OAAA8B,oCAC+C;0BAD/C;mEAAK9B,gBAALt6iB,EAC+C;;uBAD/C;iCAAK2rhB,KAALlzgB;2EAC+C;uBAD/C;iCAAKkzgB,KAALlzgB;;;iDAAKkzgB,KAALlzgB;mEAC+C;uBAD/C;iCAAKiiiB;0BAAL;4B,OAAA4B,cAAK5B,gBAALjiiB,iBAC+C;0BAD/C;;oC,OAAA8jiB,cAAK7B,gBAALjiiB,YAC+C;;uBAD/C;;;;;yEAC+C;uBAD/C;;;;;;;;;;4BiHmXE,cjHnXF;;;;;;;;;;;;;;;;;;;gEAC+C;uBAD/C;;0CAAY,gBAAZkzgB,KAAYvrhB;yDACmC;uBAD/C;;;;kDAAY28iB,YACmC;uBAD/C;;;;kDAAYK,YACmC;uBAD/C;6CAAYpub,IAAZrrH;0B,IAAYy3iB,GAAZz3iB,qCAAYqrH;uBAAZ;;;;wFAC+C;uBAD/C;;;4B;;;;;;;;;;;;;;;;;oCAAY;;oDAAZsyZ,MAAY,aAAZA,MAA+B;oCAA/B;wCAC+C;uBAD/C;;;;;;;;;4BiHmXE,cjHnXF;;;;;;;;;;;;;;;;;;;gEAC+C;uBAD/C;;0CAAY,gBAAZqK,KAAYvrhB;yDACmC;uBAD/C;;;;kDAAY09iB,YACmC;uBAD/C;6CAAY9ub,IAAZrrH;0B,IAAYy3iB,GAAZz3iB,qCAAYqrH;uBAAZ;iCAKIvuH;0BACN,SAAI21hB,a,IAAqB34hB;0BAAzB,SACI44hB,KAAK54hB,GAAI,UAAJA,EAAmB;0BAEZ;0DAJVgD,EACF21hB,MACAC,MADAD,MACAC,KAEoD;uBATtD;uCAWuB51hB,G,IAAJhD,WAAsB,qBAAlBgD,EAAJhD;uBAXnB,gBAsBMuD,EAAGP,GAAI,kBAAJA,EAAHO,EAAU;uBAtBhB;iCAyB0B24iB;0B,UAAAA,uBA3J5Bvf,WA2J4Buf;uBAzB1B,WAyBEuE,UAHAD;uBAtBF;iCA6B0BtE;0B,gBACxB15gB,MAAoBjiC;4BACP,qBAFW27iB,KACJ37iB,EAApBiiC,OAC8B;uBA/BhC;iCAiC0B05gB;0B,gBACxB15gB;4B,IAAkCj/B,6BADV24iB,KACU34iB,EAAlCi/B;uBAlCF;iCAqCMmuC;8BAAwC+B,YAAnBE,8BAArBjC,MAAqBiC,GAAmBF;sBACjD;;sBpGvLGooE;sBI4HFwV;sBsexDgB;;;yBtY6EdguZ;;yBAAQG;yBAARC;;;;;;;;;;;;;;;yBA3DAvC;;yBAAQI;yBAARC;;;;;;;;;;;;;sBhGqCFnsZ;sBJ5HExV;sB+tBVN;;sBrP+EoB;uBqP/EpB;;mCA0FY73I,EAGHqM,GAAG9M;4BACN,GADG8M,QACyCyiE,GADtCvvE,KACiCvC,EADjCuC,KAC6B+vE,GADhCjjE,MACoD,UAAhBrP,EAAgB,EAApBsyE,GAASR;4BAAhB,QAAkC;oCAJxD9uE;uBA1FZ;;mCAuGYA;;8BAIM,IADL8uE,YAAL9xE,WACU,kBADVA;8BAEO,UADDzB,EACC,EAFFuzE;4BADH,QAGS;oCALP9uE;uBAvGZ;;mCA+IYA,EAGHqM,GAAG9M;4BACN,GADG8M,QACyCyiE,GADtCvvE,KACiCvC,EADjCuC,KAC6B+vE,GADhCjjE,MACoD,UAAhBrP,EAAgB,EAApBsyE,GAASR;4BAAhB,QAAkC;oCAJxD9uE;uBA/IZ;;mCA4lBYnF;;8BAMF,gBAAiB,aADdi0E,IACc;2CAATjvE,MAAGsT;4BAFX,YAGY;oCAPVtY;uBA5lBZ;;mCAgoBYmF;;8BAKM,IADL8uE,YAAL9xE,WACU,kBADVA;8BAEO,UADDzB,EACC,EAFFuzE;4BADH,QAGS;oCANP9uE;uBAhoBZ;;mCA0oBYA,EAKHqM,GAAG9M;4BACN,GADG8M,QACyCyiE,GADtCvvE,KACiCvC,EADjCuC,KAC6B+vE,GADhCjjE,MACoD,UAAhBrP,EAAgB,EAApBsyE,GAASR;4BAAhB,QAAkC;oCANxD9uE;uBA1oBZ;;0BA0mCU;4BAKqB;6BADpB4pG;6BAALrqG;6BACyB,WADpBqqG;6BACoB;;6BACX,iBAAW,aAFzBrqG,E/c18BAijH;6B+c48Bc;yCAAL3iH,EADCi+iB,UAAOtgjB;0BAFf,YAIqB;uBAjnC7B;iCAmnCuBosG;0BAkBC,eAlBDA,IAkBC;oCAARpsG,IAAJgrC,GACA;sBAiBT;;sB/tB5oCGsvG;sBI4HFwV;sBADAD;sBJ5HExV;sB4IVN;;sB8V+EoB;uB9V/EpB,cAOS36I,GAAI,UAAJA,EAAU;uBAPnB;;;0BAa4C;2BAQtC;;4BARsC,mBAEtC,IADGF,WACH,UADGA;yCAGH,IADW65D,aACX,UADWA;4BAGX,SAEI;uBArBV;;0BAuBoD;2BAM9C;;4BAN8C,mBAE9C,IADG75D,WACH,UADGA;4BAGH,IADQ65D;4BACR,UADQA,KAGJ;uBA7BV;;0BA+BgB;2BAMV;;4BANU,mBAEV,IADG75D,WACH,OADGA;4BAGH,IADQ65D;4BACR,OADQA,IAGmB;uBArCjC;iCAuCet2D,GACb,GADaA,GAC4B,IAALvD,EADvBuD,KAC4B,UAALvD,GAAf,QAA0B;uBAxCjD;iCAqDcA,EAAEzB;0B;0BACZ,OADUyB;4CAAEzB,EAOR;;;iDAPQA,EAKR;0BAFA,QAIE;uBA5DV;iCA+DQgF,EAAGP;0BACT,UADMO;2BAGF;;4BAFJ,SADMA,MAKF,IADGvD,EAJDuD,KAKG,qBALAP,EAIFhD;gCAEK65D,IANNt2D,KAMGpD,EANHoD;4BAOQ,UADLpD,EACK,WAPL6C,EAMG62D,MACM;uBAtEpB;iCAqH0C0nf,SAAqB7iB,OAAOC,QACjEjqc,KAAgB8sd,MAA+B73U,MAC9C83U;0BACJ;sCAHwCF;2BAGxC;iCAFG7sd;8BAEMgtd;8CAMQ,kB5CpBXztB,Y4CoB0C;2BAAxC;;;8BANCytB;;;;;;8BAEH1+gB;0BAIE;4BAoBG;mCA5BR0xD;qCA6B2C,UAD1B10F,UACS,iBAAmC,UAD/CG,EAAGH,GAEZ;0BAtBA,eAYUuD;4BACX,UADWA;6BAKP,UA1ByDo7hB,QAEhE8iB;;8BAoBG,SADWl+iB,MAOP,IADGvD,EANIuD,KAOP,UA5BkDm7hB,OA2B/C1+hB;kCAJK65D,IAFDt2D,KAEFpD,EAFEoD;wCAEFpD,EAAG05D,KAKE;0BAnBb;4BAUA,iCAAM15D,KAAGH,IAAiC;0BAV1C,eAQOuD;4BACX,GADWA,GACqC,IAALvD,EADhCuD,KACqC,YAALvD,GAAtB,YAjByB2pO,MAiBW;0BAH7D;;;2CACE,iBAZEg4U,WAHeH;;yCA8BX;uBApJV;iCAsJyBD,SAAU7sd,KAAgB8sd,MAC7C73U;0BACJ,OAFiCj1I;;6BAvEjC;6CAOgB10F,GAAK,UAALA,EAAW;8BAP3B;;iCAEY;mCAED,IADGA,WACH,OADGA;iCAGH,sBAAwC;6BANnD;;;;wCAuEiDwhjB;iDAvErBxhjB,GAAK,uBAALA,EAAuB;wC4JiRzB+0H;;;;6B5JvQ1B;oDAS4B,QAAO;8BATnC;;iCAIY,mCAID,eAA2C;8BARtD,sBAEgC,QAAI;8BAFpC,sBACmB,QAAE;6BADrB;;uDAAc;;;;6BAcd;;+CAYW,oCAAM50H,EAAGH,EAAmB;8BAZvC;wCAMkBuD;iCACX,UADWA;uCAECvD,EAFDuD,KAEFpD,EAFEoD,eAEFpD,EAAGH;iCAGR,sBAAwC;8BAXnD;+CAIQ,iCAAMG,KAAGH,IAAiC;8BAJlD;wCAEeuD;iCACX,GADWA,GACqC,IAALvD,EADhCuD,KACqC,YAALvD,GAAtB,YA6CrB2pO,MA7CyD;6BAH7D;;;8CACE,iBA8CqB43U,SAA0BC;;6CAQd;sBA0BlC;;sB5I7KG1ma;sBI4HFwV;sBADAD;sBJ5HExV;sBguBVN;;sBAOI;;;;;;;;sBAW0D;;sBhuBPxDC;sBI4HFwV;sBADAD;sBJ5HExV;sBqGVN;;sBqY+EoB;;;;;;;;uBrYgId;;;;;;;;;;iCAAWzrB,M,UAAXwyb,kBAAWxyb,QAW2C;uBAXtD;;;;;;;;;;;;;;;;;;;;;;;;;;;oCgHgUE;sChHhUF;;;;;;;;;6FAWsD;iDAXtD6uB;;;;;;;;;;;;8CAMI;wEANJF;;gDAMI;;mEANJv9B,QAMIy8E;;;6CAGA;uEATJl/C;;+CASI;;oEATJv9B,QASI08E;;;4CAFA;sEAPJn/C;;8CAOI;;mEAPJv9B,QAOI48E;;;2CAJA;qEAHJr/C;;6CAGI;;kEAHJv9B,QAGIw8E;;;0CADA;oEAFJj/C;;4CAEI;;iEAFJv9B,QAEI0hF;;;yCAMA;mEARJnkD;;2CAQI;;gEARJv9B,QAQI4hF;;;wCAHA;kEALJrkD;;0CAKI;;+DALJv9B,QAKI8hF;;;uCADA;iEAJJvkD;;yCAII;;8DAJJv9B,QAIIwhF;;sCAJJ;;;;;;;;mCAEI+/W;6BAFJ,MAGIC;6BAHJ,MAIIC;6BAJJ,MAKIC;6BALJ,MAMIC;6BANJ,MAOIC;6BAPJ,MAQIC;6BARJ,MASIC;;;;;;;;;;;;;;;;;;;+BADAx5P;+BADA05P;+BADAC;+BADAC;+BADAC;+BADAC;+BADAC;;;sCACAD;sCACAD;sCACAD;sCACAD;sCACAD;sCACA15P;sCACAy5P;4BATJ;;;;+CAEIR;;gDACAC;;iDACAC;;kDACAC;;mDACAC;;oDACAC;;qDACAC;wDACAC,8CAEkD;uBAXtD;;;;;;;;;;;;kCAEIc;;mCACAD;;oCACAD;;qCACAD;wCACA1rV,OACAyrV,OACA79Z,UACA49Z,wBAEkD;uBAXtD;;;;;;;;;;;;;;;;;;;kCAEIK;kCACAD;kCACAD;kCACAD;kCACA1rV;kCACAyrV;kCACA79Z;kCACA49Z,eAEkD;uBAXtD;;;2BAuBGA;2BADA59Z;2BADA69Z;2BADAzrV;2BADA0rV;2BADAC;2BADAC;2BADAC;;;kCACAD;kCACAD;kCACAD;kCACA1rV;kCACAyrV;kCACA79Z;kCACA49Z;uBAvBH;iCA4Caz3e,OAAU/+B;0B,GAAAA;2BAAM,QAANA,WAAMypC;;+BAANipd,oB,wBAAV3zd;0BAA0C;;;;;;;;;2BAYvD;;8BAZaA,OAYb,WAZaA,OACX83e,aACAD,cAIAH;2BAmBF,kCAzBa13e,OAKXisJ,IAEApyE;2BAsBF;;8BA7BuB85Y;;+BAuBrBwkB;kCAbAD,8BANAP;2BAiCF;;8BArCuBhkB;;+BAKrB1nU;kCAKAisV,8BANAP;2BAqCF;uCAzCa33e,OAmCXq4e,kBA5BAx+Z;0BAkCF;kCAxCEi+Z;kCACAD;kCACAD;kCACAD;kCACA1rV;kCACAyrV;kCACA79Z;kCACA49Z;kCA+BAa;kCAZAF;kCAJAD;kCAlBAlsV;kCAkCAqsV;kCAJAD;kCA9BApsV;kCAKAisV;uBAtDF;;;2BAqHET;2BADA59Z;2BADA69Z;2BADAzrV;2BADA0rV;2BADAC;2BADAC;2BADAC;;;;mCACAD;;oCACAD;;qCACAD;wCACA1rV,OACAyrV,OACA79Z,UACA49Z;uBArHF;uCAoPG//iB;0BAQc;2BATf+/iB;2BADA59Z;2BAFA69Z;2BACAzrV;2BAFA0rV;2BADAC;2BADAC;2BADAC;2BAgBe,iBARdpgjB,EADD+/iB;2BAQO,iBAPN//iB,EAFDmiJ;2BAQI,iBANHniJ,EAJDggjB;2BASI,iBALHhgjB,EAHDu0N;2BAOkB,iBAJjBv0N,EALDigjB;2BAQkB,iBAHjBjgjB,EANDkgjB;2BAQa,iBAFZlgjB,EAPDmgjB;0BAQa;6CADZngjB,EARDogjB;;;;;;;;uBA5OF;iCA+QApuV;;;4BAyBwC;+DAzBxCA,OAyBwCn7J;;;4BAzBxC;4BAwBkC;+DAxBlCm7J,OAwBkC11H;;;4BAxBlC;4BAuBkC;+DAvBlC01H,OAuBkCv1H;;;4BAvBlC;4BAsB0B;+DAtB1Bu1H,OAsB0Bz6G;;;4BAtB1B;4BAqBoC;+DArBpCy6G,OAqBoCv6G;;;4BArBpC;4BAoB2B;+DApB3Bu6G,OAoB2Bp6G;;;4BApB3B;;;;;;;;;oCgQmGau7b;;sChQhFO,2CAnBpBnhV,OAmBoBh1N;sDAAS;;+BAnB7BikjB;;4BAkBmB;+DAlBnBjvV,OAkBmBh6G;;;4BAlBnB;4BAiByB;+DAjBzBg6G,OAiByB75G;;;4BAjBzB;4BAgBmB;+DAhBnB65G,OAgBmB35G;;;4BAhBnB;4BAemB;+DAfnB25G,OAemBr5G;;;4BAfnB;4BAciC;gEAdjCq5G,OAciCuvV;;;4BAdjC;4BAaiC;gEAbjCvvV,OAaiCyvV;;;4BAbjC;4BAY4B;gEAZ5BzvV,OAY4B2vV;;;4BAZ5B;4BAW4B;gEAX5B3vV,OAW4B6vV;;;4BAX5B;;6BAUI,iCAVJ7vV;6BASI,iCATJA;6BAQI,iCARJA;6BAOI,iCAPJA;6BAMI,iCANJA;6BAKI,iCALJA;6BAKI,MALJh1N;;;8DgQwHas3iB,YhQxHbtiV;;6BAGI,iCAHJA;6BAGI,MAHJh1N;;;8DgQuLaq6iB,ahQvLbrlV;;;;;8DgQuLaqlV,ahQvLbrlV;;0DA2B8D;uBA1S9D;iCA+QAA;;4B;8BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAQIgyV,MARJ/qa;2CAQIwoa;2CARJ;;;;;;;;;+DAQIA;6CARJiC;;;;;;;;;;;;;;;;;gDAQIM;2CARJhggB;;;;;gDAqBIiggB,KArBJhra,QAqBIxhC;4CAAgC,iBAAhCA;;;6CAAgC;gFAAS;oDAAT,yBArBpCu6G,OAqBIv6G;;6CArBJ9xD;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAqBIs+f;6CArBJjggB;;;;6CAIIkggB,KAJJjra;6CAII1hC;6CAJJ3xD;;;;;qEgQwHa2uf,YhQxHbviV,QAIIz6G;+CAJJusc;;;;;;;;;;;;;;;;;;;;;kDAIII;6CAJJlggB;;;;6CACImggB,KADJlra;6CACIx8C;6CADJ52C;;qEgQuLayxf,ahQvLbtlV,QACIv1H;+CADJg3C;;;;;;;;;;;;;;;;;;;;;;;;kDACI0wa;6CADJnggB;;;gDAsBI+8d,KAtBJ9nY,QAsBI38C;4CAAsB,iBAAtBA;;;6CAAsB;gFAAS;oDAAT,yBAtB1B01H,OAsBI11H;;6CAtBJx2C;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAsBIi7d;6CAtBJ/8d;;;gDAeI88d,KAfJ7nY,QAeIpiF;4CAAe,iBAAfA;;;6CAAe;gFAAS;oDAAT,yBAfnBm7J,OAeIn7J;;6CAfJ9Q;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAeI+6d;6CAfJ98d;;;;6CAGIg1F,KAHJC;6CAGIj8I;6CAHJ;;;;iEAGIA;+CAHJ+mjB;;;;;;;;;;;;;;;;;;;;;;kDAGI/qa;6CAHJh1F;;;;;6CAMIoggB,MANJnra;6CAMIsoa;6CANJ;;;;;;;iEAMIA;+CANJqC;;;;;;;;;;;;;;;;;;;kDAMIQ;6CANJpggB;;;gDAWIqggB,MAXJpra,QAWItgC;4CAAwB,iBAAxBA;;;6CAAwB;gFAAS;oDAAT,yBAX5Bq5G,OAWIr5G;;6CAXJrzD;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAWI++f;6CAXJrggB;;;gDAYIsggB,MAZJrra,QAYI5gC;4CAAwB,iBAAxBA;;;6CAAwB;gFAAS;oDAAT,yBAZ5B25G,OAYI35G;;6CAZJ9yD;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAYI++f;6CAZJtggB;;;gDAwBIuggB,KAxBJtra,QAwBI9gC;4CAA8B,iBAA9BA;;;6CAA8B;gFAAS;oDAAT,yBAxBlC65G,OAwBI75G;;6CAxBJ3yD;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAwBI++f;6CAxBJvggB;;;gDAgBIwggB,KAhBJvra,QAgBIjhC;4CAAe,iBAAfA;;;6CAAe;gFAAS;oDAAT,yBAhBnBg6G,OAgBIh6G;;6CAhBJvyD;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAgBI++f;6CAhBJxggB;;;gDAoBIyggB,KApBJxra,QAoBIrhC;4CAAuB,iBAAvBA;;;6CAAuB;gFAAS;oDAAT,yBApB3Bo6G,OAoBIp6G;;6CApBJlyD;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAoBI++f;6CApBJzggB;;;;;;gDAcI0ggB,MAdJzra,QAcI0ra;4CAA6B,iBAA7BA;;;6CAA6B;gFAAS;oDAAT,yBAdjC3yV,OAcI2yV;;6CAdJv6f;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAcIs6f;6CAdJ1ggB;;;;6CAKI4ggB,MALJ3ra;6CAKI4ra;6CALJ;;;;;;iEAKIA;+CALJhB;;;;;;;;;;;;;;;;;;;;kDAKIe;6CALJ5ggB;;;gDAiBI8ggB,MAjBJ7ra,QAiBI8ra;4CAAqB,iBAArBA;;;6CAAqB;gFAAS;oDAAT,yBAjBzB/yV,OAiBI+yV;;6CAjBJz8f;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAiBIw8f;6CAjBJ9ggB;;;gDAuBIghgB,MAvBJ/ra,QAuBIgsa;4CAA8B,iBAA9BA;;;6CAA8B;gFAAS;oDAAT,yBAvBlCjzV,OAuBIizV;;6CAvBJh9f;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAuBI+8f;6CAvBJhhgB;;;;6CAmBIkhgB,MAnBJjsa;6CAmBI4oa;6CAnBJ35f;;;;;;;;;;;;;;;;;;;;;;mDgQmGakrf;4DhQhFOp2iB;;uFAAS;qDAAT,gCAnBpBg1N,OAmBoBh1N,SAAS;iDAAzB6kjB;+CAnBJkB;;;;;;kDAmBImC;6CAnBJlhgB;;;gDAkBImhgB,MAlBJlsa,QAkBI0oa;4CAAe,iBAAfA;;;6CAAe;gFAAS;oDAAT,yBAlBnB3vV,OAkBI2vV;;6CAlBJv6f;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAkBI+9f;6CAlBJnhgB;;;;;6CAEIohgB,MAFJnsa;6CAEIosa;6CAFJx6f;;;qEgQuLaysf,ahQvLbtlV,QAEIqzV;+CAFJ3xa;;;;;;;;;;;;;;;;;;;;;;;kDAEI0xa;6CAFJphgB;;;;6CAOIshgB,MAPJrsa;6CAOIssa;6CAPJ;;;;;;;;iEAOIA;+CAPJ5B;;;;;;;;;;;;;;;;;;kDAOI2B;6CAPJthgB;;;;6CASIwhgB,MATJvsa;6CASIwsa;6CATJ;;;;;;;;;;iEASIA;+CATJhC;;;;;;;;;;;;;;;;kDASI+B;6CATJxhgB;;;;6CAUI0hgB,MAVJzsa;6CAUI0sa;6CAVJ;;;;;;;;;;;iEAUIA;+CAVJnC;;;;;;;;;;;;;;;kDAUIkC;6CAVJ1hgB;;;gDAaI4hgB,MAbJ3sa,QAaI4sa;4CAA6B,iBAA7BA;;;6CAA6B;gFAAS;oDAAT,yBAbjC7zV,OAaI6zV;;6CAbJr7f;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAaIo7f;6CAbJ5hgB;;;gDAyBI8hgB,MAzBJ7sa,QAyBI8sa;4CAAoC,iBAApCA;;;6CAAoC;gFAAS;oDAAT,yBAzBxC/zV,OAyBI+zV;;6CAzBJt7f;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAyBIq7f;6CAzBJ9hgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uUA2B8D;8BA3B9D;wCA2B8D;yC1FtVpEqkI;;;;;;;;;;;;;;;;4B0V6FkCuqX,e1V7FlCvqX;;;;;;;;;;;;;;;;;;;;;;;;;;6C0V6FkC0rX;;;;;;;uBhQ8N5B;;;;;;;;;kDgQ9N4B+C;;;uBhQ8N5B;iCAAQ55iB,G,UAAR8ojB,kBAAQ9ojB,KA2BsD;uBA3B9D;iCAAKi8K;0BAAL;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDgQ9N4B49X,chQ8NvB59X,UAAL/iH;;;yDgQ9N4B2gf,chQ8NvB59X,UAAL9iH;;oEAAK8iH,UAAL6nW;;;2DgQ9N4BgzB,chQ8NvB76X,UAALquY;;oEAAKruY,UAALouY;;oEAAKpuY,UAALmuY;;oEAAKnuY,UAALkuY;;oEAAKluY,UAALiuY;;oEAAKjuY,UAALguY;;oEAAKhuY,UAAL+tY;;;gD1F3TN5+X,kB0F2TWnP,UAAL8tY;;;gD1F3TN3+X,kB0F2TWnP,UAAL6tY;;;iD1F3TN1+X,kB0F2TWnP,UAAL4tY;;;iD1F3TNz+X,kB0F2TWnP,UAAL2tY;;;iD1F3TNx+X,kB0F2TWnP,UAAL0tY;;;iD1F3TNv+X,kB0F2TWnP,UAALytY;;;iD1F3TNt+X,kB0F2TWnP,UAALwtY;;;iD1F3TNr+X,kB0F2TWnP,UAALutY;;;;;;gCgQ9N4B7T;gD,O1V7FlCvqX,kB0F2TWnP;gCAALstY;;;iD1F3TNn+X,kB0F2TWnP,UAALqtY;;;iD1F3TNl+X,kB0F2TWnP,UAALotY;;;iD1F3TNj+X,kB0F2TWnP,UAALmtY;;;iD1F3TNh+X,kB0F2TWnP,UAALktY;;;iD1F3TN/9X,kB0F2TWnP,UAALitY;;sD1F3TN99X,kB0F2TWnP,UAALgtY,KA2B8D;uBA3B9D;iCAAK/sY,QAALphK;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDgQ9N4Bg/hB,ehQ8NvB59X,SAALphK;;kDgQ9N4Bg/hB,ehQ8NvB59X,SAALphK;4CAAKohK,QAALphK;;kDgQ9N4Bi8hB,ehQ8NvB76X,SAALphK;4CAAKohK,QAALphK;4CAAKohK,QAALphK;4CAAKohK,QAALphK;4CAAKohK,QAALphK;4CAAKohK,QAALphK;4CAAKohK,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;;;;gCgQ9N4B86hB;;kC,O1V7FlCvqX,mB0F2TWnP;8BAALphK;;;kC1F3TNuwK,mB0F2TWnP,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;kC1F3TNuwK,mB0F2TWnP,QAALphK;iC1F3TNuwK,mB0F2TWnP,QAALphK,eA2B8D;uBA3B9D;iCAAKwhI,KAALxhI;0BAGI;2BAFAwwiB,0BgQ/NwBvR,chQ8NvBz9Z,MAALxhI;2BAEIywiB;kDgQhOwBxR,chQ8NvBz9Z,MAALxhI;2BAGI,eAHCwhI,KAALxhI;2BAII2wiB,0BgQlOwBzU,chQ8NvB16Z,MAALxhI;2BAKI,8BALCwhI,KAALxhI;2BAMI,+BANCwhI,KAALxhI;2BAOI,mCAPCwhI,KAALxhI;2BAQI,0BARCwhI,KAALxhI;2BASI,2BATCwhI,KAALxhI;2BAUI,qCAVCwhI,KAALxhI;2BAWIkxiB,wB1FtUV1gY,kB0F2TWhvC,KAALxhI;2BAYImxiB,wB1FvUV3gY,kB0F2TWhvC,KAALxhI;2BAaIoxiB;4B1FxUV5gY,kB0F2TWhvC,KAALxhI;2BAcIqxiB;4B1FzUV7gY,kB0F2TWhvC,KAALxhI;2BAeIsxiB,e1F1UV9gY,kB0F2TWhvC,KAALxhI;2BAgBIuxiB,e1F3UV/gY,kB0F2TWhvC,KAALxhI;2BAiBIwxiB,qB1F5UVhhY,kB0F2TWhvC,KAALxhI;2BAkBIyxiB,e1F7UVjhY,kB0F2TWhvC,KAALxhI;2BAmBI0xiB;;;gCgQjPwB3W;;kC,O1V7FlCvqX,kB0F2TWhvC;8BAALxhI;;2BAoBI2xiB,uB1F/UVnhY,kB0F2TWhvC,KAALxhI;2BAqBI4xiB;4B1FhVVphY,kB0F2TWhvC,KAALxhI;2BAsBI6xiB,sB1FjVVrhY,kB0F2TWhvC,KAALxhI;2BAuBI8xiB;4B1FlVVthY,kB0F2TWhvC,KAALxhI;2BAwBI+xiB;4B1FnVVvhY,kB0F2TWhvC,KAALxhI;2BAyBIgyiB;4B1FpVVxhY,kB0F2TWhvC,KAALxhI;;kCACIwwiB;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC;kCACAC,+BAE0D;uBA3B9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B;4BAAA;;;;;;;;;;sCgHiDE;wChHjDF;;;;;;;;;+FA2B8D;mDA3B9D/ua;;;;;;;;;;;;;;;;kDAGI;4EAHJF;;oDAGI;;uEAHJvB,KAGIygD;;;iDAYA;2EAfJl/C;;mDAeI;;6DmH6FJv7B,enH5GAg6B,KAeI0gD;;;gDAOA;0EAtBJn/C;;kDAsBI;;4DmHsFJv7B,enH5GAg6B,KAsBI4gD;;;+CArBA;yEADJr/C;;iDACI;;sEynBjcFw8Z,aznBgcF/9Z,KACIwgD;;;8CAGA;wEAJJj/C;;gDAII;;qEgQoHSy5Z,ahQxHbh7Z,KAII0lD;;;6CAiBA;uEArBJnkD;;+CAqBI;;yDmHuFJv7B,enH5GAg6B,KAqBI4lD;;;;;;;;;;;kDADA;4EApBJrkD;;oDAoBI;;8DmHwFJv7B,enH5GAg6B,KAoBI8lD;;;iDAJA;2EAhBJvkD;;mDAgBI;;6DmH4FJv7B,enH5GAg6B,KAgBIwlD;;;gDAQA;0EAxBJjkD;;kDAwBI;;4DmHoFJv7B,enH5GAg6B,KAwBIw/D;;;+CAZA;yEAZJj+D;;iDAYI;;2DmHgGJv7B,enH5GAg6B,KAYI0/D;;;8CADA;wEAXJn+D;;gDAWI;;0DmHiGJv7B,enH5GAg6B,KAWI4/D;;;6CALA;uEANJr+D;;+CAMI;;qEANJvB,KAMI8/D;;;;2CAEA;qEARJv+D;;6CAQI;;mEARJvB,KAQIggE;;;;;;;;;;;;;;iDAUA;2EAlBJz+D;;mDAkBI;;8DmH0FJv7B,enH5GAg6B,KAkBIkgE;;;gDACA;0EAnBJ3+D;;kDAmBI;;;;sDgQgFSs4Z;sE,O7ISb7zb,enH5GAg6B;sDAmBIogE;;;+CAIA;yEAvBJ7+D;;iDAuBI;;4DmHqFJv7B,enH5GAg6B,KAuBIsgE;;;8CANA;wEAjBJ/+D;;gDAiBI;;2DmH2FJv7B,enH5GAg6B,KAiBIwgE;;;6CAZA;uEALJj/D;;+CAKI;;qEALJvB,KAKIs/D;;;4CASA;sEAdJ/9D;;8CAcI;;yDmH8FJv7B,enH5GAg6B,KAcI+4F;;;;;;;;;;;iDAWA;2EAzBJx3F;;mDAyBI;;8DmHmFJv7B,enH5GAg6B,KAyBIw4F;;;gDAZA;0EAbJj3F;;kDAaI;;6DmH+FJv7B,enH5GAg6B,KAaI45F;;;+CAHA;yEAVJr4F;;iDAUI;;uEAVJvB,KAUIoya;;;8CADA;wEATJ7wa;;gDASI;;sEATJvB,KASIsya;;;6CAFA;uEAPJ/wa;;+CAOI;;qEAPJvB,KAOIwya;;;4CALA;sEAFJjxa;;8CAEI;;oEynBlcFw8Z,aznBgcF/9Z,KAEI0ya;;;sDAFJ;;;;uCA2B8D;0BA3B9D;;;;;;iCACIhC;2BADJ,MAEIC;2BAFJ,MAGIC;2BAHJ,MAIIC;2BAJJ,MAKIC;2BALJ,MAMIC;2BANJ,MAOIC;2BAPJ,MAQIC;2BARJ,MASIC;2BATJ,MAUIC;2BAVJ,MAWIC;2BAXJ,MAYIC;2BAZJ,MAaIC;2BAbJ,MAcIC;2BAdJ,MAeIC;2BAfJ,MAgBIC;2BAhBJ,MAiBIC;2BAjBJ,MAkBIC;2BAlBJ,MAmBIC;2BAnBJ,MAoBIC;2BApBJ,MAqBIC;2BArBJ,MAsBIC;2BAtBJ,MAuBIC;2BAvBJ,MAwBIC;2BAxBJ,MAyBIC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BADAW;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;;;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;0BAzBJ;;;;6CACIlC;;8CACAC;;+CACAC;;gDACAC;;iDACAC;;kDACAC;;mDACAC;;oDACAC;;qDACAC;;sDACAC;;uDACAC;;wDACAC;;yDACAC;;0DACAC;;2DACAC;;4DACAC;;6DACAC;;8DACAC;;+DACAC;;gEACAC;;iEACAC;;kEACAC;;mEACAC;;oEACAC;uEACAC,wEAE0D;uBA3B9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAyBIxojB,ImHyFJ06G,enHlHA47B,KAyBIwwa;;2BADAx3gB,MmH0FJorE,enHlHA47B,KAwBIuwa;+DACA7ta;2BAFAhgD,MmH2FJ0hB,enHlHA47B,KAuBIswa;+DACA3ta;2BAFA38F,MmH4FJo+D,enHlHA47B,KAsBIqwa;+DACA7ma;2BAFA3mD,MmH6FJuhB,enHlHA47B,KAqBIowa;+DACA3ma;2BAFAzmD,MmH8FJohB,enHlHA47B,KAoBImwa;+DACA7zZ;2BAFAl5D;;8BgQgFS02c;8C,O7Ieb11b,enHlHA47B;8BAmBIkwa;+DACAnpX;2BAFAvjG,MmHgGJ4gB,enHlHA47B,KAkBIiwa;+DACAjpX;2BAFA8b,MmHiGJ1+F,enHlHA47B,KAiBIgwa;+DACAntW;2BAFAG,MmHkGJ5+F,enHlHA47B,KAgBI+va;+DACAhtW;2BAFAG,MmHmGJ9+F,enHlHA47B,KAeI8va;+DACA7sW;2BAFAG,OmHoGJh/F,enHlHA47B,KAcI6va;iEACA1sW;2BAFAG,OmHqGJl/F,enHlHA47B,KAaI4va;iEACAvsW;2BAFAG,OmHsGJp/F,enHlHA47B,KAYI2va;iEACApsW;2BAFAG,OmHuGJt/F,enHlHA47B,KAWI0va;iEACAjsW;2BAFA,kBAVJzjE,KAUIyva;iEACA9rW;2BAFA,kBATJ3jE,KASIwva;iEACA3rW;2BAFA,kBARJ7jE,KAQIuva;iEACAxrW;2BAFA,kBAPJ/jE,KAOIsva;iEACAiF;2BAFA,kBANJv0a,KAMIqva;iEACAoF;2BAFA,kBALJz0a,KAKIova;iEACAuF;2BAFAG,kBgQoHS7Z,ahQxHbj7Z,KAIImva;iEACA0F;2BAFA,kBAHJ70a,KAGIkva;iEACA6F;2BAFAG,kBynBlcFlX,aznBgcFh+Z,KAEIiva;iEACAgG;2BAFAG,kBynBjcFpX,aznBgcFh+Z,KACIgva;iEACAmG;oCADAE,QA0B0D;uBA3B9D;;0BACW,GADXE,gBACW;;iCADXC;2BACW,MADXD;2BACW;;8BgQsLE7X;uChQtLL+X,+BADRnxa,MACQmxa,YAAE;;;0BAAC;4BACW;mCAFtBD;6BAEsB,MAFtBD;6BAEsB;;gCgQqLT7X;yChQrLMx+X,+BAFnB56B,MAEmB46B,YAAE;;;4BAAC;8BACd,mBAHR56B;8BAGQ;gCACG;uCAJXkxa;iCAIW,MAJXD;iCAIW;;oCgQoHE5a;6ChQpHLmI,+BAJRx+Z,MAIQw+Z,YAAE;;;gCAAC;kCACY,mBALvBx+Z;kCAKuB;oCACC,mBANxBA;oCAMwB;sCACI,mBAP5BA;sCAO4B;wCACT,mBARnBA;wCAQmB;0CACC,mBATpBA;0CASoB;4CACU,mBAV9BA;4CAU8B;8CACC;qDAX/Bkxa;+CAW+B,MAX/BD;+CAW+B;;2DAAHvS,+BAX5B1+Z,MAW4B0+Z,YAAE;;;8CAAC;gDACA;uDAZ/BwS;iDAY+B,MAZ/BD;iDAY+B;;6DAAHpS,+BAZ5B7+Z,MAY4B6+Z,YAAE;;;gDAAC;kDACK;yDAbpCqS;mDAaoC,MAbpCD;mDAaoC;;+DAAH7R,+BAbjCp/Z,MAaiCo/Z,YAAE;;;kDAAC;oDACA;2DAdpC8R;qDAcoC,MAdpCD;qDAcoC;;iEAAH1R,+BAdjCv/Z,MAciCu/Z,YAAE;;;oDAAC;sDACd;6DAftB2R;uDAesB,MAftBD;uDAesB;;mEAAH11Y,+BAfnBv7B,MAemBu7B,YAAE;;;sDAAC;wDACA;+DAhBtB21Y;yDAgBsB,MAhBtBD;yDAgBsB;;qEAAHx1Y,+BAhBnBz7B,MAgBmBy7B,YAAE;;;wDAAC;0DACM;iEAjB5By1Y;2DAiB4B,MAjB5BD;2DAiB4B;;uEAAHI,+BAjBzBrxa,MAiByBqxa,YAAE;;;0DAAC;4DACN;mEAlBtBH;6DAkBsB,MAlBtBD;6DAkBsB;;yEAAHM,+BAlBnBvxa,MAkBmBuxa,YAAE;;;4DAAC;8DACQ;qEAnB9BL;+DAmB8B,MAnB9BD;+DAmB8B;;kEgQgFjB/b;2EhQhFOrrX;oEAAG;sFAAHE,+BAnBpB/pC,MAmBoB+pC,YAAE;6EAAFF;mFAAS;;;8DAAC;gEACA;uEApB9BqnY;iEAoB8B,MApB9BD;iEAoB8B;;6EAAH/mY,+BApB3BlqC,MAoB2BkqC,YAAE;;;gEAAC;kEACS;yEArBvCgnY;mEAqBuC,MArBvCD;mEAqBuC;;+EAAH7mY,+BArBpCpqC,MAqBoCoqC,YAAE;;;kEAAC;oEACV;2EAtB7B8mY;qEAsB6B,MAtB7BD;qEAsB6B;;iFAAHU,+BAtB1B3xa,MAsB0B2xa,YAAE;;;oEAAC;sEACQ;6EAvBrCT;uEAuBqC,MAvBrCD;uEAuBqC;;mFAAHa,+BAvBlC9xa,MAuBkC8xa,YAAE;;;sEAAC;wEACA;+EAxBrCZ;yEAwBqC,MAxBrCD;yEAwBqC;;qFAAHrmY,+BAxBlC5qC,MAwBkC4qC,YAAE;;;wEAAC;0EACM,UAzB3CsmY,UAyB2C,MAzB3CD;0EAyB2C;4FAAHnmY,+BAzBxC9qC,MAyBwC8qC,YAAE;;;wEADL;sEADA;oEADR;kEADU;gEADT;8DADA;4DADR;0DADM;wDADN;sDADA;oDADc;kDADA;gDADL;8CADA;4CADD;0CADV;wCADD;sCADS;oCADJ;kCADD;gCADZ;8BADH;4BADc;0BADX,QAAuB;uBADlC;;;4CynBhcEuuX,eznBgcF6Y;4CynBhcE7Y,eznBgcF6Y;;4CgQwHa5b,ehQxHb4b;;;;;;;;uCmHqGArqc,iBnHrGAqqc;;uCmHqGArqc,iBnHrGAqqc;;uCmHqGArqc,iBnHrGAqqc;;uCmHqGArqc,iBnHrGAqqc;;uCmHqGArqc,iBnHrGAqqc;;uCmHqGArqc,iBnHrGAqqc;;uCmHqGArqc,iBnHrGAqqc;;uCmHqGArqc,iBnHrGAqqc;;;;8BgQmGa/c;uChQhFO1kb;gC,kBmHkFpB5I,iBnHrGAqqc,YAmBoBzhc;8BAnBpB0ic;;;uCmHqGAtrc,iBnHrGAqqc;;uCmHqGArqc,iBnHrGAqqc;;uCmHqGArqc,iBnHrGAqqc;;uCmHqGArqc,iBnHrGAqqc;;uCmHqGArqc,iBnHrGAqqc;;mCmHqGArqc,iBnHrGAqqc;;;0BACW,GADXjnY,gBACW;;iCADXC;2BACW,MADXD;2BACW;;8BgQsLEquX;uChQtLLnuX,+BADRnrC,MACQmrC,YAAE;;;0BAAC;4BACW;mCAFtBD;;6BAEsB;;gCgQqLTouX;yChQrLMqa,+BAFnB3za,MAEmB2za,YAAE;;;4BAAC;8BACd,qBAHR3za;8BAGQ;gCACG;uCAJXkrC;;iCAIW;;oCgQoHEqrX;6ChQpHLsd,+BAJR7za,MAIQ6za,YAAE;;;gCAAC;kCACY,qBALvB7za;kCAKuB;oCACC,qBANxBA;oCAMwB;sCACI,qBAP5BA;sCAO4B;wCACT,qBARnBA;wCAQmB;0CACC,qBATpBA;0CASoB;4CACU,qBAV9BA;4CAU8B;8CACC;qDAX/BkrC;;+CAW+B;;2DAAH6oY,+BAX5B/za,MAW4B+za,YAAE;;;8CAAC;gDACA;uDAZ/B7oY;;iDAY+B;;6DAAH+oY,+BAZ5Bj0a,MAY4Bi0a,YAAE;;;gDAAC;kDACK;yDAbpC/oY;;mDAaoC;;+DAAHipY,+BAbjCn0a,MAaiCm0a,YAAE;;;kDAAC;oDACA;2DAdpCjpY;;qDAcoC;;iEAAHmpY,+BAdjCr0a,MAciCq0a,YAAE;;;oDAAC;sDACd;6DAftBnpY;;uDAesB;;mEAAHqpY,+BAfnBv0a,MAemBu0a,YAAE;;;sDAAC;wDACA;+DAhBtBrpY;;yDAgBsB;;qEAAHupY,+BAhBnBz0a,MAgBmBy0a,YAAE;;;wDAAC;0DACM;iEAjB5BvpY;;2DAiB4B;;uEAAHypY,+BAjBzB30a,MAiByB20a,YAAE;;;0DAAC;4DACN;mEAlBtBzpY;;6DAkBsB;;yEAAH2pY,+BAlBnB70a,MAkBmB60a,YAAE;;;4DAAC;8DACQ;qEAnB9B3pY;;+DAmB8B;;kEgQgFjBkqX;2EhQhFO2f;oEAAG;sFAAHE,+BAnBpBj1a,MAmBoBi1a,YAAE;6EAAFF;mFAAS;;;8DAAC;gEACA;uEApB9B7pY;;iEAoB8B;;6EAAHiqY,+BApB3Bn1a,MAoB2Bm1a,YAAE;;;gEAAC;kEACS;yEArBvCjqY;;mEAqBuC;;+EAAHmqY,+BArBpCr1a,MAqBoCq1a,YAAE;;;kEAAC;oEACV;2EAtB7BnqY;;qEAsB6B;;iFAAHqqY,+BAtB1Bv1a,MAsB0Bu1a,YAAE;;;oEAAC;sEACQ;6EAvBrCrqY;;uEAuBqC;;mFAAHuqY,+BAvBlCz1a,MAuBkCy1a,YAAE;;;sEAAC;wEACA;+EAxBrCvqY;;yEAwBqC;;qFAAHyqY,+BAxBlC31a,MAwBkC21a,YAAE;;;wEAAC;oFAxBrCzqY;iF1F3TNF;4F0FoV8C6qY,+BAzBxC71a,MAyBwC61a,YAAE;;;wEADL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAvBH;uBADlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4B;4BAAA;;;;;;;;;;sCgHiDE;wChHjDF;;;;;;;;;+FA2B8D;mDA3B9D14a;;;;;;;;;;;;;;;;kDAGI;4EAHJF;;oDAGI;;uEAHJvB,KAGIygD;;;iDAYA;2EAfJl/C;;mDAeI;;6DmH6FJv7B,enH5GAg6B,KAeI0gD;;;gDAOA;0EAtBJn/C;;kDAsBI;;4DmHsFJv7B,enH5GAg6B,KAsBI4gD;;;+CArBA;yEADJr/C;;iDACI;;sEynB5bN+8Z,aznB2bEt+Z,KACIwgD;;;8CAGA;wEAJJj/C;;gDAII;;qEgQjPyBg6Z,ahQ6O7Bv7Z,KAII0lD;;;6CAiBA;uEArBJnkD;;+CAqBI;;yDmHuFJv7B,enH5GAg6B,KAqBI4lD;;;;;;;;;;;kDADA;4EApBJrkD;;oDAoBI;;8DmHwFJv7B,enH5GAg6B,KAoBI8lD;;;iDAJA;2EAhBJvkD;;mDAgBI;;6DmH4FJv7B,enH5GAg6B,KAgBIwlD;;;gDAQA;0EAxBJjkD;;kDAwBI;;4DmHoFJv7B,enH5GAg6B,KAwBIw/D;;;+CAZA;yEAZJj+D;;iDAYI;;2DmHgGJv7B,enH5GAg6B,KAYI0/D;;;8CADA;wEAXJn+D;;gDAWI;;0DmHiGJv7B,enH5GAg6B,KAWI4/D;;;6CALA;uEANJr+D;;+CAMI;;qEANJvB,KAMI8/D;;;;2CAEA;qEARJv+D;;6CAQI;;mEARJvB,KAQIggE;;;;;;;;;;;;;;iDAUA;2EAlBJz+D;;mDAkBI;;8DmH0FJv7B,enH5GAg6B,KAkBIkgE;;;gDACA;0EAnBJ3+D;;kDAmBI;;;;sDgQhQyB64Z;sE,O7IyV7Bp0b,enH5GAg6B;sDAmBIogE;;;+CAIA;yEAvBJ7+D;;iDAuBI;;4DmHqFJv7B,enH5GAg6B,KAuBIsgE;;;8CANA;wEAjBJ/+D;;gDAiBI;;2DmH2FJv7B,enH5GAg6B,KAiBIwgE;;;6CAZA;uEALJj/D;;+CAKI;;qEALJvB,KAKIs/D;;;4CASA;sEAdJ/9D;;8CAcI;;yDmH8FJv7B,enH5GAg6B,KAcI+4F;;;;;;;;;;;iDAWA;2EAzBJx3F;;mDAyBI;;8DmHmFJv7B,enH5GAg6B,KAyBIw4F;;;gDAZA;0EAbJj3F;;kDAaI;;6DmH+FJv7B,enH5GAg6B,KAaI45F;;;+CAHA;yEAVJr4F;;iDAUI;;uEAVJvB,KAUIoya;;;8CADA;wEATJ7wa;;gDASI;;sEATJvB,KASIsya;;;6CAFA;uEAPJ/wa;;+CAOI;;qEAPJvB,KAOIwya;;;4CALA;sEAFJjxa;;8CAEI;;oEynB7bN+8Z,aznB2bEt+Z,KAEI0ya;;;sDAFJ;;;;uCA2B8D;0BA3B9D;;;;;;iCACIhC;2BADJ,MAEIC;2BAFJ,MAGIC;2BAHJ,MAIIC;2BAJJ,MAKIC;2BALJ,MAMIC;2BANJ,MAOIC;2BAPJ,MAQIC;2BARJ,MASIC;2BATJ,MAUIC;2BAVJ,MAWIC;2BAXJ,MAYIC;2BAZJ,MAaIC;2BAbJ,MAcIC;2BAdJ,MAeIC;2BAfJ,MAgBIC;2BAhBJ,MAiBIC;2BAjBJ,MAkBIC;2BAlBJ,MAmBIC;2BAnBJ,MAoBIC;2BApBJ,MAqBIC;2BArBJ,MAsBIC;2BAtBJ,MAuBIC;2BAvBJ,MAwBIC;2BAxBJ,MAyBIC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BADAW;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;6BADAC;;;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;oCACAD;0BAzBJ;;;;6CACIlC;;8CACAC;;+CACAC;;gDACAC;;iDACAC;;kDACAC;;mDACAC;;oDACAC;;qDACAC;;sDACAC;;uDACAC;;wDACAC;;yDACAC;;0DACAC;;2DACAC;;4DACAC;;6DACAC;;8DACAC;;+DACAC;;gEACAC;;iEACAC;;kEACAC;;mEACAC;;oEACAC;uEACAC,wEAE0D;uBA3B9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCACIjujB;;mCACA03jB;;oCACAngiB;;qCACAz3B;;sCACA23jB;;uCACAD;;wCACAD;;yCACAD;;0CACAD;;2CACAD;;4CACAD;;6CACAD;;8CACAD;;+CACAD;;gDACAD;;iDACAD;;kDACAD;;mDACAD;;oDACAD;;qDACAD;;sDACAD;;uDACAD;;wDACAD;;yDACAD;4DACArI,yDAE0D;uBA3B9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCACIjujB;kCACA03jB;kCACAngiB;kCACAz3B;kCACA23jB;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACAD;kCACArI,+BAE0D;uBA3B9D;iCAgCuC1rjB;;2BAyBrC0rjB;2BADAqI;2BADAC;2BADAC;2BADAC;2BADAC;2BADAC;2BADAC;2BADAC;2BADAC;2BADAC;2BADAC;2BADAC;2BADAC;2BADAC;mCAgBAU,UAAUt4jB,EAAE00F,MAAa,eAAf10F,OAAE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BjwCF,e5oBiwCEA;uB4oBjwCF,Y5oBiwCEA;uB4oBjwCF,oB5oBiwCEA;uB4oBjwCF,S5oBiwCEA;uB4oBjwCF,Y5oBiwCEA;uB4oBjwCF,U5oBiwCEA;uB4oBjwCF,S5oBiwCEA;uB4oBjwCF,a5oBiwCEA;uB4oBjwCF,c5oBiwCEA;uB4oBjwCF,gB5oBiwCEA;uB4oBjwCF,Y5oBiwCEA;uB4oBjwCF,iB5oBiwCEA;uB4oBjwCF,kB5oBiwCEA;uB4oBjwCF,U5oBiwCEA;uB4oBjwCF,U5oBiwCEA;uB4oBjwCF,S5oBiwCEA;uB4oBjwCF,gB5oBiwCEA;uB4oBjwCF,S5oBiwCEA;uB4oBjwCF,mB5oBiwCEA;uB4oBjwCF,K5oBiwCEA;uB4oBjwCF,a5oBiwCEA;uB4oBjwCF,e5oBiwCEA;uB4oBjwCF,oB5oBiwCEA;uB4oBjwCF,mB5oBiwCEA;uB4oBjwCF,2B5oBiwCEA;uB4oBjwCF,0B5oBiwCEA;uB4oBjwCF,mB5oBiwCEA;uB4oBjwCF,gB5oBiwCEA;uB4oBjwCF,wB5oBiwCEA;uB4oBjwCF,wB5oBiwCEA;uB4oBjwCF,gB5oBiwCEA;uB4oBjwCF,gB5oBiwCEA;uB4oBjwCF,oB5oBiwCEA;uB4oBjwCF,yB5oBiwCEA;uB4oBjwCF,Y5oBiwCEA;uB4oBjwCF,Q5oBiwCEA;uB4oBjwCF,mB5oBiwCEA;uB4oBjwCF,wB5oBiwCEA;uB4oBjwCF,0B5oBiwCEA;uB4oBjwCF,Y5oBiwCEA;uB4oBjwCF,yB5oBiwCEA;uB4oBjwCF,W5oBiwCEA;uB4oBjwCF,c5oBiwCEA;uB4oBjwCF,S5oBiwCEA;uB4oBjwCF,a5oBiwCEA;sB4oBjwCF,Q5oBiwCEA;sB4oBjwCF,M5oBiwCEA;sB4WhwCY;uBgSDd;;;2BA0HmB;;;4BAGd,gCAHEQ,UACAllH;2BAEF,SAEEhpiB,EAAEhD;6BACJ,IAAIwB,Q5oBioCPkvpB;6B4oBhoCM,gCADClvpB,QADAxB,MAE6B;6BADjC,UAEgC,W5oB+nCnC0wpB,c4oBloCO1wpB;6BAGmB,qB5oB+nC1B0wpB,qB4oB/nCwD;2BALrD,oBADE3yf,OAGA/6J;uBA/HP;;uBA2IU,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;;;;;;;;;4BumBzTAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBvmBwTJ;;0CAzCA04H;sBAsDkE;;sBxI9V9DhkhB;sBI4HFwV;sBADAD;sBJ5HExV;sByIVN;;sBiW+EoB;;uBjW/EpB;yCNuLSksgB;;;;;;mC9BqkCiBntF;6B,UAApBD,2BAAoBC;;;;uByBvkBXulG;wBgmBloBCroC;0BjmBhDImP;4BjBERrsD,0ByP2PsB7lC,elXzMvBywF;uB2I8nBI2L;;;;wBlBhrBHv2D,0ByP2PsB7lC,elXzMvBywF;uB2I8nBI+6B,uBuOrbmBxrH,elXzMvBywF;uBsJnBH;;;;;;;;;;;wCXipBO/1nB;kC;0CATLihoB;;;2CASK6vB;;;;;;8CwU1eJ31e;;+CxU0eIw1e;;;;;;;uBWjpBP;;0BAAoEnxB;0B;kCAApEuxB;;;mCAAoEvxB;uEAyBrB;uBAzB/C;;0BAAM0xB;0BAA+BC;;0BAArC;;;;;;4C4N4N0B5rH,cuFzKxB3rX;gD,OhVlFNwxZ;gD,OiBFAssD;;+CwO6P8BnyF,cuFzKxB3rX;mC9TslBO43e;4B,OlBxqBbpmF;0BkBuqBM;2BAAOusD,6BuO5aiBpyF,cuFzKxB3rX;2B9TqlBA,KWxoBF03e;2BXwoBE,KWxoBFA;2BXiZE,KAuPAljhB;2BAvPA,KAuPAA;2BAvPA,KAuPAA;2BArbE,KA8LFH;2BA9LE,KA8LFA;2BA9LE,KA8LFA;2BAzYI,KA2MF8B;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME;;;;4DAgoBG4nf,kBAhoBHs6B;;;4DAgoBGt6B,kBAhoBHvnD;;;;;;;;8BnHuHdvzZ,kBmH0gBiB20e,yBAjoBHO;2BzBmKR,GyBnKQD;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR;;;;;;;2ByBwCM;;;;;;gCA3ME11G;gCzBmKR;2ByBwCM;0DgmBpMJksE,oBhmBoMIupC;2BA8LF;;;;8BA9LE;2BA8LF;2BAuPA;;;;8BAvPA;;;2CWjZIX,+BXiZJQ;2BWjZF;;;;8BXwoBE;;;2CWxoBmCP,+BXwoBnCM;2BzBglBMU;;;2BAAV,KoCxtCEd;2BpCwtCF,KoCxtCEA;2BpCwtCF;mCA3CYe;;6BA4CUxnmB;;;iEADZunmB,kBACYxnmB;;gEADZwnmB,kBACYvnmB;0BA5CpB;gCA2CF0jF;2BA3CE,KA2CFA;2BACa02e,KA5CX/ngB;2BA4CWwxB,KA5CXxxB;2BA4CW++b;2BA5CX;;;;oDA4CWA;2BADb;;;;;2CA3CEnpH,OAnvBF4nH,cAmvBY23G,gBAAV16gB;2BoC7qCA;;;;8BpCwtCF;2B8BrkCF,KMnJI05gB;2BNmJJ,KMnJIA;2BNmJJ,MMnJIA;2BNmJJ,MMnJIA;2BNnBF,KAsKFqB;2BAtKE,KAsKFA;2BAtKE,KAsKFA;;2BAtKE;;;;;;gCkO+O4BnnH;;;mClO5OrB1gf;;;;;;gCAHPksF;;;2BAMM8la;;;2BANN;;;;;2CAMMA;2BAgKR;;;;;;gCAtKEk2G;;kCkO+O4BrpH;;;qClOvOrB7+e;;;;;;kCARP8nmB;2BA0CA,IA4HFF;2BA5HE,GA4HFA;2BA5HE,KA4HFA;2BA5HE,KA4HFA;2BA5HE,KA4HFA;2BA5HE,KA4HFA;2BA5HE,KA4HFA;2BA5HE,KA4HFA;2BA5HE,KA4HFA;2BA5HE,KA4HFA;2BA5HE;;;;;;gCkOqM4BlnH;;;mClOlMrB1gf;;;;;;gCAHPssF;;;;;;gCkOqM4Bo0Z;;;mClO/LrB1gf;;;;;;gCANP0omB;;;2BAQQK;;;2BARR;;;;;2CAQQA;2BARR;;;;;gCkOqM4BprH;;;mClO3LrB39e;;;;;;gCAVPwomB;;;2BAaMW;;;2BAbN;;;;;2CAaMA;2BAbN;;2BAeMG;;;2BAfN;;;;;2CAeMA;2BAfN;;2BAiBMG;;;2BAjBN;;;;;2CAiBMA;2BAjBN;;2BAmBMG;;;2BAnBN;;;;;2CAmBMA;2BAnBN;;2BAqBMI;;;2BArBN;;;;;2CAqBMA;2BArBN;;2BAuBMI;;;2BAqGR;;;;;;gCA5HEH;;6CAuBMG;2BAqGR;;;;;;mCMnJI3C;;;qCNmJJ6C;qC9BioCI3oG;;;0C8B5nCI3hgB;;;;;;;uCALR0nmB,OM1HmD;uBAzB/C;;0BAAM8C;0BAA+BC;0BpCytC3B9opB;0BoCztCV61C;;;;;;;4C4N4N0Bojf,euFzKxB3rX;;4B,OhVlFNwxZ;;4B,OiBFAusD;;+CwO6P8BpyF,euFzKxB3rX;mC9TslBOy7e;4B,OlBxqBbjqF;0BkBuqBM;2BAAOwsD,2BuO5aiBryF,euFzKxB3rX;2B9TqlBA,KWxoBFy3e;2BXwoBE,KWxoBFA;2BXiZE,KAuPAljhB;2BAvPA,KAuPAA;2BAvPA,KAuPAA;2BArbE,KA8LFH;2BA9LE,KA8LFA;2BA9LE,KA8LFA;2BAzYI,KA2MF8B;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME,KA2MFA;2BA3ME,8BzBitCIxjI,IoCztCV61C,OXQMwtF;6CAgoBGiof,gBzBilBCtrnB,IyBjtCJ6vC;6CAgoBGy7kB,gBzBilBCtrnB,IyBjtCJ4vC;yDzBitCI5vC,IyBjtCJ2vC;;4BnHuHd4gI,mBmH0gBiBw4e,uBzBglBC/opB,IyBjtCJwwC;2BzBmKR,GyBnKQ+0mB;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,GyBnKQA;2BzBmKR,oBA8iCYvlpB,IyBjtCJ21C,OzBmKRyI;iDA8iCYp+C,IA9iCZC;iDA8iCYD,IA9iCZi6B;iDA8iCYj6B,IA9iCZk8B;iDA8iCYl8B,IA9iCZ0qC;iDA8iCY1qC,IA9iCZysC;iDA8iCYzsC,IA9iCZ2sC;iDA8iCY3sC,IA9iCZ+sC;2ByBwCMiK,OgmBpMJglkB,qBznB0sCUh8mB,IyBtgCN0vC;2BA8LFkB,wBzBw0BQ5wC,IyBtgCNg3C;2BA8LF,oBzBw0BQh3C,IyBx0BR4wC;;uCWjZIi4mB,+BpCytCI7opB,IyBx0BR2wC;2BzBw0BQW;uCoCztC2Bw3mB,+BpCytC3B9opB,IyBjlBRmxC;2BzBglBM63mB;;;2BAAV,KoCxtCElE;2BpCwtCF,KoCxtCEA;0BpCwtCF,SA3CYmE,cA4CAjppB;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;qDADJ,MAEIznG;;;;;sDADA6nG;sDoCtsCE54b,apCssCF44b,cACA5nG;;;;;sDoCvsCEhxV;uDpCqsCN;;;;mEACIw4b;sEACAznG;;6CoCvsCEilG;0CAnBJ;;;yCAyB+C;4BAzB/C;;;;;;mCACID;6BADJ,MAmBIC;6BAnBJ,MAuBInlG;;;;+BAJAgoG;+BAlBAC;wDAkBAD,iBAIA3nG;4BAvBJ;;;;+CACI6kG;;gDAkBAC;mDAIAnlG;mCAuJRr3c;4B;yD7B7MAyqd;;;;gCknBmDA1+B;gD,OjmBrDA+qF;6BSWEwyB;;;;;;;;+BAWI,eAXJA,QAWI9rB;;+BADA;;kCAVJ6rB;kCAUI19F;mEACA38a;+BAFA;mEACAC;8BADA;;6BRyVAsuf;qDQ9SNusB;;mCG9BImM;;uCX4UE;;;wCAQI;;2CARJ14B,0BAQIC;;wCADA;4EACAxuf;uCADA;;qCWrKV38I;+CA9KIktqB;oEAoLAh2f;;+BACEloD,8BADFkoD;+BAEEw5Y;;8EADA1hc,IADFrrH;;6CAEEqrH;gC;yCqlBlKNqqb;kDrlBkKMrqb;2C,OZvNN41gB;6DYuNM51gB;sD,O7BrNNupd,2B6BqNMvpd;;;;;;;qCAtLFo+iB,+BA+KAl2f;8B,IACEloD,4BADFkoD;4DHjJJwgf,eGkJM1oiB,IADFrrH;sCA/KAA;qCXwoBE0pqB,2BWpoBMr+iB;8B,O7BnCZgpd;gD6BmCYhpd;yC,kBfwBR6ib,evITF/pb,csJfUkH;;;qCXooBN61gB,oBWtoBM71gB;8B,kBf0BR6ib,evITF/pb,csJjBUkH;;;;;6BXMFoic,OAgoBJi8G,2BWxoBFH;6BXQM77G,OAgoBJwzE,oBAhoBIzzE;oCAgoBJyzE,oBAhoBIxzE;oCAgoBJg8G,2BAhoBI/7G;6BzBmKRE;;gCmHoXAprc;gC1FyGIinjB;gCAhoBI97G;;;6BzBmKRvic;;;;;;;6BoC/JU+hc,+BpC+JVD;;6ByBwCMw8G;;gCgmBpMJx0H;yCjmBhDJ9pb;+DY6CYA;oC,O7B3CZgpd;sD6B2CYhpd;+C,kBfgBR6ib,evITF/pb,csJPUkH;;;yCZ7CZ61gB;gCY6CY9zE;;6BXqYNU,wBA9LE67G;6B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;kCAQA+0B;kCAEAl9c;kCAEA0/U;uBA3SE;;4C;;;0BwQmGJm+B;0B6UpFYyjD;4BjmBhDImP;8BjBERrsD,0ByP2PsB7lC,elXzMvBywF;uBsJnBH;wCwQmGJnxD;;;2B,O3QzHsDslF,gB3HqJ1Drse;;wC0V6FkCynX,e/NzMrB6lH;;;wC,ORyTiC5sB;uBWjBtC;;;;;;;4C,OA3ToEyyB;;uBA2TpE;uBAkB+C;wC,UAlB/CkT;uBAkB+C;iCAlB/CpwqB;0B,qB4N/F0ByxiB,cuFzKxB3rX;gD,OhVlFNwxZ;gD,OiBFAssD;;;;8BoRoIA7yD;8C,O6UpFIyjD;4C7UoFJzjD;;4B,O3QzHEulF;;4C+NkP4B7kH,c3OhMrB73X;;iCe5BLujf;mD,OX4UEzyB;;mCWjBF1qoB;uBAkB+C;iCAlB/CyY;0B,qB4N/F0Bi5hB,euFzKxB3rX;;4B,OhVlFNwxZ;;4B,OiBFAusD;;;;8BoRoIA9yD;;gC,O6UpFIyjD;4C7UoFJzjD;;4B,O3QzHE0lF;;;4C+NkP4BhlH,e3OhMrB73X;;iCe5BLwnf;;qC,OX4UEx2B;;mCWjBFpynB;;qCAkB+C;;iCAD7CA;0B,qB4NhHwBk5hB,cuFzKxB3rX;;4B,OhVlFNwxZ;;4B,OiBFAwsD;;;;8BoRoIA/yD;;gC,O6UpFIyjD;4C7UoFJzjD;;4B,O3QzHE6lF;;4C+NkP4BnlH,c/NzM1B2lH;;iCGnBAqK;;qC,OX4UE32B;;mCWAAvynB;;;uBAC6C;iCAlB/CA;0B,qB4N/F0Bk5hB,cuFzKxB3rX;;4B,OhVlFNwxZ;;4B,OiBFAwsD;;;;8BoRoIA/yD;;gC,O6UpFIyjD;4C7UoFJzjD;;4B,O3QzHE6lF;;4C+NkP4BnlH,c/NzM1B2lH;;iCGnBAwK;;qC,OX4UE92B;;mCWjBFvynB;2CAkB+C;uBAlB/C;uCAAK43pB;sBiWhRO;uBjWgRZ;;;;;;;;;;;;8CA4CmB5yqB,GAAI,kBARZ2zqB,UAQQ3zqB,EAAa;uBA5ChC,uBA8CmBA,GAAI,kBAVZ0zqB,UAUQ1zqB,EAAa;uBA9ChC,SA4CQ6zqB,cAEAC;uBA9CR;;yBAAKlB;yBAALC;;;;mD;uBAAA;;;;;;;;uBAgCF;;sBiWhTc;uBjWgTd;;;;;;;;;;;4C;;wBf1SUlwC;0BomBlCA7L;4BjmBhDImP;8BjBERrsD,0ByP2PsB7lC,elXzMvBywF;uBsJwUL;6Bf1SU7B;;;2B,OYvE0Cg2B,gB3HqJ1Drse;;6B+GnGgBk2c,gBYTHo3B;;;wC,ORyTiC5sB;uBWiDtC;;;;;;;4C,OA7XoEyyB;;uBA6XpE;uBAmB+C;wC,UAnB/CgV;uBAmB+C;iCAnB/ClyqB;0B,qB4NjK0ByxiB,cuFzKxB3rX;gD,OhVlFNwxZ;gD,OiBFAssD;gD,OimBgDIpP;gD,OpmBkCA6L;;gD,OAAAA;;4B,OYvEFi2B;yCZkDEt2pB;4B,kB2OgM0ByxiB,c3OhMrB73X,UAAL55K;;iCe5BAm9pB;mD,OX4UEzyB;;mCWiDF1qoB;uBAmB+C;iCAnB/CyY;0B,qB4NjK0Bi5hB,euFzKxB3rX;;4B,OhVlFNwxZ;;4B,OiBFAusD;;4B,OimBgDIrP;;4B,OpmBkCA6L;;;4B,OAAAA;;4B,OYvEFo2B;;yCZkDEj+oB;4B;gD2OgM0Bi5hB,e3OhMrB73X,SAALphK;;iCe5BA4opB;;qC,OX4UEx2B;;mCWiDFpynB;;qCAmB+C;;iCAD7CA;0B,qB4NnLwBk5hB,cuFzKxB3rX;;4B,OhVlFNwxZ;;4B,OiBFAwsD;;4B,OimBgDItP;;4B,OpmBkCA6L;;;4B,OAAAA;;4B,OYvEFu2B;;4B,OZkDE52B,cYTAo3B;;iCGnBAqK;;qC,OX4UE32B;;mCWmEAvynB;;;uBAC6C;iCAnB/CA;0B,qB4NjK0Bk5hB,cuFzKxB3rX;;4B,OhVlFNwxZ;;4B,OiBFAwsD;;4B,OimBgDItP;;4B,OpmBkCA6L;;;4B,OAAAA;;4B,OYvEFu2B;;4B,OZkDE52B,cYTAo3B;;iCGnBAwK;;qC,OX4UE92B;;mCWiDFvynB;2CAmB+C;uBAnB/C;uCAAK05pB;sBiWlVO;uBjWkVZ;;;;;;;;;;;;;8CA6CmB10qB,GAAI,kBARZy1qB,UAQQz1qB,EAAa;uBA7ChC,uBA+CmBA,GAAI,kBAVZw1qB,UAUQx1qB,EAAa;uBA/ChC,SA6CQ21qB,cAEAC;uBA/CR;;yBAAKlB;yBAALC;;;;mD;uBAAA;;;;;;;;uBAiCF;;sBiWnXc;uBjWmXd;;;;;;;;;;sBAoBH;;sBzI3cG75hB;sBI4HFwV;sBsexDgB;;;;;;;;;;;;;;;;;;;;;;;;;;;sBteuDhBD;sBJ5HExV;sBoxBVN;;sB1S+EoB;uB0S/EpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAEkD;;sBpxBS5CC;sBI4HFwV;sBADAD;sBJ5HExV;sB0IVN;;sBAiBM;;;;;;;;;;;;;;;;sBgW8Dc;uBhW3DR;iCAM+Bo6b;0BACzB,IAAZmlF,UAAY,sCADyBnlF;0BAGzB;uEAFZmlF,WAEwC;uBATlC;;;;;;;;;;;;;;;;;;uBAgBC;uBAII,uBsmBmHNt2T,SlnBorCH4sT;uBYvyCS;;gCsmBmHN5sT;uBtmBnHM;wC,aZuyCT4sT;uBYvyCS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BA8BThgmB;2BA5CJolnB;uBAca;;;;;;;;;;;;;;0BA4Cf;;;;;;;2BsmBwEE;2BACQ;;8BADJjzqB,kBAC8B,kBlnBkrC9B6tpB,mBknBlrCsD;0BAAlD,eAYDxwpB;4BACK,IAAJK,EAAI,mBAfLujW;4BAgBH,OAFG5jW,EAEa,iBADZK;4BACJ,wBADIA,EAEgB;0BAfhB,eAKDL;4BACH;8BAEM,IADEK,EACF,mBAAiB,OAVpBujW,SlnBorCH4sT;8BknBxqCI,OALDxwpB,EAKiB,iBAHZK;8BAGJ,wBAHIA,EAIe;4BALvB,kBlnB4qCAmwpB,iBknBvqCyB;0BAXrB;iClnBkrCJA;2BknB/qCF,iBlnB+qCEA,aknBnrCA7tpB,ElnBmrCA6tpB;0BknB/qCF;mClnB+qCEA;;;;;;;mCknBlrCAxwpB,EtmBxEyB;sBgWNb;;;uBhW+BJ,kB7BqEVy7kB,cAtGAq8C;uB6BiCU;kCZiuCR04B;uBYjuCQ,OZiuCRA;uBYjuCQ,KZiuCRA;uBYjuCQ,QZiuCRA;uBYjuCQ,SZiuCRA;uBYjuCQ,UZiuCRA;uBYjuCQ,WZiuCRA;uBYjuCQ,WZiuCRA;uBYjuCQ,WZiuCRA;uBYjuCQ;iCA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AC;qCACAE;qCACAC;qCACAG,OgDrIkC;+BAF/B1zhB;;6BhDkIP;;iCgDlIOtzK;8BhDkIP,GgDlIOA;8BhDkIP,GgDlIOA;8BhDkIP,KgDlIOA;8BhDkIP,KgDlIOA;8BhDkIP;;8BAxBA,GAwBAyhhB;8BAxBA,GAwBAA;8BAxBA;8BAwBA;;;;iCAxBA;8BAwBA;8BAJA,KAIAumC;8BAJA,KAIAA;8BAJA;;;sCAIAlqH;sCAJA;oCgD9HO7qR;;;8BhDkIP,GgDlIOjzK;8BhDkIP,GgDlIOA;8BhDkIP,GgDlIOA;8BhDkIP,KgDlIOA;8BhDkIP,KgDlIOA;8BhDkIP,uBgDlIOyY,UhDkIP+hI;qDgDlIO/hI,IhDkIP0qC;8BAxBA,GAwBAs+d;8BAxBA,GAwBAA;8BAxBA,qBgD1GOhpgB,IhD0GPysC;qDgD1GOzsC,IhD0GPC;8BAwBA,uBgDlIOD,IhDkIPi6B;8BAJA,KAIAs1gB;8BAJA,KAIAA;8BAJA,uBgD9HOvviB,IhD8HP2sC;qDgD9HO3sC,IhD8HPk8B,WgD5HsC;;4BAF/Bu+H;qCAAKT,YAALS;;;;;;;qCAAKT;qCAALS;;;0CAE+B;sBAGi0B;;sBxyBCn2B36B;sBI4HFwV;sBADAD;sBJ5HExV;sByyBVN;;sBAAS,wBlDcLuoE;sBkDZK,sBlDYLA;sB7QiEgB;uB+T7EX;;0BAMmB,uBDPxB2lf;0BCOwB;mCDPxBA;iDnkByBAh6nB,iBmkBzBAg6nB,kBCO0D;uBANrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;uBAAA;sBAmBL;;;;;;;;;;;;;;;;sB/T0DgB;uB+T1DhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;sBAQD;;sBzyBlBGjujB;sBI4HFwV;sBADAD;sBJ5HExV;sB0yBVN;;sBAY6C;;sB1yBDvCC;sBI4HFwV;sBADAD;sBJ5HExV;sB2yBVN;;sBjU+EoB;uBiU/EpB;;mCAGMklC;4BAAK0phB,QAAQC,QAAQC,YAAYj1pB,MAAM2vf,UAAUpO;4BACnD;;;;;;;;;qCADeyzK;8CAaiB1psB;uCACnB,IAALqC,GAAK,WAd4BgiiB,UAaTrkiB;uCAV9B,eAGaA;yCACK;;0CAAd,iBAP6Ci2hB,QAMpCj2hB;yCACT,6CAAkC;uCADG;uEAOXA;wCAPb,kCANZypsB;;wCAIH;uCAYO,uBAFHpnsB,GACAD,IAMC;uCAfkC;wCAWrC;;;;;;;0DACGw5I;;+FACuB;;wCAF1B;;;;;0DACG+sZ;;+FACuB;;uCAF1B;;;;;;;;;qEACG/uW;;8EAlBc+vgB,YAkBd/vgB,mBACuB;;;gDAnBGllJ;gDAaH10C;gDACxBqC;gDACAD;sDAMG,EAAE;mCAEXwnsB,MAAM9msB,EAAEE,EAAEiC;4BAAI,mCAARnC,EAAEE,EAAEiC,EAA0D;mCAEpE4ksB,MAAM/msB,EAAEE,EAAEiC;4BAKV,kBALUA,GAI8B,cAJhCjC;4BAIgC;;+BAA7Bo2D;;;;;4BADX;4BADG;kFAFGt2D,cAKY;oCA9BlBi9K,KAuBA6phB,MAEAC;uBA5BN;;0BA0M0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAAxB;mCAER90e,UAAU/0N;4BAAY,sCAAZA,GAAyB;0BAF3B,SAIRu1N;4B;8BAEE,IADMh1N,WACH,2BADGA;4BAGN,YAAwC;0BARlC,SAcVgvE,IAAKhsE,EAAGP,GAAI,kBAAJA,EAAHO,EAAU;0BAdL,SAgBVqsH,KAAMh9C,GAAGF,GAAI1vE,GAAI,kBAAJA,EAAP4vE,GAAGF,GAAe;0BAhBd,SAwBN8iJ,YAAUx1N;4BAAY,4CAAZA,GAA+B;0BAxBnC,SA0BN6lO;4B;8BAEE,IADMtlO,WACH,iCADGA;4BAGN,YAAwC;0BA9BpC,iBAwBNi1N,YAEAqQ;0BA1BM,SA6CRhhE,gBAnBc,YAI8B;0BA9BpC,SAcVt1F,IAEAqgD,KA6BEi1C;0BA7CQ,SAkDVtT,QAAQvxJ,GAAI,UAAJA,IAAS;0BAlDP;;;;;;;mCAkEV0piB,cAAYxpiB,EAAEC,EAAEqD;4BAAI,6BAARtD,EAAEC,EAAEqD,EAAqB;0BAlE3B;mCAwEVuhiB,SAAOxhiB;4BAAiC;8DAAjCA,QAA4C;0BAxEzC;;;;sCA0EmBrD,EAAEsD,GAAK,6BAAPtD,EAAEsD,EAAsB;2BA1E3C;;;mCAkFVumsB,iB;0BAlFU;;;;gCAcVx6nB;;6BAoCAgiF;6BApCAhiF;6BAEAqgD;;8BAdEmlG;8BAEAQ;;;;;;;;;;;;;;;;8BAJAoga;;;;;;;;;;;;;;;;;;6BAwDF1sQ;6BAEA8L;6BAEAoqK;6BAEA1nV;6BAEAqyf;6BAEApgK;6BAEA1kb;6BAEAC;6BAEA8/a;6BAlBA9J;6BAoBA0O;6BAEAzkb;6BAEAu8a;6BAEAs5H;6BAEAgvC;2BAnPFrsc;2BAEAtB;2BAEAt3I;2BAEAkua;mCAEArid,MAAM3wE,EAAEzB;4BACV;;;6BAC+B,sBAFrBA;6BAER,eAAe,gBAFTyB;6BACR;sEAEe;mCAEb6yhB,aAAa7yhB,EAAEzB;4BACjB,eAEayB,EAAEzB,GAAK,+BAAPyB,EAAEzB,EAAyB;4BACrB;mDAJFA;6BAEf,eAEG,gBAJUyB;4BAEb,mCAEgC;8BAEhCsrE;;;;;;;;;;8BAGF;6CACmCtrE,EAAEzB;gCAAY,qBAJ/C+sE,OAIiCtrE,EAAEzB;gCAAY,oCAAO;8BADxD,gDACyD;0BAMhD;2BAJP4uE;2BAEAnkC;2BAEO,gBA3BPozN;2BA6BM,eA7BNA;0BA6BM,SAENijZ,WAAWr/oB,EAAEzB;4BACR,2BADMyB,GACS,yBADPzB;;8BAGJ;+BADI2tC;+BAAR2tB;+BACI,iBAlCTuiM,SAkC8B,oBADzBviM,IAAQ3tB;8BACJ;2CAEE89pB;oDAMT,OANSA,QAMD;8BADK,qBArCfh3K,YA2Baz0hB,EAKFyrsB,SALAhqsB;8BAUI;4BAFsB;;0DAzCrC09P,IAiCan/P;6BAQW,6BAzCxBm/P,IAiCW19P;6BAQQ;6BAFf,kCAvCJ09P;4BAuCI,0CAKM;0BAbJ;;;4BAeNq1R;sCAKM7yhB,EAAEkP,IAAM,kBA7Cd4jhB,YA6CM9yhB,IAAEkP,GAAwB;;2BAF9B,iBAHF2jhB,cAEQ9zb;0BAjBF;;;4BAsBN8lB;sCAKM/kH,EAAEzB;+BACG,2BADLyB,GACoB,yBADlBzB;;iCAGO;kCADI2tC;kCAAR2tB;kCACI,iBA3DfuiM,SA2DoC,oBADzBviM,IAAQ3tB;iCACJ;8CAEE1mC;uDAOT,OAPSA,GAON;iCADU,qBA/DrBwthB,YAoDMhzhB,EAAEzB,EAKSiH;iCAMI;+BAFa;;6DAnElCk4P,IA0DQn/P;gCASa,6BAnErBm/P,IA0DM19P;gCASU;gCAHN,kCAhEV09P;+BAgEU,0CAMC;;2BAdT,iBAHF34I,SAEQhmB;;;;;;;;;;8BAkBV;wEApBEgmB,SAqBiC;0BA3C3B;;;4BA6CN9iF;sCAKMjiC;+BACI,2BADJA;+BACI;iCAEF;;kCAAO,iBAlFfo8P,SAkFyB,oBADdviM;iCACI;8CAEEr0D;uDAKT,OALSA,GAKN;iCADU,qBA5CrButhB,cAmCM/yhB,EAKWwF;iCAII;+BAFe;;6DAxFpCk4P,IAiFM19P;gCAO0B;gCADtB,kCAvFV09P;+BAuFU,0CAIC;;2BAZT,iBAHFz7N,OAEQ68D;;;;;;;;;;8BAgBV;wEAlBE78D,OAmBsC;0BAhEhC;;;4BAkENy4nB;sCAKMn3pB;+BACI,2BADJA;+BACI;iCAEF;;kCAAO,iBAvGf64P,SAuGyB,oBADdp8P;iCACI;8CAEEwF;uDAKT,OALSA,GAKN;iCADU,qBAzGrBwthB,YAgGMzvhB,EAKWiC,IA5EjB0E;iCAgFqB;+BAFe;;6DA7GpCwzP,IAsGMn6P;gCAO0B;gCADtB,kCA5GVm6P;+BA4GU,0CAIC;;2BAZT,eAHFg9Z,QAEQ13pB;;;qCA4ENusE;;kCAoCAgiF;kCApCAhiF;kCAEAqgD;;mCAdEmlG;mCAEAQ;;;;;;;;;;;;;;;;mCAJAoga;;;;;;;;;;;;;;;;;;kCAjKJj4X;kCAEAtB;kCA2NE+iS;kCAzNFr6a;kCA6NEgllB;kCA3NF92K;kCAaA1nd;kCAMA6B;kCAEAnkC;kCA4LEiyf;kCA4BA8uK;kCA3OFp5nB;kCAsCAoid;kCAjCAF;kCAwCA9ta;kCAuBA9iF;kCA3CAo9mB;kCAgEAqb;kCApEA7llB;kCAEA3qE;sBA2xBH;;sB3yBx1BG4wI;sBI4HFwV;sBADAD;sBJ5HExV;sB4yBVN;;sBlU+EoB;;;mCkU0Ed4jgB;gCAAoBlgpB,WAAHyB;2CAEVk5B;6CACAC;+CACA2knB;kCACkB;;mCAAV,uBAFR3knB,GACA2knB;mCACO;0DALMv/oB,QAKuB;gCAD/B;;8DAJKyB;gCAIL;8BADA,2BADLk5B,GAFUl5B;8BAGL;4BADA,2BAFKA;4BAEL;0BAQL;;;;2BADP;;;;;8BADOqkiB;;;;;;8BARPo6G;0BASA,SAMAz1mB;gCAAYzqC,WAAHyB,WAAqB,UAArBA,EAAqB,iBAAlBzB;0BANZ,SAQA69P,SAAU74P;4BACD;uDADCA;6BACD;;6BACI,sBADRhF;4BACJ,0BADCyB,SACsB;0BAVxB,SAYA6yhB;4BACW;6BADgBj2b;6BAAJ1jE;6BAAL2jE;6BAAJ5jE;6BACH,gCADGA,GAASC;6BACkB,gCADvB2jE,GAASD;4BACc,sBAC3C,QAAE;;;qDADM++b,eAA8B57X;;0BAbpC,cATA0+e,gBAqBA5rH;0BAZA,SAyDAvvgB,IAAMuhM,IAAI4hD,GAAGuF;4BACf;sCAAoC,IAAP1oP,aAAO,kBAAPA,IADjBmjP,GAAGuF;4BACf,IAlCqCqyY,GAiCtBryY,MAjCkBmyY,GAiClBnyY,MAjCa6xY,GAiChBp3Y,MAjCYq3Y,GAiCZr3Y;;8BAhCZ,eACSpkO;+CACAi8mB;;mDAgBAE;4DAYT,UA5BSF,GAgBAE,GAYD;sCADkC;8DAXjCA,GAnBmBX;uCA8BI,uBA9BRC,GAGfQ;uCA2BI,uBA5BJj8mB;sCA4BI;oCANM;;gFAxBKy7mB;qCAyBT,2CAzBaD;qCA0Bb,2CAvBNS;qCAwBU,2CAzBVj8mB;oCAyBU;sCACQ;;;uCADjBA;uCADAi8mB;uCADAT;uCADIC;uCAIa,0BAJbA,GAEJQ;uCAEO,0BADPj8mB;sCACO,iCAHPw7mB;oCALR;;mEAMQthH,eACAC;wEAFAF;wEADID;;qCAJZ;;kCAHwB;0DAdjBiiH,GAHeR;mCAiBE,6BAjBOK;mCAiB/B,uBAfO97mB;kCAeP;gCATiB;;4EARKy7mB;iCAST,2CATkBK;iCAUd,2CARV97mB;gCAQU;kCACc;;mCADvBA;mCADA87mB;mCADIL;mCAGmB,0BAHnBA,GACJK;mCAEO,0BADP97mB;kCACO;gCAPf;;+DAKQg/H,eACAC;oEAFI06X;;iCAJZ;;8BAF8B;sDAFCmiH,GAATL;+BAEN,iBA+BVj5b,IA/Bc,iBAFew5b,GAATR;8BAEV,0CA6BV;sCplB2mBNvykB;mEolBxmBqE;0BA1DrE,SA+DAg0kB,WAAWnpoB,EAAExU;2CACPC,GACR,qBADQA,EAC8B;4BAD1B,oBADCuU,EAAExU;4BACH;0BAhEV,SAmEAsyL,QAAQ99K,EAAExU;4BAAI;8CAAe3B,EAAEzB;uCAAwB,2BAA1ByB,GAAO,uBAALzB;uCAAK,0CAA2B;qCAAvD4X;qCAAExU,EAA0D;0BAnEpE,SAsEAs5hB,KAAI96hB;4BACM;6BADwBkzP;6BAAJD;6BAAZ3rL;6BAAJm2F;6BACJ,gCADNz9J,EAAUy9J,GAAgBw1F;6BAExB,gCAFFjzP,EAAcsnE,GAAgB4rL;4BAE5B;kCAAJ90P,WADIyB,uBACJzB;;;qDADImjK,eACJC;;0BAxEF,SAwGEjrF;2CAKIl0C;uCAdFm8mB,gBAAgBvuO;gCAAkB,sBAchC5tY,OAdc4tY,QAAwC;uCAExD9sZ,IAAI8sZ,QAAQpwa,GAAI,eAAZowa,QAAQpwa,EAAqB;4CArFrC6yhB;wCAiGMrwf,MAZFlf,IAFAq7nB,gBAzBJ1jH,YAyCc;4BALuB;;;6BAAJ;6BAA/B,kCA5GFv9R;4BA4GE;0BA1GF,SAkHJ5lG;gCAA2B+lf,YAAJC;;8BACrB,eACSC;+CACA17mB;iDAQA87mB;mDAQAE;sCAWC;;uCAGgC;uCAAnB;uCAAlB,uBA/BIN;uCA+BL;uCADU,uBA7BL17mB,OA2BL6+f;uCAEF,sCAhCuB28G;uCAkCW,uBAlCfC,GA8BjB58G;uCAI0B,uBAvBrBi9G;uCAuBA,gCA/BA97mB;uCAgC6B,uBAhB7Bg8mB,GAnBgBR;uCAmCG,uBAnCPC,GAWZK;uCAwBA,gCAhCA97mB;sCAgCA,sBACT,UAzBS87mB,GAQAE,GAiBD;;oEAFJ6rD,eACAC;oEAJIF;gFAKA;oCAZe;;gFArBd5nqB;qCAsBM,2CAzBMy7mB;qCA0BN,2CA1BUD;qCA2BV,2CAhBNM;oCAgBM;sCACc;;;uCADnBA;uCADAN;uCADAC;uCADIz7mB;uCAIe,0BAHnBy7mB,GAEAK;uCACS,0BAJL97mB;sCAIK,iCAFTw7mB;oCANR;;mEAMQysD,eACAC;wEAFAF;wEADID;;qCAJZ;;;iDALmD/nqB,OAAOy7mB;oCAEhC;+DAFgCA;qCAEhD,0BAFyCz7mB;oCAEzC,uCAAyB;kCAFN;qEAfVy7mB;mCAeR,kCAZJz7mB;mCAYD;mCAHN;;;+CALsD07mB,UAAUF;kCAED;6DAFCA;mCAEL;;mCAAhD,0BAF2CE;mCAE3C,gCAF2CA;mCAE5C;yEAA8D;gCAFxC;mEAPTF;iCAOZ,kCALJE;iCAKD;iCAHN;;8BAFmB,2BAFAD;8BAEA,0CAkCb;sCplB4gBNxykB;;0BolBlqBA,SAwJAk/nB,SAGEh6U,KAH6B0qK,KAAOC;4BAC3B;uDADoBD;6BACpB;;6BACA,4BAF2BC;6BAE3B;;qCAETm/G,OAAOnroB,GAAGC;8BACZ,eACsBD,GAAGC;gCACA;;iCAAD,uCAJtBohX;iCAIgB,iCADOphX;iCACrB,iCADkBD,GAHpBqhX;gCAIE,8CAA0D;8BAF9D,uBADSrhX,GAAGC,SAGoD;4BAEnD,iBARPytF,GACAD;4BAOP,iBARG3jE,GACAC,UAOwB;0BAjK1B,SAuNA8mnB,YACQyqD;4B,gBAA4ClnsB,EAElDpD,EADqDgjB;8BAGjD,aAFJhjB,GAEI,aAAJ0C;8BAAI,SAsDA8wN,GAAG/qL,IAAI8gf,aAAa5lf;gCAC1B,GAD0BA;oDAtFZ+njB,GAsFY/njB;;oCAUI;qCADPkjC;qCA/FLt2D;qCAgGY,wCAVjBg5gB;qCAUiB;+CACjBnjS;uDAGA39M;0CACF;mDADEA,IACF,oBA1Cc+hqB,qBAoCF3joB,KAM2B;wCAD/B,qBAxEXyjoB,WA0DC7hqB,IAWI29M;wCAGM;qCApCR,0BApCyChjP,EA0DvCmmhB;qCAtBF,6BALcihL;qCAId,uBAnCyCpnsB,EA+B3BonsB;qCAGd,uBAlCyCpnsB,EA0DvCmmhB;;+CArFP81H;wCACR,SAAIC;8CAAwBnyH,YAAJC,YAAJn+gB,YAAJD;mDAEVm8D,OAAMtrE,EAAEG;4CAAI,eAAiBH,GAAK,kCAA1BG,EAAqBH,EAAwB;4CAAzC,uBAANA,QAAgD;0CAKrD;2CAJDmtE;2CAIC,0BAPqBmgd,GAAZn+gB;2CAOT,gCAPaC;2CAOf,aAAC,0BAPkBm+gB,IADhBiyH;2CAOH,aAAC,oBANkBjyH,GAARp+gB,IAFIuB;2CAOf,aAAC,oBALctB,GAAJD,IAFA08kB;0CAMd;mDADI1+gB;mDACJ;qDADIA;qDACJ,WADIA,SACJ,gBAJch+D;;;wCASH;mEAiByC5L;yCAjBzC;;yCACA,4BAZgBmvE;yCAYhB;;yCACA,4BAboBs0J;yCAapB;;yCACA,4BAdwBC;yCAcxB;;yCACiB,sCADtB6+Z;wCACP,0CADG1pjB,WACsD;qCAdtC,4BADJyvgB,GAAIn7kB;qCACA;;kCA2FyB;4DAhESnN,EA0DvCmmhB;mCAnEX+1H;;sCAG4B;uCAHZrwoB;uCAAJD;uCAGgB,iCAtBhB08kB;uCAsBI,0BAHAz8kB,GAAJD;uCAGZ;uCADF,sBAFcA;sCAEd;mCAGW,0BAIyC5L;mCAJzC;;mCAAoC,4BANNguD;mCAMM;;mCAC3B,0BADsBqrC;mCAC3C,4BADuC1jE;oDAI9BuxqB,WA0DC7hqB,IAKD29M;gCAFJ,8BAHK39M,IAeyC;8BArE5C,eAuECgiqB;gCAE0B;4DAxE/BF;iCAwEU,0BA7EwCnnsB;iCA6EpD;iCAE4B,eAH1Bu8oB;gCAG0B,kBA/EpB2qD,WA2EDG,wBAIuC;8BAJnB,aA1E4BznrB,KADH5f,EAElDpD;8BAyEyB,0CAImB;0BAvS9C,SA8SA2kH,MAAMrvG,EA1I6ClS,EAGjDC,EAFsD2f;4BAsI9C;6BAFM5kB,EArImCgF;6BAqItCvD,EArIsCuD;6BAuIzC,gCAFGvD;6BAEqB,gCAFlBzB;4BAEkB;kCAAJA,WAAxByB;8DAAwBzB;;;4DAAxBsssB,eAAwBC;;;8BAM5B,IADG9nlB;8BACH,8BAHIvtG,GAEDutG,IAzIHx/G,EAFsD2f;;uCAIlDwwM,GAAG51N,EAAE6gpB,IAAIh2mB,IAAIkslB;gCACnB,GADW8pB;kCAMM;mCAFV1/Z,GAJI0/Z;mCAITz+oB,EAJSy+oB;;;qDAOQG;wCACT,kBA6HJtpoB,KAjIJtV,EAGiB4+oB,OAPJn2mB,IAS0C;sCAF7B,qBA8HtBnzB,KArISmzB,IAAIkslB;sCAOS;mCADX,gCANR/2nB;mCAMH;mCAIQ,wBAVK+2nB;mCAUL;;0CAANA,YALKlslB;6CALP+qL,GAAG51N,UAIFmhP,GACMt2M,IAKLkslB;gEALKi2E,eAKLC;;gCAPJ,8BAHWpiqB,IAWW;qCAXpB+qL,KAFJnwN,EAFsD2f,KADL5f,EAkBxC;sCplB4eX+nE;mEolB/WmB;0BAnTnB,SAqTA5qC,IAA2B+pqB;4B,gBAA2C34nB,GACrE3uD;8BACH,SACQwwM,GAAG/qL;gC;kCAIW;mCADbqkF;mCAAL1pH;kDACWqlC,KACT,UADSA,IADNqkF,GAEO;mCADM,iBAPOw9kB,WAGlB7hqB,IAGPrlC;kCACkB;gCAFhB,8BAFKqlC;8BADX,UADGzlB,KADqE2uD,GAU9D;0BA/TR;kCAFA4rL;qCA0GEhnL;kCAlGF1tC;kCAEAozN;kCAuDAkjZ;kCAOArkH;kCA4CJnjY;kCAsCI0yiB;kCAsJA1llB;kCAvFAk7hB;kCA8FAt/mB;;sBAWH;;sB5yBvdGo6G;sBI4HFwV;sBADAD;sBJ5HExV;sB6yBVN;;sBA+BG;;sB7yBpBGC;sBI4HFwV;sBADAD;sBJ5HExV;sB8yBVN;;sBpU+EoB;uBoU1EdowjB;iCAAI1hmB,GAAIvmG;yCACFpB,GAKR,aALQA,EAKE;0BAJR;;;8BAFI2nG;;uCAEiChmG,EAAEk/G;+CAC3BpiH,GACR,UADQA,EADyBkD,EAE3B;gCADM,qBAHRP,EAE+By/G;gCACvB;0BADhB;sBAKH;;sB9yBDGq4B;sBI4HFwV;sBADAD;sBJ5HExV;sB+yBVN;;sBrU+EoB,a/doFpByvC;sBoyB7JI;;;sBrUyEgB;uBqU/DhB4ghB;iCAAKlrsB;8BAAO8xE,YAAHjY,uBAAJ75D,KAAI65D,IAAGiY;sBAqDmD;;sB/yB1D7DgpE;sBI4HFwV;sB4yBrIJ;sBAoHG;sBvGpHH;sB/N6EoB;uB+N7EpB;;iCA2CY/sJ,EAAExF;0BAAW,iCAAbwF,EAAExF;0BAAU;qFAAwB;uBA3ChD;iCA6CYwF,EAAExF,EAAEoC;0BAAI,GAAJA;4BAAoB,sCAAtBpC;4BAAsB,6BAAxBwF;0BAAgD;;gDAAO,4BAArDxF;0BAA8C,6BAAhDwF,QAAkE;uBA7C9E,YAuCQ4nsB,UAIAC,cAEAC;uBA7CR;;iCAwDY9nsB,EAAExF;0BAAW,+BAAbwF,EAAExF;0BAAU;mFAAwB;uBAxDhD;iCA0DYwF,EAAExF,EAAEoC;0BAAI,GAAJA;4BAAoB,oCAAtBpC;4BAAsB,2BAAxBwF;0BAAgD,8BAAO,0BAArDxF;0BAA8C,2BAAhDwF,QAAkE;uBA1D9E,YAoDQ+nsB,UAIAC,cAEAC;uBA1DR;;mCAgEQn7nB,KAAK9sE;4BACP;6CAEiBqlC,IADD5lC;0CACC2sD,UAAI5xD;sCACb;wCAAG,mBADUA,QACQ,OADZ4xD;wCACqB;6CADjB5xD;yCACoB,iBAFzBiF,EACC2sD,MAC+B,gBAJzCpsD,EAGcxF;yCAAJ4xD;yCAAI5xD;iDAGN,EACd;mCAECsuE,KAAK9oE,EAAGP;4BACV;;;8BACE;2CAFQA,EAEN,gBAFGO,EACPxF;gCACE,UADFA;;;oCAEI;mCAEFg9hB,QAAQx3hB;4BAA0B,0BAA1BA,GAA0B,yBAAS;mCAE3Cq5hB,QAAQ6uK;4BACV,eAAuC1tsB,EAAEwF,EAAE6rH,MAAQ,uBAAV7rH,EAAFxF,EAAIqxH,KAAsB;4BAAjE,aADUq8kB,iBACwD;8BAEhEz/J;oCAnBA37d,KAmBA27d,aAVA3/d,KAKA0ud,QAEA6B;uBAhFR;;;;0B,IAoIMoP;mCAxBA37d,KAAK9sE;4BACP;6CAGiBqlC,IAFD5lC;sCACF,2BAHPO,GAIUosD,UAAI5xD;sCACb;wCAAG,mBADUA,EAoBnBiuiB,cAnB6B,OADdr8e;wCAEJ;6CAFQ5xD;yCAEL,iBAJAiF,EAEC2sD,MAEM,qBAHb9sD,EACW9E;yCAAJ4xD;yCAAI5xD;iDAIN,EACd;mCAECsuE,KAAK9oE,EAAGP;4BACF;oDADDO;6BACC,MAYNyoiB;6BAZM;;kCACRjuiB;8BACE;2CAHQiF,EAGN,qBAFAH,EACJ9E;gCACE,UADFA;;;oCAEI;mCAEFg9hB,QAAQx3hB;4BACF;oDADEA;6BACF,IAMNyoiB;6BALSpjgB;6BAAI7qC;4BACb;8BAAG,mBADUA,KACC,OADL6qC;8BACc;mCADV7qC;+BACc,8BAFzB8E,EACW9E,GAAJ6qC;;+BAAI7qC;uCAGO;oCAtBpBsyE,KAwBA27d,aAbA3/d,KAMA0ud;uBA7HN;;;;;;;0BAsLoB;4BAsDH;;;;uCApCQx3hB;oCACCmmhB,yBAAa3rhB,IAAE6qC;gCACxB;kCAAG,mBADmB7qC,SACD,OADG6qC;kCAIjB;;qDALCrlC,EACcxF;sCAIA,uBAJb2rhB,aAAe9gf;;mCAMtB,IANoB7qC;mCAMjB;2DANI2rhB;;mCAAa3rhB;mCAAE6qC,IAGlB+mB;2CAKiB;6BAZ9B+tM;;;;;yCAacn6P;kCACD,4BADCA,GAvBPqlC,UAAI7qC;kCACb;oCAAG,mBADUA,SACQ,OADZ6qC;oCACqB;yCADjB7qC;qCACoB,uBADxB6qC,IAAI7qC,EAyBY,sBADd8E,EAxBE9E;qCAAJ6qC;qCAAI7qC;6CAyBgC;uCAf3C2/P;6BAuBFguc;uCAAU9+lB;gCACZ;yCADYA;;kDACwB7uG,EAAE6qC,IAAIzoC;2CACnC,uBAD6BpC;oDACX,iBADa6qC,IAAF7qC,EAAMoC;oDAAJyoC,GACS,EAAE;;6BAI/C+iqB,2B;6BAUS;uCAnBGppsB;gCACd;;kDAAoBxE;2CAAQ,uBAARA,SAA0B,iBADhCwE,EACMxE,IAA8C;6BAiB9D;6BADF,wCAdA2tsB;6BAcA;6BAMgB;uCArOlBxsd;gCACmB,IAAnBvhP,gBAAmB,OADnBuhP;gCAEG,mBADHvhP;iCAEC;0CAHDuhP,GAGC,OAFDvhP,wBAEgC,YAAO;;6BAkOrB;uCAEEuhP;gCAClB,iCADkBA;;;;;;;;yCDpMFtuK;yCAANz3C;;;+CAAMy3C;;sCADhB;oCAFA;kCAFA,kBC0MqE;6BAHrD;uCAKDruE;gCACf;;kDAA2BxE;2CAA0B,2BADtCwE,EACYxE;2CAA0B,oCAAW,EAAC;6BANjD;;+BAPdkrX;+BAiGA6jK;+BA1FA8+K;+BAEAC;+BAGAzsK;;6BALc;uCAWLp/hB,GAAI,iCAAJA,QAAkD;6BAX7C,oCAWD,YAA8C;6BAX7C,sBAiBFA,GAAqC,OAArCA,CAAsC;6BAjBpC;uCAmBJA,EAAEzB;gCAC6C,2BAD7CA,GACgC,uBADlCyB;gCACkC,oDAAyB;6BApBvD;uCAsBYk/O,GAAI/+O;;kCAE1B;gEAFsB++O;mCAGrB,8BADL38O,EAF8BpC;kCAGzB,iCAAL+6E,UACoC;0CjfwjBxC5P;;6BifllBkB;uCA4BS4zK;;kCAEnB;gEAFmBA;mCAGF;mCAAhB,8BADL38O;kCACK,iCAAL24E,UACoC;0CjfkjBxC5P;;6BifllBkB;uCAkCMyF,IAAmBluE;;kCACV,2BADUA,GACvB,uBADIkuE;kCACJ,6CAA0B;0Cjf+iB9CzF;;6BifllBkB;uCAqCayF,IAAmBluE;;kCACV,2BADUA,GACvB,uBADIkuE;kCACJ,iDAA0B;0Cjf4iBrDzF;;6BifllBkB;uCAwCXklT,KAAsB0qK,KAAwBC;gCAGnD;;;oCAH2BD;oCAAwBC;6CAGrBD,KAAMC;sCAChC,6BAJC3qK,KAGyB0qK,KAAMC,OACF;gCADlC;kCAIE,IADChihB;kCACD,iCADCA;gCAGD,sBAAsD;4BAjDxC;;;;oCAdhBwyrB;oCA+BAK;;oCANAF;oCAQAG;oCASJE;oCANAD;oCAeAG;oCAHAD;oCAvBIN;oCAIAC;oCAyBA9wK;;sBAmIL;sBzsBnZGpgZ;sBizBVN;sBvU+EoB;;;mCuUzEdyxjB,SAAS96nB;4BACJ,mBAAC,OADGA;;;;sCAKF0tK,cAAL/+O;;oCACY;;;;;6CADP++O;;kCACsC,oCADtCA;;gCADH;0DAIG;mCAEPqtd,mBAAoBvssB,EAAkBzB;4BAStC;;6BAFkC;6BAAvB,iCAP2BA;4BAO3B,mCAPSyB,QASW;mCAGzB2zN,GAAGmZ,KAAM8xa;4BACf,GADeA;8BAKG;+BADX1/Z,GAJQ0/Z;+BAIbz+oB,EAJay+oB;qDAMX,UAFFz+oB,EAAK++O,GAEI;+BADO,yBADhB/+O,EAJO2sO;8BAKS;4BAFd,gCAGO;mCAPX0/d;4BASF,cAAgCttd,YAAL/+O,kBARnBwzN,GAQmBxzN,EAAK++O;4BAAjB,gCAA8B;mCAE3Cutd,QAAQzssB,EAAG6C;4BAAI,wBAAP7C,MAAG6C,aAAwB;mCAEnC6psB,WAAW3hqB,KAAKm0M;4BAAiB,mBAAtBn0M,KAAKm0M;4BAAiB,mCAAyC;mCAE1Eytd,YAAa/tD;4BACP,IAAJ/7oB,EAAI,OADO+7oB;4BAER,mBADH/7oB;8BAEJ;;+BASG;;;qCAZY+7oB;;;kCAOP;mCAHC1/Z;mCAAL/+O;mCAGI;;mCADmB,iCAFvBA;mCAEI;;;yCAFC++O;;gCAMH;0DAEgE;;mCAKpE0td,OAAQC,aAAahqsB;2CACdq8O;8BAaL;+DAbKA;+BAYP,mDAbqBr8O;+BAiBd,iCAhBAq8O;8BAgBA,sBACT,OAjBSA,EAiBP;;;uDANMy8S,eAKJ57X;;4BAdA,gCAHM8siB;4BAGN,eAI6BhqsB;8BACrB;uCARFgqsB;gDAQiC9usB;yCAEW;sEAHrB8E;0CAGG,6BAFO9E;0CAEjB;yCAAR;6FAAqD,EAAE;4BAH7D;0DAPW8E;6BAOf;6BAHK;6BAFX;;mCAkBAiqsB,4BAA4B5td,GAAGnvK;4BACd,IAAf88nB,aAAe,OADW3td;4BAEvB,mBADH2td;8BAEY;;yCAAP9hqB;iDACAgiqB;oCACT;sCACoD,sBANtB7td,IAMC,kBAFtB6td;sCAEsB,iDAAqC;oCADpE,uCACsE;kCAFpD,qBADThiqB,KAHqBm0M;kCAIZ;+BADF,aAFZ2td,aAD6B98nB;8BAGjB;0DAGsD;8BAG3DnnC;0BACX,SAFEylC,aACa4C;gCAAJthB,UAAI9sD;4BAAI;8BAAG,mBAAPA,KAAkB,OAAtB8sD;8BAA+B,QAA3B9sD,YAA2B,UAA/B8sD,sBAAI9sD;;0BAGe;;;mCAK5BoqsB,+BAA+BpzoB;4BAI3B,cAAU,uBAJiBA;4BvgB2MjC;;gCugBtMqB;6CvgB2MH;gCugB3MG;;;;+BAGf;;gCAPF0xD,uBAMK2hlB;;mCANL3hlB;8BAWJ,OAXIA,SAWI;0BAjBsB,SAoB5B4hlB,8BAECC;2CACM5nsB;oDAUT,OAVSA,GAUN;8BADU,sCAVV4nsB,WACM5nsB;8BASI;;2CAFKxF;8BAAkB,yCAAlBA;8BAAkB,oCAAkC;4BADlD;8DAPjBotsB;6BAOO;6BADF;6BAHK;6BADX;;0BAxB4B,SAmC5BC,qBAAsB7uiB,WAAYx+J;4BAEpC,oCAFoCA,EAAZw+J;4BAExB;uDAjBE2uiB,8BAiByE;;;;;;;;;;8BAIhE;;;;;;;;;;kCAQP,IAHyBtqsB;kCAGzB,SACIuiG;oCANJ,iBAEyBviG,kBAFK,cAAc;wEAMK;sCAoBjD9E;kCACE;oCAnBQ;;qCACA;;;wCASC;yCANYu/hB;yCAAND;yCAMN,yCANYC;yCAKT,yCALGD;wCAKH,0CpyB3IhB1nW;qCoyBwIa,gCALLp3L;qCAIqC,gCALrCyB;qCAKG,iCAXgB6C;;qCASrB;;;qCAWmC,4BAbjCtE;qCAaoB,4BAdpByB;qCAcY;oCACT,GAbHq9hB,SAaoB,gBADpBz7hB;sCAEG,GAdG07hB,kBAcuB,gBAF7B17hB;kDAIN7D;;wCAxB6B;;mEA0BzB;;;;;;;;;;kCAQM;;mCADA;mCADA;mCADL;kCAFL,OACE;kCAIQ,UAIC;kCAFJ,YAEH;gEAA2D;;;;;;;;;;kCAG/D,SAAIuvsB,WAAWpud;oCACP,4BAAmB,OADZA;oCACP,iCAAyD;kCAEjE,OAAgB;kCAChB,OAAgB;kCACT,YAAmB;gEAAyC;;;;;;;;;;kCAGnE,IAuBAr8O,IAvBA;kCAwBE;oCAtBA;;+CAqBFA;iDArBMU;0CACuC,iCAoB7CV;0CApByB,cAHrBgqsB,aAGqB,iCAAqC;+CADxDtpsB;qCAAJ,MAqBFV;qCArBE;+CAAIU;iDAGAiqsB,YAAaC;0CACf;4CAAS;mDAAa7+K;qDAGd,WAHuBmtK,WADhB0R;6DAMI;0CALnB,2BAJElqsB,QASiB;+CANjBiqsB;qCAHJ,0BAAIjqsB;qCAWU,cAUhBV;qCAVgB;+CACFX;wCACV;iDAfA2qsB;0DAe+B9usB,GAAK,wBAD1BmE,MACqBnE,aAAyB,EAAC;qCAE9C,YAjBX8usB;qCAaY;oCAID;0CAAb9usB;sCACE;wCAAG,mBADLA,EAJI2vsB;0CAMuB,sBAAa,QAFxC3vsB;0CAEI,OAAgB;;0CACoB,sBAAa,QAHrDA;0CAGc,cAAmB;;kDAHjCA;;;oCAfA,UAqBF8E;;oCA9BE,SAgCE;;;;;;;;;;kCAGG,mBAAC;oCACD,mBAAC;sCACD,mBAAC;;;gEAAoB;;;;;;;;;;kCAG5B,SAAIG,EAAEd,EAAEg9O;oCACC;;;wCAAC,+BAA+B,uBADjCA;wCAAFh9O;;kEAC0D;kCAEhE;kCACA;kCACA;mDACsC;;;kCA3NxCoqsB;kCAUAC;kCAWAC;kCAWAC;kCAEAC;kCAEAC;;kCAiBAC;kCAoBAE;kCAQAz+nB;kCAIA2+nB;;kCAKAC;kCAeAE;kCAeAE;sBA8HH;sBjzBjPGvyjB;sBADAD;sBkzBVN;sBA4BG;sBlzBjBGC;sBADAD;sBiJVN;sByV+EoB;uBzV/EpB,8BAegB,4BAoBX;uBAnCL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAiDe,IAAT71C,OAAS;yCAEqCzhG;4BAE5C;;;;;;oCAIgB;qEAN4BA;qCAItC;;;;;;;;;;;;;;;;;;;;;;2C8lBnBR6iiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC9lBaAphc;;qCAMQ;;;sCAIiC,kCAL5BzmG;sCAKgB,kCALnByB,SAK0C;6BAIlD;;;;;;;;;;;;;;;;gCAdFglG;gCAE8CzhG;6BAY5C,EAQSmvE;6BART,EAQSA;6BADI,4BARNn0E;6BAQM;6BAFT,yCANAyB;6BAKD,6BALCA;6BAKF,mCALEA;6BAKF;;6BAFOk5O;6BAEP;;6BAFO7jM;;uEAAa;;8BAAbmf;gCAMAgwK;;;;;;;;;;;;;;;6CAAgB,sBAAhBzhF,cAA6B;;qCAA7BxuF;;;;;;;wCAAoD;0BAtBtD,0DAsBwD;sByVQnD;;;0BzVaX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BADH;2BADF,2CwjBkPMu4d;0BxjBlPN,eAUU9shB;4BAAiC,uCAAjCA;4BAAiC,0CAAqB;0BAHhE;2BADE6/K;4BACF;8BACE;gClDGa6pW,akDFK,2BlDELA;;0BkDJf,SAKEwrG,SAASl1nB,EAAEjC;4BAAgC,sCAAlCiC;4BAAkC,yCAAhCjC,EAA+C;0BAL5D,SAQI4yE,MAAMzwE,EAAEC,G,8BAAFD,EAAEC,EAGuB;0BAXnC,SAaI46hB,e;0BAbJ,SAgBMv2T,QACCtkO,EAAEC,G,iCAAFD,EAAEC,EAG4B;0BApBrC;qCAgBMqkO;2BAhBN,WAQI7zJ,MAKAoqd;2BAbJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAREr9R;6BAOA79E;6BAMAq1c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCpC6EAv5C,cAOAC;uBoC3CI+xH;iCAAS9rlB;0BAAT,SAASA;;;;;;;;;;;0DAATptD,YAASotD,KAAmC;uBAA5C+rlB;;;;;2BAASj8oB;;wDAAmC;gCAA5Cg8oB;uC;sByVhEU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;;;;;;yB7XNLvomB;yBA0GTu2e;yBAOAC;yBAjHSm8C;yBA8HTE;yBA9HSjvlB;;;;0B;;;;;sB6XMK;uByUoDhB6kqB;;;;;;;uB1nBtGIE;;uBADFE;;uBACEE;uBkB8VEC;;;;;;;uBOg4BAC;;;;;;;;uBAhGAC;;;;;;;;;;;;;;;;;;;uBZyNJC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uC;sBoSryCc;uBzV8GW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCpCVzBn2E,gBAOAC;uBoCGyB;iCAWZx2gB;0BAAT,SAASA;;;;;;;;iDwC3KXkslB,cxC2KWprsB;iDwC3KXorsB,cxC2KW30oB;;0DAAT1E,YAASmtD,KAAmC;uBAXvB;;0BAWrB;;;2BAASlwD,gBwC3KXq8oB,cxC2KWrrsB;2CwC3KXqrsB,cxC2KW50oB;wDAAmC;uBAXvB,SAWrBo1oB;uBAXqB;wC;uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wC;;uBAAA;;;kCA+BV/nc,GAAGuF;2BACN;;oDACI,2BAFDvF,GAAGuF,GAEyC,EAAE;uBAjCpC,SA6Bf0ic;uBA7Be;;yBpCpHhBriK;yBA0GT+rF;yBAOAC;yBAjHSH;yBA8HTI;yBA9HSvzF;;uBoCoHgB;;;2B;;;uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sByV9GX;uBzV8GW;;;;;;;;;;;;;;;;;;;;yB8lBzJzBqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uB9lByJyB;iCA8CZ5iiB,GAAI,+BAAJA,EAAsB;sBA2BtC;sBjJ3PGs3I;sBozBXN;sBAKyC;sBlqBLzC;sBwV+EoB;uBxV/EpB;;;;;;;;;;;;;uBASa;;iCAEI91C,OAASzkG;0BAChB,IAAJgC,EAAI;0BACR;4BAFwBhC;4C,mCACpBgC;0BAEJ,oCALE4ssB,SAGE5ssB;0BAGO;mCAJahC;mD,0BACpBgC,UAGkE;;;;;;;;;;0BAGtE,eAMUhC;4BACN,SAAIk8D,WAAO,eADLl8D,EACoB;4BAGxB;+C6lBgaFm4nB,c7lBhawB;6BADkB;6BAAxC,mC6lBiaFA;6B7lBjaE;;6BADSrjlB;;sD,OsEoLX2rE;qCtEpLWiS;8BAAU;gDAAV+jD;yFAAS;uCAAThB;6CAAe;;qCAAfrhH,qDAEoB;0BALnB;;;;;;;;;;yCAKqB;;sBC5BvC;sBuV+EoB;uBvV/EpB;iCAkBkB9xC,MAAM9kB,EAAEiC;0BAAwB;kDAAhC6iB,MAAM9kB;2BAA0B,0CAAxBiC;0BAAW,iBAAnB6iB,MAAM9kB;0BAAa,QAA2B;uBAlBhE;uCAoB2CwE;8BAAX2vpB,mBAAR/gP;mCAChBghP,KAAK39X;4BACP;4BAAiB;gDADVA,IAD8BjyR,4BAEgC;0BAE7D,IAANiD,IAAM,KAJU2ra,OAChBghP;0BAGM,kBAAN3spB,IAJwB0spB;uBApBhC;iCA2BWhypB,GAAI,YAAJA,kBAAI,YAAoB;uBA3BnC,gBAkBMmvsB,aAEAp9C,iBAOAq9C;uBA3BN;iCAiCezxsB,OAAOmC;0BAClB,GADWnC;4BAKP,IADG22H,SAJI32H;4BAKG,0CALImC,GAIXw0H;0BADH,qCAHcx0H,EAKmB;uBAtCzC;iEDWIovsB;uBCXJ;;;;;iCA2CYvsrB;0BAAQ,wB4lBiZd61mB,c5lBjZM71mB,MAA4B;uBA3CxC;iCA6CUM,MAAO,wBAAPA,K4lB+YJu1mB,c5lB/Y4B;uBAIhC;;;;mCAAyCznjB;gCAD5BroC,uBAAI/lC,EACwBouE;4BADpB;8BAAG,mBAAPpuE,KAAkB,OAAtB+lC;8BAA+B;mCAA3B/lC;+BAAuC,oCAA3C+lC;;+BAAI/lC;uCAC6C;uBAA9D;iCAUgB0pC;0B,GAAAA;2BAAS,QAATA,cAASypC;;+BAATn4E;0BACF;oFADEA;uBAVhB;;;;;;;;;uBAgBa,gB4lB2XT66nB;uB5lB3XS;iCAMHv1mB,KAAK2uD;0BACb;0BAAW;;;qCqJwRakjD,OrJzRhB7xG,qB;mCANNysrB;mCAMW99nB,GACoD;uBAPtD;uBAWH,sB,O8CmGF09C,gB9ChINkglB;uBA4BA;;;;;;;;;;uBAiBa;;;0BA7CbA;uBA6Ca;iCAEInvsB;0BAEZ;;uCADP,sBADmBA;4BAGU,qBAAQ,YAHlBA;4BAGU;wDAAoC;;;;;;;;;;0BAKxD;;2BACA;2BACA;2BACA;2BACI,2CAJT04B,GACAC,GACAC,GACAijD;2BAGF;;uCAAc,wCANZnjD,GACAC;iCACAC,GACAijD;2BAGF;;2BAES/mC;;oD,OqEgGP2rE;mCrEhGOiS;4BAAQ;8CAAR+jD;uFAAO;qCAAPhB;2CAAa;;mCAAbphH,qDAA0B;;;;;;;;;;0BAK7B;;2BACA;oCADJ50D,EACAzB;0BAAI;4BAKN;4BAAoB,gCAAdyB,EAAGzB,GAAsB;0BALzB;4BAIN;;kEAAuC,oBAAjCyB,EAAGzB,GAAqD,EAAE;0BAJ1D;;2BAEC;;;;;;;;;;;yCAID;sBuV3CU;uBvVkDD,gB1C7Gb81kB;uB0C6Ga;;;;;iCAiBEr0kB;0BAGL;6DAHKA;2BAKL,oCAFNwF;0BAEM,qCAANmvE,MALW30E,EAOR;uBAxBM;;;;;6BAcXo/W;6BAGAixV;;6BAdAH;6BAEAC;6BAEAC;uBAPW;;;;;iCA+BPjtrB,MAAO,wBAAPA,KAhCN8srB,SAgC8B;uBA/BjB;iCAmCP1vsB;0BAA6C,6BAA7CA;4CAFU,iBAlChB0vsB,sBAoCuE;uBAnC1D;;uBAsCf;wC,O3BtDEnxE;uB2BsDF;;uBAME;;iCAaiB9+nB;0BAGL;0DAHKA;2BAKL,iCAFNwF;0BAEM,kCAANmvE,MALW30E,EAOR;uBAKI;;iCAEK6iB,MAAM9kB,EAAEiC;0BAAuB;kDAA/B6iB,MAAM9kB;2BAAmB,iBAFrC2ysB,OAE0C,iCAAtB1wsB;0BAAI,iBAAZ6iB,MAAM9kB;0BAAM,QAAiC;uBAFlD;uCAI8BwE;8BAAX2vpB,mBAAR/gP;mCAChBghP,KAAK39X;4BACP;4BAAiB,+BADVA,IAD8BjyR,yBAEoB;0BAEjD,IAANiD,IAAM,KAJU2ra,OAChBghP;0BAGM;mCAAN3spB;mCAJwB0spB;4CAKSlypB,EAAEwD;qCAAU,kBAT/CktsB,OAS+C,2BAAZ1wsB,EAAEwD,GAAiB;uBAT/C;iCAWFtD,GAAI,YAAJA,kBAAI,YAAoB;uBAXtB;;;;;6BAfTq6rB;6BAGAkW;gCAcEE,aAEAC,mBAOAC;6BA7EJX;6BAEAC;6BAEAC;uBA8DW;uBAiBF,gBAvFXH;sBAgGH;sBuVjJiB;uBvViJjB;;;;;;;;;;;;;;;;;;;yBCjNAp7oB;;;;;;;;yBAyBCk8oB;;yBAODj8oB;;yBAIAC;yBAEAC;yBAEAC;yBAEAC;;;yBAMAC;;;;;yBAkBAC;;;uBD+IA;;;;;;;;;;;;;;;;uBmqBhOC67oB;uBASEC;uBAJJC;iCAMW5wsB;0BACT,IAAI61M,cAAJ,sBADS71M;0BACT,GAAI61M;2BAGA;sCAHAA;4BACAx0M;6BAGA,OALKrB,EAKD,OADA+4E,qBAC2B,OAPjC43nB,YAO6C;;+BAH3CtvsB,EAIG,QANErB,IAXT0wsB;0BAiBqC,yBAJjCrvsB,UAOJ,OAPIA;wDAOH;uBAKgB;uBAEK;uBAEZ;uBAEO;uBAED;uBAEA;uBAEK;uBAEA;uBAeP;uBAED;uBAEa;uBAEN;uBAEA;;iCAEJswsB;0BAAoB,wBAApBA,kBAA8C;uBAEjC;uBAGP;uBAET;uBAEC;uBAED;uBAEI;uBAEG;uBAEE;uBAGM;uBAEX;uBAEN;uBAEO;sBAEE;sB5UbJ;uB4UeK;uBAGQ;uBAEO;uBAGE;uBAEhB;uBAEA;uBAEO;uBAEK;uBAEtB;uBAEE;uBAEC;uBAEC;uBAEH;uBAEA;uBAEK;uBC5HV;sBAqIF;sB7UtDU;uB6UwDK,iBAAd//qB,KAAO,MAAMA,GAAvB;uBCrEgB,GAAjB33B;uBAqC8B,YAA9B8B;uBAA8B,qBA+EZ0D,GATG,OASHA,MA/EZmkH,iBA+EYnkH,EAA6C;uBA0O3Dg0sB;;sBA0WF;;0BAA0B;4BACF,IAAL1hsB;sCAxF+B,wBAwF/BA;0BACR,QAAK;sBAGhB;iCACQA;0BACD,OADCA,aAhXN0hsB;;sCAiX8E,wBADxE1hsB,cACyE;sB9UlsB/D;uB8UgsBlB;iCAOSgvF,MAAMthG;0BAAc,IAHhB4+P,QAGgB,wBAApBt9J;0BAFsC,OAAjD4ymB,aADet1c,WAGE5+P,CAA8B;uBC/wB3Cm0sB;iCAAQzrrB,MAAwBrM;0BAE7B,OAFKqM,UDgGNy7F;;mCChGMz7F,MAGc,wBAHUrM,KAGG;uBAEnC+3rB;iCAAOtvsB,KAAK0jC;0BACd;0EADS1jC,MAAK0jC,QAC6C;uBAEzD6rqB;iCAAMr0sB;0BACR;kDADQA;2BACR;;;yD,OxnB+JQwvH,8BwnB/J+D;uBAErE8klB;iCAAK/zsB;0BACD,yBADCA;0BACD,UAEF,IADGsiB,eACH,aADGA;0BADD,atqBgF+C,gBsqBjF9CtiB;0BtqBiF2C,kDsqB5E1B;sBCvB1B;sBhV+EoB;uBgV/EpB,gBAGUA,GAAuB,cAAvBA,EAA4D;uBAHtE;iCAKiBA;0BDqBT,yBCrBSA;0BDqBT,UAEF,IADGsiB,eACH,aADGA;0BAGH,cCzBWtiB,EAC6B;uBAEX;oCJ0D/B4xsB;uBIxD8B;+BJwD9BA;sBItDsB,OJyDtBC;sBIvDW,OJ0EXS;sBIxEoB,OJ+DpBJ;sBI7DsB,OJ+DtBC;sBI7D4B,OJgE5BC;sB5ULgB,qBgVzDC,OJgEjBC;sBI9DkB,OJkElBE;sBIhEc,OJ4BdlB;sBI1Ba,OJ4BbC;sB5UuBgB,qBgVjDC,OJLjBT;sBIOsB,OJLtBC;sB5UoDgB;uBgV/CM;;iCAMpBtzsB;0BACQ,IAANyC,IAFF08b;0BAGC,mBAFDn/b,EACEyC;4BAIE;;;iCALJzC,aACEyC;yCAIoCzC;kCAAK,IARzC4tE,IAQoC5tE,IAJpCyC;yCApCJ+zsB,OJ+CuB,oCIfnB5ooB,MAQoD;4BADpD,qBALFuxX;0BAOF,wBAPEA,UACAn/b,SAMS;uBAZW;;iCAiBpBA;0BACQ,IAANyC,IAFFi0sB;0BAGC,mBAFD12sB,EACEyC;4BAIE;;;iCALJzC,aACEyC;yCAIoCzC;kCAAK,IAPzC4tE,IAOoC5tE,IAJpCyC;yCA/CJ+zsB,OJiDgC,oCIL5B5ooB,MAOoD;4BADpD,uBALF8ooB;0BAOF,wBAPEA,YACA12sB,SAMS;sBAEG,OJgBdu0sB;sB5UMgB;uBgVpBQ,6BJGxBN;uBIDwB,6BJDxBD;uBICwB;iCAIZxlqB;0B,GAAAA;2BAAiB,QAAjBA,sBAAiBypC;;+BAAjB0+nB,eL/DZ1D;0BKgEF,UADc0D;2BAGV,OAHUA;;;0BAOV,IADYxC,WANFwC;0BAF6B,8BAQ3BxC;uBAGiB,yCJZ/BF;uBIc+B,yCJhB/BD;uBIgB+B;iCAKZxlqB;0B,GAAAA;2BAAiB,QAAjBA,sBAAiBypC;;+BAAjB0+nB,eL/EnB1D;0BKgFF,UADqB0D;2BAGjB,OAHiBA;;;0BAOjB,IADYxC,WANKwC;0BAFN,mCAQCxC;sBAGD,OJfbK;sBIiBiB,OJfjBC;sBIiBa,OJvBbH;sBIyB0B,OJtC1BP;sB5UqBgB;uBgVmBN,0BJrEVR;uBIuEiB,wBJrEjBC;uBIuEgB,uBJrEhBC;sBIuEgB,OJrEhBC;sB5U4CgB;;iCgV2BHllqB;0B,GAAAA,IAAQ,QAARA,OJjEQ8zD,MIiEArqB,aJjEAqqB,MDvCrB2wmB;0BCwCF,UADuB3wmB;2BAGnB,UAHmBA,MAJrBqxmB,mBAEAC;;;4BAQcO,WANO7xmB;kCAOZ,iBADK6xmB;iCI5CdqC;sBAyGqB,OJdrBxB;sBIgB6B,OJb7BC;sBIeoC,OJbpCC;sBIgBF,OJbEC;sB5UvBgB;uBgVsCM,6BJbtBC;uBIesB,6BJbtBC;uBIe6B;+BJb7BC;uBIekC;+BJblCC;uBIeY,mBJbZC;uBIec,qBJbdC;uBIee,mBJbfC;uBIegB,qBJbhBC;uBIea,oBJbbC;sBIea,OJbbC;sB5U3CgB,sBgV0DE,OJblBC;sBIasC;sBtzBHtCxjjB;sBJ5HExV;sB2zBVN;;sBjV+EoB;uBiV/EpB;;mCAIMi6jB,cAAc7vjB;4BAChB,SAAI1sB,UAAUp4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mEAEIhb,KAAY8rrB,UACwB;uBAHxC;;;oCAEI9rrB,EAAY8rrB,OACwB;sBAG3C;sBvqBhBH;sBqV+EoB;uBrV/EpB;iCAGWvtrB;0BAAqB,uCAArBA;0BAAqB,4CAAe;uBAG7C;;;mCAA0DyB;4BACtD,eACQzB,GACR,UAHsDyB,EAE9CzB,EACF;4BADM,qBxCmMZs9kB,OwCrMsD77kB;4BAE1C,iDACN;uBAHV;uBAeM;;;;;;;4C,OuqBXsBs1sB,8BtXiMnB1rhB;;uBjTtLH;uBAA8D;wC,UAA9DushB;;uCAAKC;sBqV0DO;uBrV1DkD;uBAA9D;;;;;;;;4C,OuqBXFtxe;8BtXiMKl7C;;uBjTtLH;uBAA8D;wC,UAA9D2shB;;;;;;;;;yC1I8IRpshB,2B0I9Ias6C;;uBAAL;uBAA8D;wC,UAA9D+xe;uBAA8D,mBAA9DjzsB,iBAA8D;;iCAA9DyX;;mDsDsFA+sK,ctDtFA/sK;6BuqBXF26rB,enoBmBExH,oBpCRAnzrB;;;0BAA8D,OAA9DzX,CAA8D;;iCAA9DyX;;;;;;;0BAA8D,OAA9DzX,CAA8D;0CAA9DozsB;uBAA8D;iCAA9DpzsB;;;;;mEsDsFAskL,ctDtFAzuH;;mDuqBXF08oB,cnoBkBA7H,mBpCPE50oB,IAA8D;;iCAA9Dr+C;;;;;0CsDsFA8sK,etDtFA9sK;iCuqBXF+6rB,enoBkBA7H,oBpCPElzrB,WAA8D;0CAA9D87rB;uBAA8D,YAA9DL;uBAA8D;uBAchE;;;;;;;4C,OuqBzBwBnB,8BtXiMnB1rhB;;uBjTxKL;uBAuBG;wC,UAvBHsthB;uBAuBG;iCAtBD1loB;0BuqB1BF;8BvqB0BEA;2BuqB1BF,GvqB0BEA;2BuqB1BF,wCnoBkBAy8nB,cmoBlBA70oB;;uBvqBgDG;iCuqBhDHp+C,UvqB0BEw2D;0BuqB1BF;8BvqB0BEA;2BuqB1BF,GvqB0BEA;2BuqB1BF,enoBkBA08nB,emoBlBAlzrB;4DvqB2BmC;uBAqBhC,mBkCLWo8rB;uBlCKX;iCAtB6Cp8rB,IuqB1BhDsvI,QvqB0BgDqrB;0BuqB1BhD;uBvqBgDG;iCuqBhDH36J;0BAEI;0CnoBiBFmzrB,emoBnBFnzrB;2BAEgB,yBAFhBA;0BAEgB,UAAZ46rB,IAAYC,SvqByBmB;uBAqBhC,mBkCLW2B,cMqLdD;uBxChLG,YkCLgEJ,WlClBnEG,gBACEG;uBAsBC;;iCAtBDzhiB;0BuqBxBM,GvqBwBNA,gBuqBxBM;0BvqBwBK,qB6DunCTs4hB,S7DvnCFt4hB;sEAA8D;uBAsB7D;iCAtBDoD;0BuqBxBM,GvqBwBNA,gBuqBxBM;0BvqBwBK,IuqBxBLv2K,EvqBwBK,W8pB+FfirsB,Y9pB/FI10hB;uCuqBxBMv2K,EAAiB,iBvqBwBvBu2K,mBuqBxBMv2K,CvqBwBwD;uBAsB7D;iCAtBD42K;0B,IuqB1BFloD,eTyHFs8kB,e9pB/FIp0hB;0DuqB1BFloD,IvqB0BErrH;uBAsBC;iCAtBDlG;0B,IAAAuxH,IgI8IFzH;;mChI9IEgulB,sBACiC;uBAqBhC;;;2BArCDhB;;;;;;;;2BAwBMzhpB;2BAEAknlB;uBAWL;;;;;iCAHah5oB;0BAAI,+BgnBkCpBg6oB,gBhnBlCgBh6oB,GAAuC;uBAGpD;iCADas+G;0BAAO,kBgnBuCvB47hB,oBhnBvCuB,YAAP57hB,MAAiD;uBAC9D;;;2BAtBDi2lB;2BkCiBYV;;;2BMqLdG;2BNrLmEJ;2BlClBnEG;2BACEG;;2BkCiBAU;2BM+LRN;2BN/LQK;2BlCjBAH;uBAsBC;;;iCAOOM;8BArCG95sB,EAqCH85sB,gBArCAr4sB,EAqCAq4sB;0BArC2B,UAA3Br4sB,EAA2B,OAAxBzB,GAsCU;uBwCmTzB6jK,sCxCtJE8ziB;uBA5LA;uCkCkBmEiB;sBmT0BrD;uBrV5Cd;;;;;;;;4C,OuqBzBArye;8BtXiMKl7C;;uBjTxKL;uBAuBG;wC,UAvBH2uhB;;;;;;;;;yC1IgINpuhB,2B0I/HaquhB;;uBADP;uBAuBG;wC,UAvBHC;uBAuBG,mBAvBHl1sB,iBAuBG;;iCAvBHyX;;mDsDwEE+sK,ctDxEF/sK;6BuqBzBA26rB,enoBmBExH,oBpCMFnzrB;;;0BAuBG,OAvBHzX,CAuBG;;iCAvBHyX;;;;;;;0BAuBG,OAvBHzX,CAuBG;;iCAvBHA;;;;;mEsDwEEskL,ctDxEFzuH;;mDuq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vKA,GOuKAA;;6BPvKA;;;;;0BOuKA,kBHxKF,KGwKEG;;;;mCHxKF,kDG2KuD;;iCAHrDliI;;;;;6BPvKA,GOuKA+hI;6BPvKA,GOuKAA;6BP9IF;6BAzBE,qBOuKA/hI,IP9IF0qC,MAzBE0T;oDOuKAp+C,IPvKAC;0BOuKA;;;2BHxKF,KGwKEiiI;2BHxKF,yBGwKEliI,IHxKFysC;kDGwKEzsC,IHxKFi6B,WG2KuD;;iCAHrDj6B;;;4BP9IF;;6BArBM,4BOmKJA;6BPnK+B,0BOmK/BA;6BPnK+B,SAA3Bm9vB,cAA2BC;sCOmK/Br/lB;;4BHxKF,4BGwKE/9J;4BHxKF;6BACsB;2DGuKpBA;yCHvKoBq9vB;;iCGuKpB/tP,QHxKF,uBGwKEhgY;;mEAGqD;;iCAHrDzoC;;;;;;;;;;;;4B8B6VE,c9B7VF;;;;;;;;;;;;;;;;;;;;kCHxKF,SGwKEl/G;;;;;;;2DHxKF,2BGwKEA;;;;;;;;;;;;;0CHxKF;;;;;;;;;;;;;;;;;;;;;uDACsB;mFADtB0yO;;;;0EACsBj4C,aADtBp9L;;8DACsBo9L,aADtB,sCGwKEz6L;yDHvKoB;;sDADtB;;;;;8CGwKEgvD;+CHxKF,mDGwKEhvD;;6CHxKF;kDGwKEgvD,KHxKF,0CGwKEhvD;;+CHxKF,UACsB41wB;+CADtB;gFGwKE5mtB,QHvKoB6mtB;;;iDGuKpB7mtB;kDHxKF;;oDGwKEhvD;gEHvKoB41wB;;;2CGuKpB5mtB,KHxKF,mCGwKEhvD;;8CHxKF,kCGwKEA;uDHxKF,2BGwKEA;;;;;;;gCPvKA,SOuKAk8I;0CPvKA,oCOuKAA;;kCPvKA;+COuKAA;mCPvKA;;;;;;;;;;;;;;;;;;;;;;;;;iGOuKAA,KPlKsD;yDALtDZ;;;;;;gDAII;0EAJJF;;kDAII;;;;;+CAA2B;yEAJ/BA;;iDAI+B;;;;8CAJ/B;;;;;sCOuKAe;uCPvKA,iDOuKAD;;qCPvKA;0COuKAC,KPvKA,wCOuKAD;;uCPvKA;8CAII45nB;wCAJJ,MAI+BC;;;;;yCAA3BE;yCOmKJ95nB,QPnKI85nB,kBAA2BD;;;;;yCOmK/B75nB;0CPvKA;;4COuKAD;;sDPnKI45nB;yDAA2BC;;0COmK/B55nB;;iEAGqD;;;0BAHrD;4BACE;;6BPxKF,SOwKED;6BPxKF,cOwKEA;6BPpK6B;;6BAA3B;iEAA2BK;6BAA3B;kDOoKFv8I;0BACA;;2BH1KJ,eG0KIm8I;2BHzKkB;;;gDGyKlBntF,SACmD;;iCAHrD8nH;0B,SAAAvzK;4BACE;gCADFA;6BACE,iCADFuzK;;6BPvKAloD,ea+NA6mlB,ebtMFnlJ,MO+IItV;oDPxKFpsb,IOwKEosb;0BACA,SAFFz3iB,OAEE,iCAFFuzK;4CMwDA2+hB,eT/NAllJ,MGyKEi5D;uBAFF;uCAAK4rJ;sBmTnGS;uBnT8Gd;;;;;;;;;0CP/IGhe;6CI1BAwO;;uBGyKH;uBAMqD;wC,UANrDyQ;uBAMqD;;0BANrD;;;6BPvKA,GOuKAj8nB;6BPvKA,GOuKAA;6BPvKA,GOuKAA;6BPvKA,GOuKAA;;6BPvKA;;;sE+qBLF25mB,c/qBKE1yO;;;;;0BOuKA;;2BHzKF,KGyKE9mY;2BHzKF,KGyKEA;2BHzKF;;;;0FG+KuD;;iCANrDliI;;;;;6BPvKA,GOuKA+hI;6BPvKA,GOuKAA;6BPvKA,GOuKAA;6BPvKA,GOuKAA;6BP/IF;6BAxBE,qBOuKA/hI,IP/IF+sC,MAxBEqR;oDOuKAp+C,IPvKAC;8C+qBLF07uB,exqB4KE37uB,IPvKAi6B;oDOuKAj6B,IPvKAk8B;0BOuKA;;;2BHzKF,KGyKEgmG;2BHzKF,KGyKEA;2BHzKF,yBGyKEliI,IHzKF0vC;kDGyKE1vC,IHzKF0qC;kDGyKE1qC,IHzKFysC,WG+KuD;;iCANrDzsC;;;4BP/IF;;6BAvBM,0BOsKJA;6BPrKI,4BOqKJA;6BPpKI,sB+qBRN47uB,exqB4KE57uB;6BPnKI,0BOmKJA;6BPnKI,SAHAq+vB,YACAlB,cACAmB,WACAlB;sCOmKJr/lB;;4BHzKF,4BGyKE/9J;4BHzKF;6BAEQ;wDGuKNA;8BHtKM,6BGsKNA;yCHvKMu+vB,YACAlB;;iCGsKN/tP,QHzKF,uBGyKEhgY;;mEAMqD;;iCANrDzoC;;;;;;;;;;;;4B8BkVE,c9BlVF;;;;;;;;;;;;;;;;;;;;kCHzKF,SGyKEl/G;;;;;;;2DHzKF,2BGyKEA;;;;;;;;;;;;;0CHzKF;;;;;;;;;;;;;;;;;;;;;;;;;;;yGGyKEA,GHpK6C;iEAL/Cs7I;;;;;;wDAGQ;oFAHRo3F;;0DAGQ;;;;;uDADA;mFAFRA;;yDAEQ;;;;sDAFR;;;;;8CGyKE1jL;+CHzKF,mDGyKEhvD;;6CHzKF;kDGyKEgvD,KHzKF,0CGyKEhvD;;+CHzKF;sDAEQ82wB;gDAFR,MAGQlB;;;;;iDADAmB;iDGuKN/ntB,QHvKM+ntB,gBACAlB;;;;;iDGsKN7mtB;kDHzKF;;oDGyKEhvD;;8DHvKM82wB;iEACAlB;;;2CGsKN5mtB,KHzKF,mCGyKEhvD;;8CHzKF,kCGyKEA;uDHzKF,2BGyKEA;;;;;;;gCPvKA,SOuKAk8I;0CPvKA,oCOuKAA;;kCPvKA;+COuKAA;mCPvKA;;;;;;;;;;;;;;;;;;;;;;;;;;;iGOuKAA,KPjKsD;yDANtDZ;;;;;;;;kDAGI;4EAHJF;;oDAGI;;uE+qBRN84mB,c/qBQM55jB;;;iDAFA;2EADJl/C;;mDACI;;;;;gDACA;0EAFJA;;kDAEI;;;;;+CAEA;yEAJJA;;iDAII;;;;8CAJJ;;;;;sCOuKAe;uCPvKA,iDOuKAD;;qCPvKA;0COuKAC,KPvKA,wCOuKAD;;uCPvKA;8CACI86nB;wCADJ,MAEIlB;wCAFJ,MAGImB;wCAHJ,MAIIlB;;;;;yCADAmB;yCADAjB;yCADAkB;yCOsKJh7nB;;2CPtKIg7nB;2CACAlB;2CACAiB;2CACAlB;;;;;yCOmKJ75nB;0CPvKA;;4COuKAD;;sDPtKI86nB;;uDACAlB;;wDACAmB;2DACAlB;;0COmKJ55nB;;iEAMqD;;;0BANrD;4BACE;;6BPxKF,SOwKED;6BPxKF,WOwKEA;6BPxKF,cOwKEA;6BPxKF,YOwKEA;6BPpKE;;6BADA,iB+qBRNi4mB,c/qBQMwiB;iEACAp6nB;6BAFA;iEACAC;6BAFA;iEACA6G;6BADA;kDOuKFrjJ;0BACA;;2BH3KJ,eG2KIm8I;2BH3KJ,YG2KIA;2BHxKI;;2BADA;+DACAga;2BADA;gDGyKJnnG,SAImD;;iCANrDwhgB;0B,SAAAjtjB;4BACE;gCADFA;6BACE,iCAD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MqLnE;uBAC+C;wC,UAD/CghF;;uCAAKC;sB6S3JS;;;kClUjDTx4C;;mCKMFuP;;oCK0VAqR;uCvK3NTn1kB,mBiL+CSqomB;;;kCHrLI9J;qC9KsIbv+lB,mB4K9GyE8rhB;uBMuMnE;;;;;;;;;uCNvMmEA;;wCyqBd/C0+C;;;;;uBnqBqNpB;uBAa+C;wC,UAb/CyiC;uBAa+C;;0BAb/C;;;;;;;;;;;;;;oEkqBrPFxiC,clqBqPE3vmB;;;;;;;;oEJhOA8njB,cIgOA3jJ;;;gDlLzFNh/X,kB4K9GoB8rhB,mBMuMd/sJ;;oEJhOA4jJ,cIgOA7jJ;;;;;0BhBzOA,GgByOAD;2BhBzOA;+BgByOAA;4BhBzOAK,GgByOAL;4BhBzOAnmC,GgByOAmmC;4BhBzOA9wf,GgByOA8wf;4BhBzOA/wf,GgByOA+wf;4BhBzOA;;;;;;;0BgByOA;;;;sDlLzFN7+X,kBiL+CIqomB,cC0CE1pO,KAa+C;;iCAb/CjviB;;;;;;;;;;;;;;4CkqBrPF+6uB,elqBqPE/6uB;;;;6CJhOAkzrB,eIgOAlzrB;kClLzFNuwK,mB4K9GoB8rhB,iBMuMdr8rB;6CJhOAkzrB,eIgOAlzrB;2BhBxNF;;;;0BAjBE,GgByOAmviB;2BhBzOA;+BgByOAA;4BhBzOAK,GgByOAL;4BhBzOAnmC,GgByOAmmC;4BhBzOA9wf,GgByOA8wf;4BhBzOA/wf,GgByOA+wf;4BhBzOA,uBgByOAnviB,IhBxNF4vC;4BAjBE,uBgByOA5vC,IhBzOAC;mDgByOAD,IhBzOAi6B;mDgByOAj6B,IhBzOAk8B;mDgByOAl8B,IhBzOA0qC;4BgByOAiF,OhBzOA,iBgByOA3vC,IhBzOAysC;;+BgByOAkD,OhBzOA,mBgByOA3vC,IhBxNF4vC;0BgBwNE;iClLzFN2gI,mBiL+CIqomB,eC0CE54wB,eAa+C;;iCAb/CA;2EAa+C;;iCAb/CA;0BACI;sDADJA;2BAEI,sBkqBvPNg7uB,elqBqPEh7uB;2BAGI,gCAHJA;2BAII,oCAJJA;2BAKI,+BALJA;2BAMI,gCJrOFmzrB,eI+NFnzrB;2BAOI+9wB,WlLhGVvtmB,kB4K9GoBgshB,cMuMdx8rB;2BAQI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tC,gBnBxLHptC;6BmBwLGotC,gBIxMH6T;6BE8IG0F;;6BN0DAvZ,gB2QXHlyB;;wC,OxQnMwBqkC;uBGuwB3B;;;;;;;;+B,ODnwBGiC;;;uBCmwBH;uBAS+C;wC,UAT/CwL;uBAS+C;iCAT/CrqyB;0BDxwBF;8BCwwBEA;2BDxwBF,GCwwBEA;2BDxwBF,GCwwBEA;2BDxwBF,KCwwBEA;2BDxwBF,KCwwBEA;2BHvwBF,GEDAmpH;2BFCA,GEDAA;;;2BFCA;oDH8MAuhqB,cF1LAh/E,cKpBA70oB;2BEDA;;;;oDFCAp0D,KGoJAwhyB,oBHpJAntuB;2BEDA;;gDL+MA4ztB,cF1LAh/E,cOrBA9njB;;;gDL+MA8moB,cF1LAh/E,cOrBAjqL;;;gDL+MAipQ,cF1LAh/E,cOrBAzjJ;8DCqJAg8O,oBDrJAj8O;uBCixBiD;iCHhxBjDvviB,QGuwBEzY;0BDxwBF;8BCwwBEA;2BDxwBF,GCwwBEA;2BDxwBF,GCwwBEA;2BDxwBF,KCwwBEA;2BDxwBF,KCwwBEA;2BHvwBF,GEDAmpH;2BFCA,GEDAA;2BCwwBE;;2BHvwBF/jE,MH8MAuluB,eF1LAh/E,eKpBAlzrB;2BEDAysC,MCqJAg/uB,qBHpJAzrxB;2BEDA0qC,ML+MAwnuB,eF1LAh/E,eKpBAlzrB,IEDAysC;iCL+MAyluB,eF1LAh/E,eKpBAlzrB,IEDA0qC;iCL+MAwnuB,eF1LAh/E,eKpBAlzrB,IEDAk8B;iCCqJAuvvB,qBHpJAzrxB,IEDAi6B,SCixBiD;;iCHhxBjDj6B;0BGuwBE;;;2BHnwBE89tB,OH0MJq0C,eFzLEh/E,eKrBFnzrB;2BAIyB0kxB,iBGgJzBgH,qBHpJA1rxB;2BEWI4nxB,YFPA9pD,OAAqB4mD;2BEQrBiD,OLkMJxV,eFzLEh/E,eKrBFnzrB;2BEaI0nxB;4BLiMJvV,eFzLEh/E,eKrBFnzrB;2BEgBIynxB,kBL8LJtV,eFzLEh/E,eKrBFnzrB;2BEiBIwnxB,eCmIJkE,qBHpJA1rxB;;kCEWI4nxB;kCACAD;kCACAD;kCAGAD;kCACAD,eC+vB6C;;iCAT/Cj/xB;0B;0BAOI,sB,OA1nBNojyB;0BAynBM;4B,ON/jBNv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FE,KE8FFA;2BF9FE;oDN5rBFowoB,cF1LAh/E,cQs3BE5vjB;;;;yDAtvBFmopB,oBAsvBE/lI;;0DAtvBF+lI,oBAsvBEhmI;;;2BE8FF;;;;8BF9FE;2BA1cF,GEwiBA/sC;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,KEwiBAA;2BFxiBA;oDA5SA+yK,6BA4SAtppB;;yDA5SAsppB,0BA4SAntuB;;;gDNlPA4ztB,cF1LAh/E,cQ4aAjqL;;;gDNlPAipQ,cJjKc71E,mBUmZd5sJ;;;;;;8B4hBxbA6kO;gD,OliBsMApC,4BMkPA1iO;;;gDNlPA0iO,mCMkPA3iO;+DNlPA2iO,mBMkPA5iO;2BEwiBA;;;;oDFxiBA/oH,ONlPA2rV,mBMkPA7iO;2BEmuBA;;;;;2CA3LAm3G,QFp1BAilI,0BEo1BArmI;2BA2LA;;;0BAppCA,UAopCAp2G;;;2BAppCA;iCAopCAA;;6BAppCA,mCVKAkkJ,cULAzvjB;0BF23BE;2BEuwBF0khB;;uEA9eAH;0BpBrqCF,UoBmpDEzC;;;2BpBnpDF,SoBmpDEA;4BpBnpDF;kCoBmpDEA;;8BpBnpDF;;;kCoBmpDEA;mCpBnpDF;uDoBmpDE4C,cAE8D;;iC1CrpDhElopB,I0CmpDEsxC;;;;2BA9eA,IA8eAo5F;2BA9eA,IA8eAA;2BA9eA,IA8eAA;2BA9eA,IA8eAA;2BA9eA,GA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,KA8eAA;2BA9eA,uB1CrqCF1qI,I0CmpDEsxC,OA9eAi5F;4C4pBpqCFwwmB,etsBDA/6uB,I0CqqCE+vC;2BAxgBA,KAwgBAo2mB;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA,KAwgBAA;2BAxgBA;;4B0hBnpBAmuH;;gC,OliBsEA3D;8BlChFF3wwB;8B0C6pBE8vC;;kCR7kBA6guB,eJjCct0E,iB9B/ChBr8rB,I0C6pBEyzC;kCR7kBAk9tB,qBlChFF3wwB,I0C6pBEi1C;kCR7kBA07tB,eTwSFjrB,ezBxXA1lvB,I0C6pBEm1C;kCR7kBAw7tB,qBlChFF3wwB,I0C6pBEk1C;kCR7kBAy7tB,qBlChFF3wwB,I0C6pBEs2C;kCR7kBAq6tB,eQ6aEitB,e1C7fJ59xB,I0C6pBEq2C;2BAwgBAF,ORrlCAw6tB,eF1DAz9E,ehCtBFlzrB,I0C6pBEo2C;2BvC9pBF,GuCsqCE2vmB;2BvCtqCF,GuCsqCEA;2BvCtqCF,8BHCA/lpB,I0CqqCEm2C,OvCtqCFiI;2BHCA;4BGDAC;8BHCA;;2B0CqqCE,uB1CrqCFr+C,I0CqqCEi6B;iD1CrqCFj6B,I0CqqCE6vC;iD1CrqCF7vC,I0CqqCE4vC;kE1CrqCF5vC,I0CqqCE2vC;2BA3LA,KA2LAw/f;2BA3LA,KA2LAA;2BA3LA,KA2LAA;2BF7OA;;;mCA3CSm/P;4B,OAvvBT7iB;0BAsvBE;gCE8FF5ppB;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE,KE8FFA;2BF9FE/vF,ON5rBFoguB,eF1LAh/E,ehCtBFlzrB,I0C0+BEwwC,OF9FE6yF;8CxC54BJrjI,IwC44BI8xC;8CxC54BJ9xC,IwC44BIysC;kCAtvBFg/uB,qBxCtJFzrxB,IwC44BI2sC;kCAtvBF8+uB,qBxCtJFzrxB,IwC44BIoxC;kDxC54BJpxC,IwC44BI+xC;kDxC54BJ/xC,IwC44BI+sC;2BA1cF,GEwiBA24mB;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,GEwiBAA;2BFxiBA,KEwiBAA;2BFxiBA,KEwiBAA;2BFxiBA7zmB,OA5SA45uB,8BxCtJFzrxB,I0C0+BE0vC,MFxiBAwyF;kCA5SAuppB,2BxCtJFzrxB,IwCkcE6xC;kCNlPAqguB,eF1LAh/E,ehCtBFlzrB,IwCkcE4xC;kCNlPAsguB,eJjKc71E,iB9B/ChBr8rB,IwCkcE2xC;;;4B4hBxbA2iuB;;gC,OliBsMApC;8BlChNFlywB;8BwCkcE+zC;;kCNlPAm+tB,oClChNFlywB,IwCkcE8zC;kCNlPAo+tB,oBlChNFlywB,IwCkcE6zC;2BEwiBAF,OR1xBAu+tB,oBlChNFlywB,IwCkcE4zC;2BEmuBAF,OF/gCA+3uB,2BxCtJFzrxB,I0C0+BE2zC;2BA2LA,uB1CrqCF3zC,I0CqqCE0zC;kD1CrqCF1zC,I0CqqCE4wC;0BApiCA,OAoiCAo+f;8CApiCA,mB1CjIFhviB,I0CiIE2wC;uCAoiCAQ,OApiCA,mB1CjIFnxC,I0CiIE2wC;wCAoiCAQ,OApiCA,mB1CjIFnxC,I0CiIE2wC;0BAhHA,UAopCAo+f;2BAppCA;4BAkoDA19f;6BA9eA09f;+BAppCA,mB1CjBF/uiB,I0CqqCEmxC;+BAppCA,mB1CjBFnxC,I0CqqCEmxC;;2BAppCA;iCAopCA49f;4BAppCA,yB1CjBF/uiB,I0CqqCEmxC;4BA8eAE,OAloDA,WVKA6hpB,ehCtBFlzrB,I0CiBEyvC;0BpBjBF,UoBmpDE21mB;2BpBnpDF,0BtBAAplpB,I0CmpDEqxC;;4BpBnpDF,SoBmpDE+zmB;8BpBnpDF,SoBmpDEA,QpBnpDF,yBtBAAplpB,I0CmpDEqxC;8BpBnpDF,oCtBAArxC,IsBAAk8B;qCoBmpDEkpnB,QpBnpDF,yBtBAAplpB,I0CmpDEqxC;4BpBnpDF,sBtBAArxC,IsBAA0qC,YoBqpDgE;;iC1CrpDhE1qC;0B0CsqCM;sD1CtqCNA;2B0CuqCM,sB4pBtqCNg7uB,etsBDAh7uB;2B0C6pBE;2BACIy+oB;4B0hBppBJ81H;;gC,OliBsEA3D;8BlChFF5wwB;;2B0CgqBMwuyB,aRhlBJ59B,eJjCcp0E,c9B/ChBx8rB;2B0CiqBM84wB,mBRjlBJlI,qBlChFF5wwB;2B0CmqBMu+wB,cRnlBJ3N,eTwSFjrB,ezBxXA3lvB;2B0CoqBMm5wB,YRplBJvI,qBlChFF5wwB;2B0CqqBM49wB,eRrlBJhN,qBlChFF5wwB;2B0CuqBMi+wB,SRvlBJrN,eQ6aEitB,e1C7fJ79xB;2B0CwqBMg+wB,aRxlBJpN,eFzDEz9E,ehCvBJnzrB;2B0CwqCMgqyB;;6BA1gBAvrJ;6BAEA+vJ;6BACA11B;6BAEAyF;6BACApF;6BACAyE;6BAEAK;6BACAD;2BvCvqBF,sCHDJh+wB;;;;;;2B0CyqCM+pyB,oBvCxqCF7yF,YAAwBD;2BuC0qCtB,kC1C3qCNj3sB;2B0C4qCM,wB1C5qCNA;2B0C6qCM,yB1C7qCNA;2B0C8qCM,4C1C9qCNA;2BwCw7BE;;;mCA3CSuouB;4B,OAvvBTmjD;0BAwwBM;2BADAkL;4BN7sBNzkB,eFzLEh/E,ehCvBJnzrB;2BwC85BQ,8BxC95BRA;2BwC06BQ,+BxC16BRA;2BwC26BQ0kxB,iBArxBNgH,qBxCtJF1rxB;2BwC46BQ+moB;4BAtxBN2kJ,qBxCtJF1rxB;2BwC66BQ,mCxC76BRA;2BwC86BQ,gCxC96BRA;2BwC86BQ;;6BAjBA42xB;6BACA5vJ;6BAYA2vJ;6BACAjS;6BACA39I;6BACA2vJ;6BACAD;2BA3eF5Y,UA7SJ6N,8BxCtJF1rxB;2BwCocMy6vB,QA9SJixB,2BxCtJF1rxB;2BwCqcM89wB;4BNrPJ3L,eFzLEh/E,ehCvBJnzrB;2BwCscM+9wB,WNtPJ5L,eJjKc31E,c9B/ChBx8rB;;2BwCucM0ulB;4B4hB7bJ6lL;;gC,OliBsMApC;8BlChNFnywB;;2BwCwcMg5wB;4BNxPJ7G,oClChNFnywB;2BwCycMk5wB,eNzPJ/G,oBlChNFnywB;2BwC0cM2uxB,SN1PJxc,oBlChNFnywB;2B0C4+BMkqyB;;6BFziBArsB;6BACApjB;6BACAqjB;6BACAC;6BACArvL;6BACAsqL;6BACAE;6BACAyV;2BEmiBAsb,cFv1BJve,2BxCtJF1rxB;2B0C+qCM2pyB,mBApMAzgS,UACAghS,UACAD;2BAmMA,sC1ChrCNjqyB;2B0CirCM,+C1CjrCNA;2B0CiIE,0B1CjIFA;0B0CiIE;+BAijCIwpyB,gBAjjCJ,uB1CjIFl6pB;;;wC0CkrCMk6pB;;;0BFpRE,YE74BN,kB1CjBFxpyB;0B0CiBE;+BAkqCIupyB,qBAlqCJ,uB1CjBFj6pB;;;wC0CmrCMi6pB;;8BAlqCJ;kDVMEp2G,ehCvBJnzrB;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;;2BAxgBAtzB;;8B0hBnpBAhb;uC1hBqpBM5nb;gC,OR/kBNy6pB,qCQ+kBMz6pB;8BAFN01d;;kCR7kBA+kM,eEoJA5zE,eMybAjkJ;kCR7kBA63N,e6qBjEA+C,erqB8oBA36N;kCR7kBA43N,eTwSFzoB,eiBqSElvM;kCR7kBA23N,ekBvDE7hqB,cVooBFmqc;kCR7kBA03N,ekBvDE7hqB,cVooBFoqc;kCR7kBAy3N,eQ6aEgtB,eAgKF3xN;2BAwgBAE,ORrlCAykM,qBQ6kBA1kM;;2B1C7pBF/1d,+B0CqqCEg2d;;;8B1CrqCsC,2BAAxCh2d;8BAAoC,2BAApCA;2B0CqqCE21d;kCApGEg5N,eAoGFh5N;kCApGEg5N,eAoGF/4N;2BF5OIH,wCE4OJI;;;mCFzREgkO,iBA8CE75rB;4B,OApyBJ01qB,4BAoyBI11qB;;2BA9CF0ic,ON5rBFs5N,qBMyuBIvmM;2BA7CFrzB;2BAgDEC,OAhDFw3P;2BA+CEr3P,OAryBJkzO,+BAsyBIrzO;2BAhDFI,OAtvBFizO,4BAqyBIlzO;2BA/CFF;2BE8FFC,OF9FEq5O;;2BA1cFh6O,MA5SA8zO,+BEo1BAnzO;2BFxiBAV,MA5SA6zO,4BA4SA9zO;iCNlPAo6N,qBMkPAn6N;iCNlPAm6N,eEoBAn1E,eI8NA/kJ;;;;8B4hBxbAla;uC5hB6bY5nb;gC,ONvPZg8pB,qCMuPYh8pB;8BALZ+hc;;iCNlPAi6N,qCMkPAh6N;iCNlPAg6N,6BMkPA/5N;2BEwiBAE,OR1xBA65N,6BMkPA95N;2BEmuBA+zB,OF/gCAy/M,4BEo1BAvzO;2BA2LA28G;2BApiCAG,gCAoiCAH;;;wCAniCE,2BADFG;;iCAoiCAC,OA/hCE,2BALFD;wCAoiCAC,OA1hCE,2BAVFD;;;2BA5GE;4BA8nDFK;;+BA9nDE,2BAgpCFJ;+BAlpCE,2BAkpCFA;;2BAjpCE;;8DAipCFA;4BA8eAI,OA/nDE,WgnByGJg9B,ehnBzGI35I;oCA+nDFhujB;;2BpBhpDA,kCoBgpDA2qqB;;;8BpBlpDA,iDoBkpDAA;8BpBlpDA;4BACA;;8DoBipDAA;4BpBjpDA;uBoBmpD8D;iCAF9D7wqB;0B,IAAAu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B;kDE4UMv8rB;2C,OAvUFu+rB;oDAsUF3E,qCACI55rB;;yCAAFA;;8BADF0hc;;yDAqVA1hc;uBA7BA;;uBA8CM;;;;;;;;;uCHqhCDu6rB;;;;;mC,OG33CmDkJ;4CHy0CnDnM,gBxLt/CXv8nB;;;;uB2LmhBY;uBAS+C;wC,UAT/C8soB;uBAS+C;;0BAT/C;;;;2BHqhCN,KGrhCMr8qB;2BHqhCN,KGrhCMA;2BH+lBJ,GAsbFrxB;2BAtbE,GAsbFA;2BAtbE,GAsbFA;2BAtbE,GAsbFA;2BAtbE;;;;;gDxLlnCR4/D,8BwLknCQ04V;2BAsbF;;;;8BAtbE;2BG/lBI;;;;8BHqhCN;;4B,OGjsDEyqS;qCAsUI3F;0BAsWA;;;;;8B3LnhBZv+nB;;kC,OyL9JIwioB;gCEirBQnuO;;kFAS+C;;iCAT/C5jkB;;;;;2BHqhCN,KGrhCM+hI;2BHqhCN,KGrhCMA;2BH+lBJ,GAsbFrxB;2BAtbE,GAsbFA;2BAtbE,GAsbFA;2BAtbE,GAsbFA;2BAtbE,qBG/lBI1wG,UH+lBJo+C;2DG/lBIp+C,IH+lBJC;iCxLlnCRswK,+B2LmhBYvwK,IH+lBJi6B;2BAsbFiC,6BGrhCMl8B,IH+lBJ2sC;2BG/lBIjC,MxBlqBRyssB,ewBkqBQn3uB,IHqhCNk8B;;4B,OGjsDEy3wB;qCAsUItF;;;;;;;2BAsWAthwB;4B3LnhBZyiI;;gC,OyL9JIyioB;;8BEirBQjyyB;;;uEAS+C;;iCAT/CA;2EAS+C;;iCAT/CA;0BHgmBA;sDGhmBAA;2BHimBA,gCGjmBAA;2BHkmBA06vB,cxLrnCZlqlB,8B2LmhBYxwK;2BHomBA,+BGpmBAA;2BHomBA,UAJAuksB,aACAg2D,MACAG,cAEAD;2BAmbF,+BGvhCEz6vB;2BHuhCF,eADAugwB,OACAkuC;;4B,OGnsDFoF;qCAsUItF;0BA6WI;2BALAgP;4B3LrhBhB9toB;;gC,OyL9JI0ioB;8BEirBQnyyB;;2BAOI,8BAPJA;0BAOI,UANAw9yB,YACAD,kBAKA5iD,OAE2C;uBAT/C;wCAAK0jD;sBoSvmBG;uBpS8pBNM;wBAfF;mCAIWC;2CAHEC;8BACT;oCAEO3J,eADIC;8DAC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8DWh1N,mBAAkB;sC7B9DjB03kB;;;;;;;;;;;;;2CAAZjhc;;;;8CAAY,eAAZotY,MAAY,wBAAZA,YAA4C;8CAA5C,wCAA4C;0CAA5C;;;;sCAAY,yDAAgC;sCAAhC;wC6B8DwC;0BAAlD;;;;+C7B9DFknO,mB6BYS/1kB;2BAkDFM,iBAALuvD;;4B7B9DF,c6B8DEtiO;;+B7B9DU4Q,K6B8DV5Q;+B7B9DiC82D,GAAvBlmD;+BAAuBimD,GAAvBjmD;+BAAuBnO,6B6BY/BuwK,W7BZ+Bn8G;+BAAvBu/G,gCAAuB3zK,K6BY/BuwK,W7BZ+Bl8G;2DAAvBs/G;uC6B8DVp2K,K7B9DUw8zB,Y6BYRxppB,W7BZQ5/D;;mC6B8DV8gE;4B7B9DF,c6B8DEl0K;;+B7B9DU4Q,K6B8DV5Q;+B7B9DU0Y,IwDyXZkvI,sB3B3TEnvI;+B7B9DiCq+C,GAAvBlmD;+BAAuBimD,GAAvBjmD;+BAAuB8hC,M6BY/BugI,YAkDFx6J,I7B9DUC,IAAuBm+C;qC6BY/Bo8G,YAkDFx6J,I7B9DiCi6B;;6BAAvB0gE,O6B8DVpzG;6B7B9DU20C,MwDyXZizG,sB3B3TEnvI;mCAlDEw6J,YAkDFx6J,I7B9DUk8B,a6B+DqC;8BAD/Cw/H;gDAA4B17J;4B,O7B9D9BgwuB,e6BYIp1kB,aAkD0B56J;mCAA5B47J;4B,O7B9DFq0kB,e6BYIr1kB,aAkDF56J,YAC+C;;2BAD/C67J;sCAAKvB,cAALoB;;;4B,gB7B9DF70D;;gE6BYIq6D,U7BZJr6D;;;;;oDAC+C;qC6B6D7Ct+G;;4B7B9DF,c6B8DEhB;;+B7B9DUI,G6B8DVJ;+B7B9DiC62D,GAAvBz2D;+BAAuBgvD,KAAvBhvD;+BAAuBk8I,K6BY/B3uB,U7BZ+Bv+D;oC6BY/Bu+D,U7BZ+B92D;;gCAAvB0lF,K6B8DVv8I;kDAlDE2tH,U7BZQ4uB;mC6B8DV7oC;4BAA4B,S7B9D9B6qC,M6B8DWK,wCAAkB;4B7B9D7B,G6B8DE69qB,gB7B9DF;0C6B8DEA;;gC7B9DiC;iCAAnCtkpB,U6B8DEx5B;iC7B9DFy5B,S6B8DEqkpB;iC7B9DiC/xM,MAAnCtyc;iCAAmCuyc,MAAnCv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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 caml_named_value, caml_global_data, caml_string_of_jsstring\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 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//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 globalThis.Error(str);\n // otherwise, just throw an unhelpful error\n console.dir(err, { depth: 10 });\n throw globalThis.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","/* global plonk_wasm, caml_jsstring_of_string, 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: tsBindings\nvar tsBindings = globalThis.__snarkyTsBindings;\n\n// Provides: tsRustConversion\n// Requires: tsBindings, plonk_wasm\nvar tsRustConversion = tsBindings.rustConversion(plonk_wasm);\n\n// Provides: tsSrs\n// Requires: tsBindings, plonk_wasm\nvar tsSrs = tsBindings.srs(plonk_wasm);\n\n// Provides: getTsBindings\n// Requires: tsBindings\nfunction getTsBindings() {\n return tsBindings;\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 globalThis.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_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: free_finalization_registry\nvar free_finalization_registry = new globalThis.FinalizationRegistry(function (\n instance_representative\n) {\n instance_representative.free();\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.__wbg_ptr);\n free_finalization_registry.register(x, instance_representative, x);\n return x;\n};\n\n// srs\n\n// Provides: caml_fp_srs_create\n// Requires: tsSrs\nvar caml_fp_srs_create = tsSrs.fp.create;\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: tsSrs\nvar caml_fp_srs_lagrange_commitment = tsSrs.fp.lagrangeCommitment;\n\n// Provides: caml_fp_srs_commit_evaluations\n// Requires: plonk_wasm, tsRustConversion\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 tsRustConversion.fp.vectorToRust(fps)\n );\n return tsRustConversion.fp.polyCommFromRust(res);\n};\n\n// Provides: caml_fp_srs_b_poly_commitment\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fp_srs_b_poly_commitment = function (srs, chals) {\n var res = plonk_wasm.caml_fp_srs_b_poly_commitment(\n srs,\n tsRustConversion.fieldsToRustFlat(chals)\n );\n return tsRustConversion.fp.polyCommFromRust(res);\n};\n\n// Provides: caml_fp_srs_batch_accumulator_check\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fp_srs_batch_accumulator_check = function (srs, comms, chals) {\n var rust_comms = tsRustConversion.fp.pointsToRust(comms);\n var rust_chals = tsRustConversion.fp.vectorToRust(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, tsRustConversion\nvar caml_fp_srs_batch_accumulator_generate = function (srs, n_comms, chals) {\n var rust_chals = tsRustConversion.fp.vectorToRust(chals);\n var rust_comms = plonk_wasm.caml_fp_srs_batch_accumulator_generate(\n srs,\n n_comms,\n rust_chals\n );\n return tsRustConversion.fp.pointsFromRust(rust_comms);\n};\n\n// Provides: caml_fp_srs_h\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fp_srs_h = function (t) {\n return tsRustConversion.fp.pointFromRust(plonk_wasm.caml_fp_srs_h(t));\n};\n\n// Provides: caml_fp_srs_add_lagrange_basis\n// Requires: tsSrs\nvar caml_fp_srs_add_lagrange_basis = tsSrs.fp.addLagrangeBasis;\n\n// Provides: caml_fq_srs_create\n// Requires: tsSrs\nvar caml_fq_srs_create = tsSrs.fq.create;\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: tsSrs\nvar caml_fq_srs_lagrange_commitment = tsSrs.fq.lagrangeCommitment;\n\n// Provides: caml_fq_srs_commit_evaluations\n// Requires: plonk_wasm, tsRustConversion\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 tsRustConversion.fq.vectorToRust(fqs)\n );\n return tsRustConversion.fq.polyCommFromRust(res);\n};\n\n// Provides: caml_fq_srs_b_poly_commitment\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fq_srs_b_poly_commitment = function (srs, chals) {\n var res = plonk_wasm.caml_fq_srs_b_poly_commitment(\n srs,\n tsRustConversion.fieldsToRustFlat(chals)\n );\n return tsRustConversion.fq.polyCommFromRust(res);\n};\n\n// Provides: caml_fq_srs_batch_accumulator_check\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fq_srs_batch_accumulator_check = function (srs, comms, chals) {\n var rust_comms = tsRustConversion.fq.pointsToRust(comms);\n var rust_chals = tsRustConversion.fq.vectorToRust(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, tsRustConversion\nvar caml_fq_srs_batch_accumulator_generate = function (srs, comms, chals) {\n var rust_chals = tsRustConversion.fq.vectorToRust(chals);\n var rust_comms = plonk_wasm.caml_fq_srs_batch_accumulator_generate(\n srs,\n comms,\n rust_chals\n );\n return tsRustConversion.fq.pointsFromRust(rust_comms);\n};\n\n// Provides: caml_fq_srs_h\n// Requires: plonk_wasm, tsRustConversion\nvar caml_fq_srs_h = function (t) {\n return tsRustConversion.fq.pointFromRust(plonk_wasm.caml_fq_srs_h(t));\n};\n\n// Provides: caml_fq_srs_add_lagrange_basis\n// Requires: tsSrs\nvar caml_fq_srs_add_lagrange_basis = tsSrs.fq.addLagrangeBasis;\n\n// gate vector\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, tsRustConversion\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 tsRustConversion.fp.gateToRust(x)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_gate_vector_get\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_gate_vector_get = function (v, i) {\n return tsRustConversion.fp.gateFromRust(\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, tsRustConversion\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 tsRustConversion.wireToRust(x),\n tsRustConversion.wireToRust(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// prover index\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, tsRustConversion\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 tsRustConversion.fq.gateToRust(x)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_gate_vector_get\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fq_plonk_gate_vector_get = function (v, i) {\n return tsRustConversion.fq.gateFromRust(\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, tsRustConversion\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 tsRustConversion.wireToRust(x),\n tsRustConversion.wireToRust(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_pasta_fp_plonk_index_create\n// Requires: plonk_wasm, free_on_finalize, tsRustConversion\nvar caml_pasta_fp_plonk_index_create = function (\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n var wasm_lookup_tables =\n tsRustConversion.fp.lookupTablesToRust(caml_lookup_tables);\n var wasm_runtime_table_cfgs = tsRustConversion.fp.runtimeTableCfgsToRust(\n caml_runtime_table_cfgs\n );\n\n var t = plonk_wasm.caml_pasta_fp_plonk_index_create(\n gates,\n public_inputs,\n wasm_lookup_tables,\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_create_bytecode\n// Requires: caml_pasta_fp_plonk_index_create\nvar caml_pasta_fp_plonk_index_create_bytecode = function (\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n return caml_pasta_fp_plonk_index_create(\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n );\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_pasta_fq_plonk_index_create\n// Requires: plonk_wasm, free_on_finalize, tsRustConversion\nvar caml_pasta_fq_plonk_index_create = function (\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n var wasm_lookup_tables =\n tsRustConversion.fq.lookupTablesToRust(caml_lookup_tables);\n var wasm_runtime_table_cfgs = tsRustConversion.fq.runtimeTableCfgsToRust(\n caml_runtime_table_cfgs\n );\n\n return free_on_finalize(\n plonk_wasm.caml_pasta_fq_plonk_index_create(\n gates,\n public_inputs,\n wasm_lookup_tables,\n wasm_runtime_table_cfgs,\n prev_challenges,\n urs\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_index_create_bytecode\n// Requires: caml_pasta_fq_plonk_index_create\nvar caml_pasta_fq_plonk_index_create_bytecode = function (\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\n) {\n return caml_pasta_fq_plonk_index_create(\n gates,\n public_inputs,\n caml_lookup_tables,\n caml_runtime_table_cfgs,\n prev_challenges,\n urs\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// verifier index\n\n// Provides: caml_opt_of_rust\nvar caml_opt_of_rust = function (value, value_of_rust) {\n if (value === undefined) {\n return 0;\n } else {\n return [0, value_of_rust(value)];\n }\n};\n\n// Provides: caml_opt_to_rust\nvar caml_opt_to_rust = function (caml_optional_value, to_rust) {\n // to_rust expects the parameters of the variant. A `Some vx` is represented\n // as [0, vx]\n if (caml_optional_value === 0) {\n return undefined;\n } else {\n return to_rust(caml_optional_value[1]);\n }\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_create\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_verifier_index_create = function (x) {\n var vk = plonk_wasm.caml_pasta_fp_plonk_verifier_index_create(x);\n return tsRustConversion.fp.verifierIndexFromRust(vk);\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_read\n// Requires: plonk_wasm, caml_jsstring_of_string, tsRustConversion\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 tsRustConversion.fp.verifierIndexFromRust(\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, tsRustConversion\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 tsRustConversion.fp.verifierIndexToRust(t),\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_shifts\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_verifier_index_shifts = function (log2_size) {\n return tsRustConversion.fp.shiftsFromRust(\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, tsRustConversion\nvar caml_pasta_fp_plonk_verifier_index_dummy = function () {\n var res = plonk_wasm.caml_pasta_fp_plonk_verifier_index_dummy();\n return tsRustConversion.fp.verifierIndexFromRust(res);\n};\n\n// Provides: caml_pasta_fp_plonk_verifier_index_deep_copy\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_verifier_index_deep_copy = function (x) {\n return tsRustConversion.fp.verifierIndexFromRust(\n plonk_wasm.caml_pasta_fp_plonk_verifier_index_deep_copy(\n tsRustConversion.fp.verifierIndexToRust(x)\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_create\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fq_plonk_verifier_index_create = function (x) {\n return tsRustConversion.fq.verifierIndexFromRust(\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, tsRustConversion\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 tsRustConversion.fq.verifierIndexFromRust(\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, tsRustConversion\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 tsRustConversion.fq.verifierIndexToRust(t),\n caml_jsstring_of_string(path)\n );\n};\n\n// Provides: caml_pasta_fq_plonk_verifier_index_shifts\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fq_plonk_verifier_index_shifts = function (log2_size) {\n return tsRustConversion.fq.shiftsFromRust(\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, tsRustConversion\nvar caml_pasta_fq_plonk_verifier_index_dummy = function () {\n return tsRustConversion.fq.verifierIndexFromRust(\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, tsRustConversion, tsRustConversion\nvar caml_pasta_fq_plonk_verifier_index_deep_copy = function (x) {\n return tsRustConversion.fq.verifierIndexFromRust(\n plonk_wasm.caml_pasta_fq_plonk_verifier_index_deep_copy(\n tsRustConversion.fq.verifierIndexToRust(x)\n )\n );\n};\n\n// proof\n\n// Provides: caml_pasta_fp_plonk_proof_create\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_proof_create = function (\n index,\n witness_cols,\n caml_runtime_tables,\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(tsRustConversion.fp.vectorToRust(witness_cols[i]));\n }\n witness_cols = w;\n prev_challenges = tsRustConversion.fp.vectorToRust(prev_challenges);\n var wasm_runtime_tables =\n tsRustConversion.fp.runtimeTablesToRust(caml_runtime_tables);\n prev_sgs = tsRustConversion.fp.pointsToRust(prev_sgs);\n var proof = plonk_wasm.caml_pasta_fp_plonk_proof_create(\n index,\n witness_cols,\n wasm_runtime_tables,\n prev_challenges,\n prev_sgs\n );\n return tsRustConversion.fp.proofFromRust(proof);\n};\n\n// Provides: caml_pasta_fp_plonk_proof_verify\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fp_plonk_proof_verify = function (index, proof) {\n index = tsRustConversion.fp.verifierIndexToRust(index);\n proof = tsRustConversion.fp.proofToRust(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, tsRustConversion\nvar caml_pasta_fp_plonk_proof_batch_verify = function (indexes, proofs) {\n indexes = tsRustConversion.mapMlArrayToRustVector(\n indexes,\n tsRustConversion.fp.verifierIndexToRust\n );\n proofs = tsRustConversion.mapMlArrayToRustVector(\n proofs,\n tsRustConversion.fp.proofToRust\n );\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, tsRustConversion\nvar caml_pasta_fp_plonk_proof_dummy = function () {\n return tsRustConversion.fp.proofFromRust(\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, tsRustConversion\nvar caml_pasta_fp_plonk_proof_deep_copy = function (proof) {\n return tsRustConversion.fp.proofFromRust(\n plonk_wasm.caml_pasta_fp_plonk_proof_deep_copy(\n tsRustConversion.fp.proofToRust(proof)\n )\n );\n};\n\n// Provides: caml_pasta_fq_plonk_proof_create\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fq_plonk_proof_create = function (\n index,\n witness_cols,\n caml_runtime_tables,\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(tsRustConversion.fq.vectorToRust(witness_cols[i]));\n }\n witness_cols = w;\n prev_challenges = tsRustConversion.fq.vectorToRust(prev_challenges);\n var wasm_runtime_tables =\n tsRustConversion.fq.runtimeTablesToRust(caml_runtime_tables);\n prev_sgs = tsRustConversion.fq.pointsToRust(prev_sgs);\n var proof = plonk_wasm.caml_pasta_fq_plonk_proof_create(\n index,\n witness_cols,\n wasm_runtime_tables,\n prev_challenges,\n prev_sgs\n );\n return tsRustConversion.fq.proofFromRust(proof);\n};\n\n// Provides: caml_pasta_fq_plonk_proof_verify\n// Requires: plonk_wasm, tsRustConversion\nvar caml_pasta_fq_plonk_proof_verify = function (index, proof) {\n index = tsRustConversion.fq.verifierIndexToRust(index);\n proof = tsRustConversion.fq.proofToRust(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, tsRustConversion\nvar caml_pasta_fq_plonk_proof_batch_verify = function (indexes, proofs) {\n indexes = tsRustConversion.mapMlArrayToRustVector(\n indexes,\n tsRustConversion.fq.verifierIndexToRust\n );\n proofs = tsRustConversion.mapMlArrayToRustVector(\n proofs,\n tsRustConversion.fq.proofToRust\n );\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, tsRustConversion\nvar caml_pasta_fq_plonk_proof_dummy = function () {\n return tsRustConversion.fq.proofFromRust(\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, tsRustConversion\nvar caml_pasta_fq_plonk_proof_deep_copy = function (proof) {\n return tsRustConversion.fq.proofFromRust(\n plonk_wasm.caml_pasta_fq_plonk_proof_deep_copy(\n tsRustConversion.fq.proofToRust(proof)\n )\n );\n};\n\n// oracles\n\n// Provides: fp_oracles_create\n// Requires: plonk_wasm, tsRustConversion\nvar fp_oracles_create = function (lgr_comm, verifier_index, proof) {\n return tsRustConversion.fp.oraclesFromRust(\n plonk_wasm.fp_oracles_create(\n tsRustConversion.fp.polyCommsToRust(lgr_comm),\n tsRustConversion.fp.verifierIndexToRust(verifier_index),\n tsRustConversion.fp.proofToRust(proof)\n )\n );\n};\n\n// Provides: fp_oracles_create_no_public\n// Requires: fp_oracles_create\nvar fp_oracles_create_no_public = function (lgr_comm, verifier_index, proof) {\n return fp_oracles_create(lgr_comm, verifier_index, [0, 0, proof]);\n};\n\n// Provides: fp_oracles_dummy\n// Requires: plonk_wasm, tsRustConversion\nvar fp_oracles_dummy = function () {\n return tsRustConversion.fp.oraclesFromRust(plonk_wasm.fp_oracles_dummy());\n};\n\n// Provides: fp_oracles_deep_copy\n// Requires: plonk_wasm, tsRustConversion\nvar fp_oracles_deep_copy = function (x) {\n return tsRustConversion.fp.oraclesFromRust(\n plonk_wasm.fp_oracles_deep_copy(tsRustConversion.fp.oraclesToRust(x))\n );\n};\n\n// Provides: fq_oracles_create\n// Requires: plonk_wasm, tsRustConversion\nvar fq_oracles_create = function (lgr_comm, verifier_index, proof) {\n return tsRustConversion.fq.oraclesFromRust(\n plonk_wasm.fq_oracles_create(\n tsRustConversion.fq.polyCommsToRust(lgr_comm),\n tsRustConversion.fq.verifierIndexToRust(verifier_index),\n tsRustConversion.fq.proofToRust(proof)\n )\n );\n};\n\n// Provides: fq_oracles_create_no_public\n// Requires: fq_oracles_create\nvar fq_oracles_create_no_public = function (lgr_comm, verifier_index, proof) {\n return fq_oracles_create(lgr_comm, verifier_index, [0, 0, proof]);\n};\n\n// Provides: fq_oracles_dummy\n// Requires: plonk_wasm, tsRustConversion\nvar fq_oracles_dummy = function () {\n return tsRustConversion.fq.oraclesFromRust(plonk_wasm.fq_oracles_dummy());\n};\n\n// Provides: fq_oracles_deep_copy\n// Requires: plonk_wasm, tsRustConversion\nvar fq_oracles_deep_copy = function (x) {\n return tsRustConversion.fq.oraclesFromRust(\n plonk_wasm.fq_oracles_deep_copy(tsRustConversion.fq.oraclesToRust(x))\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, tsRustConversion, tsRustConversion\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 tsRustConversion.fp.vectorToRust(fp_vector)\n );\n var new_fp_vector = tsRustConversion.fp.vectorFromRust(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, tsRustConversion, tsRustConversion\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 tsRustConversion.fq.vectorToRust(fq_vector)\n );\n var new_fq_vector = tsRustConversion.fq.vectorFromRust(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","/* global tsBindings\n*/\n\n// Provides: caml_bigint_256_of_numeral\n// Requires: tsBindings\nvar caml_bigint_256_of_numeral = tsBindings.caml_bigint_256_of_numeral;\n\n// Provides: caml_bigint_256_of_decimal_string\n// Requires: tsBindings\nvar caml_bigint_256_of_decimal_string = tsBindings.caml_bigint_256_of_decimal_string;\n\n// Provides: caml_bigint_256_num_limbs\n// Requires: tsBindings\nvar caml_bigint_256_num_limbs = tsBindings.caml_bigint_256_num_limbs;\n\n// Provides: caml_bigint_256_bytes_per_limb\n// Requires: tsBindings\nvar caml_bigint_256_bytes_per_limb = tsBindings.caml_bigint_256_bytes_per_limb;\n\n// Provides: caml_bigint_256_div\n// Requires: tsBindings\nvar caml_bigint_256_div = tsBindings.caml_bigint_256_div;\n\n// Provides: caml_bigint_256_compare\n// Requires: tsBindings\nvar caml_bigint_256_compare = tsBindings.caml_bigint_256_compare;\n\n// Provides: caml_bigint_256_print\n// Requires: tsBindings\nvar caml_bigint_256_print = tsBindings.caml_bigint_256_print;\n\n// Provides: caml_bigint_256_to_string\n// Requires: tsBindings\nvar caml_bigint_256_to_string = tsBindings.caml_bigint_256_to_string;\n\n// Provides: caml_bigint_256_test_bit\n// Requires: tsBindings\nvar caml_bigint_256_test_bit = tsBindings.caml_bigint_256_test_bit;\n\n// Provides: caml_bigint_256_to_bytes\n// Requires: tsBindings\nvar caml_bigint_256_to_bytes = tsBindings.caml_bigint_256_to_bytes;\n\n// Provides: caml_bigint_256_of_bytes\n// Requires: tsBindings\nvar caml_bigint_256_of_bytes = tsBindings.caml_bigint_256_of_bytes;\n\n// Provides: caml_bigint_256_deep_copy\n// Requires: tsBindings\nvar caml_bigint_256_deep_copy = tsBindings.caml_bigint_256_deep_copy\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","// Provides: plonk_wasm\nvar plonk_wasm = require('./plonk_wasm.js');\n","/* global tsBindings */\n\n// fp\n\n// Provides: caml_fp_vector_create\n// Requires: tsBindings\nvar caml_fp_vector_create = tsBindings.caml_fp_vector_create;\n\n// Provides: caml_fp_vector_length\n// Requires: tsBindings\nvar caml_fp_vector_length = tsBindings.caml_fp_vector_length;\n\n// Provides: caml_fp_vector_emplace_back\n// Requires: tsBindings\nvar caml_fp_vector_emplace_back = tsBindings.caml_fp_vector_emplace_back;\n\n// Provides: caml_fp_vector_get\n// Requires: tsBindings\nvar caml_fp_vector_get = tsBindings.caml_fp_vector_get;\n\n// Provides: caml_fp_vector_set\n// Requires: tsBindings\nvar caml_fp_vector_set = tsBindings.caml_fp_vector_set;\n\n// fq\n\n// Provides: caml_fq_vector_create\n// Requires: tsBindings\nvar caml_fq_vector_create = tsBindings.caml_fq_vector_create;\n\n// Provides: caml_fq_vector_length\n// Requires: tsBindings\nvar caml_fq_vector_length = tsBindings.caml_fq_vector_length;\n\n// Provides: caml_fq_vector_emplace_back\n// Requires: tsBindings\nvar caml_fq_vector_emplace_back = tsBindings.caml_fq_vector_emplace_back;\n\n// Provides: caml_fq_vector_get\n// Requires: tsBindings\nvar caml_fq_vector_get = tsBindings.caml_fq_vector_get;\n\n// Provides: caml_fq_vector_set\n// Requires: tsBindings\nvar caml_fq_vector_set = tsBindings.caml_fq_vector_set;\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","/* global tsBindings\n*/\n\n// pallas\n\n// Provides: caml_pallas_one\n// Requires: tsBindings\nvar caml_pallas_one = tsBindings.caml_pallas_one;\n\n// Provides: caml_pallas_add\n// Requires: tsBindings\nvar caml_pallas_add = tsBindings.caml_pallas_add;\n\n// Provides: caml_pallas_sub\n// Requires: tsBindings\nvar caml_pallas_sub = tsBindings.caml_pallas_sub;\n\n// Provides: caml_pallas_negate\n// Requires: tsBindings\nvar caml_pallas_negate = tsBindings.caml_pallas_negate;\n\n// Provides: caml_pallas_double\n// Requires: tsBindings\nvar caml_pallas_double = tsBindings.caml_pallas_double;\n\n// Provides: caml_pallas_scale\n// Requires: tsBindings\nvar caml_pallas_scale = tsBindings.caml_pallas_scale;\n\n// Provides: caml_pallas_random\n// Requires: tsBindings\nvar caml_pallas_random = tsBindings.caml_pallas_random;\n\n// Provides: caml_pallas_rng\n// Requires: tsBindings\nvar caml_pallas_rng = tsBindings.caml_pallas_rng;\n\n// Provides: caml_pallas_endo_base\n// Requires: tsBindings\nvar caml_pallas_endo_base = tsBindings.caml_pallas_endo_base;\n\n// Provides: caml_pallas_endo_scalar\n// Requires: tsBindings\nvar caml_pallas_endo_scalar = tsBindings.caml_pallas_endo_scalar;\n\n// Provides: caml_pallas_to_affine\n// Requires: tsBindings\nvar caml_pallas_to_affine = tsBindings.caml_pallas_to_affine;\n\n// Provides: caml_pallas_of_affine\n// Requires: tsBindings\nvar caml_pallas_of_affine = tsBindings.caml_pallas_of_affine;\n\n// Provides: caml_pallas_of_affine_coordinates\n// Requires: tsBindings\nvar caml_pallas_of_affine_coordinates = tsBindings.caml_pallas_of_affine_coordinates;\n\n// Provides: caml_pallas_affine_deep_copy\n// Requires: tsBindings\nvar caml_pallas_affine_deep_copy = tsBindings.caml_pallas_affine_deep_copy;\n\n// vesta\n\n// Provides: caml_vesta_one\n// Requires: tsBindings\nvar caml_vesta_one = tsBindings.caml_vesta_one;\n\n// Provides: caml_vesta_add\n// Requires: tsBindings\nvar caml_vesta_add = tsBindings.caml_vesta_add;\n\n// Provides: caml_vesta_sub\n// Requires: tsBindings\nvar caml_vesta_sub = tsBindings.caml_vesta_sub;\n\n// Provides: caml_vesta_negate\n// Requires: tsBindings\nvar caml_vesta_negate = tsBindings.caml_vesta_negate;\n\n// Provides: caml_vesta_double\n// Requires: tsBindings\nvar caml_vesta_double = tsBindings.caml_vesta_double;\n\n// Provides: caml_vesta_scale\n// Requires: tsBindings\nvar caml_vesta_scale = tsBindings.caml_vesta_scale;\n\n// Provides: caml_vesta_random\n// Requires: tsBindings\nvar caml_vesta_random = tsBindings.caml_vesta_random;\n\n// Provides: caml_vesta_rng\n// Requires: tsBindings\nvar caml_vesta_rng = tsBindings.caml_vesta_rng;\n\n// Provides: caml_vesta_endo_base\n// Requires: tsBindings\nvar caml_vesta_endo_base = tsBindings.caml_vesta_endo_base;\n\n// Provides: caml_vesta_endo_scalar\n// Requires: tsBindings\nvar caml_vesta_endo_scalar = tsBindings.caml_vesta_endo_scalar;\n\n// Provides: caml_vesta_to_affine\n// Requires: tsBindings\nvar caml_vesta_to_affine = tsBindings.caml_vesta_to_affine;\n\n// Provides: caml_vesta_of_affine\n// Requires: tsBindings\nvar caml_vesta_of_affine = tsBindings.caml_vesta_of_affine;\n\n// Provides: caml_vesta_of_affine_coordinates\n// Requires: tsBindings\nvar caml_vesta_of_affine_coordinates = tsBindings.caml_vesta_of_affine_coordinates;\n\n// Provides: caml_vesta_affine_deep_copy\n// Requires: tsBindings\nvar caml_vesta_affine_deep_copy = tsBindings.caml_vesta_affine_deep_copy;\n","/* global tsBindings\n*/\n\n// Provides: caml_pasta_fp_copy\n// Requires: tsBindings\nvar caml_pasta_fp_copy = tsBindings.caml_pasta_fp_copy;\n\n// Provides: caml_pasta_fp_size_in_bits\n// Requires: tsBindings\nvar caml_pasta_fp_size_in_bits = tsBindings.caml_pasta_fp_size_in_bits;\n\n// Provides: caml_pasta_fp_size\n// Requires: tsBindings\nvar caml_pasta_fp_size = tsBindings.caml_pasta_fp_size;\n\n// Provides: caml_pasta_fp_add\n// Requires: tsBindings\nvar caml_pasta_fp_add = tsBindings.caml_pasta_fp_add;\n\n// Provides: caml_pasta_fp_sub\n// Requires: tsBindings\nvar caml_pasta_fp_sub = tsBindings.caml_pasta_fp_sub;\n\n// Provides: caml_pasta_fp_negate\n// Requires: tsBindings\nvar caml_pasta_fp_negate = tsBindings.caml_pasta_fp_negate;\n\n// Provides: caml_pasta_fp_mul\n// Requires: tsBindings\nvar caml_pasta_fp_mul = tsBindings.caml_pasta_fp_mul;\n\n// Provides: caml_pasta_fp_div\n// Requires: tsBindings\nvar caml_pasta_fp_div = tsBindings.caml_pasta_fp_div;\n\n// Provides: caml_pasta_fp_inv\n// Requires: tsBindings\nvar caml_pasta_fp_inv = tsBindings.caml_pasta_fp_inv;\n\n// Provides: caml_pasta_fp_square\n// Requires: tsBindings\nvar caml_pasta_fp_square = tsBindings.caml_pasta_fp_square\n\n// Provides: caml_pasta_fp_is_square\n// Requires: tsBindings\nvar caml_pasta_fp_is_square = tsBindings.caml_pasta_fp_is_square;\n\n// Provides: caml_pasta_fp_sqrt\n// Requires: tsBindings\nvar caml_pasta_fp_sqrt = tsBindings.caml_pasta_fp_sqrt;\n\n// Provides: caml_pasta_fp_of_int\n// Requires: tsBindings\nvar caml_pasta_fp_of_int = tsBindings.caml_pasta_fp_of_int\n\n// Provides: caml_pasta_fp_to_string\n// Requires: tsBindings\nvar caml_pasta_fp_to_string = tsBindings.caml_pasta_fp_to_string;\n\n// Provides: caml_pasta_fp_of_string\n// Requires: tsBindings\nvar caml_pasta_fp_of_string = tsBindings.caml_pasta_fp_of_string;\n\n// Provides: caml_pasta_fp_print\n// Requires: tsBindings\nvar caml_pasta_fp_print = tsBindings.caml_pasta_fp_print;\n\n// Provides: caml_pasta_fp_mut_add\n// Requires: tsBindings\nvar caml_pasta_fp_mut_add = tsBindings.caml_pasta_fp_mut_add;\n\n// Provides: caml_pasta_fp_mut_sub\n// Requires: tsBindings\nvar caml_pasta_fp_mut_sub = tsBindings.caml_pasta_fp_mut_sub;\n\n// Provides: caml_pasta_fp_mut_mul\n// Requires: tsBindings\nvar caml_pasta_fp_mut_mul = tsBindings.caml_pasta_fp_mut_mul;\n\n// Provides: caml_pasta_fp_mut_square\n// Requires: tsBindings\nvar caml_pasta_fp_mut_square = tsBindings.caml_pasta_fp_mut_square;\n\n// Provides: caml_pasta_fp_compare\n// Requires: tsBindings\nvar caml_pasta_fp_compare = tsBindings.caml_pasta_fp_compare;\n\n// Provides: caml_pasta_fp_equal\n// Requires: tsBindings\nvar caml_pasta_fp_equal = tsBindings.caml_pasta_fp_equal;\n\n// Provides: caml_pasta_fp_random\n// Requires: tsBindings\nvar caml_pasta_fp_random = tsBindings.caml_pasta_fp_random;\n\n// Provides: caml_pasta_fp_rng\n// Requires: tsBindings\nvar caml_pasta_fp_rng = tsBindings.caml_pasta_fp_rng;\n\n// Provides: caml_pasta_fp_to_bigint\n// Requires: tsBindings\nvar caml_pasta_fp_to_bigint = tsBindings.caml_pasta_fp_to_bigint;\n\n// Provides: caml_pasta_fp_of_bigint\n// Requires: tsBindings\nvar caml_pasta_fp_of_bigint = tsBindings.caml_pasta_fp_of_bigint;\n\n// Provides: caml_pasta_fp_two_adic_root_of_unity\n// Requires: tsBindings\nvar caml_pasta_fp_two_adic_root_of_unity = tsBindings.caml_pasta_fp_two_adic_root_of_unity;\n\n// Provides: caml_pasta_fp_domain_generator\n// Requires: tsBindings\nvar caml_pasta_fp_domain_generator = tsBindings.caml_pasta_fp_domain_generator;\n\n// Provides: caml_pasta_fp_to_bytes\n// Requires: tsBindings\nvar caml_pasta_fp_to_bytes = tsBindings.caml_pasta_fp_to_bytes;\n\n// Provides: caml_pasta_fp_of_bytes\n// Requires: tsBindings\nvar caml_pasta_fp_of_bytes = tsBindings.caml_pasta_fp_of_bytes;\n\n// Provides: caml_pasta_fp_deep_copy\n// Requires: tsBindings\nvar caml_pasta_fp_deep_copy = tsBindings.caml_pasta_fp_deep_copy;\n\n\n\n\n// Provides: caml_pasta_fq_copy\n// Requires: tsBindings\nvar caml_pasta_fq_copy = tsBindings.caml_pasta_fq_copy;\n\n// Provides: caml_pasta_fq_size_in_bits\n// Requires: tsBindings\nvar caml_pasta_fq_size_in_bits = tsBindings.caml_pasta_fq_size_in_bits;\n\n// Provides: caml_pasta_fq_size\n// Requires: tsBindings\nvar caml_pasta_fq_size = tsBindings.caml_pasta_fq_size;\n\n// Provides: caml_pasta_fq_add\n// Requires: tsBindings\nvar caml_pasta_fq_add = tsBindings.caml_pasta_fq_add;\n\n// Provides: caml_pasta_fq_sub\n// Requires: tsBindings\nvar caml_pasta_fq_sub = tsBindings.caml_pasta_fq_sub;\n\n// Provides: caml_pasta_fq_negate\n// Requires: tsBindings\nvar caml_pasta_fq_negate = tsBindings.caml_pasta_fq_negate;\n\n// Provides: caml_pasta_fq_mul\n// Requires: tsBindings\nvar caml_pasta_fq_mul = tsBindings.caml_pasta_fq_mul;\n\n// Provides: caml_pasta_fq_div\n// Requires: tsBindings\nvar caml_pasta_fq_div = tsBindings.caml_pasta_fq_div;\n\n// Provides: caml_pasta_fq_inv\n// Requires: tsBindings\nvar caml_pasta_fq_inv = tsBindings.caml_pasta_fq_inv; \n\n// Provides: caml_pasta_fq_square\n// Requires: tsBindings\nvar caml_pasta_fq_square = tsBindings.caml_pasta_fq_square\n\n// Provides: caml_pasta_fq_is_square\n// Requires: tsBindings\nvar caml_pasta_fq_is_square = tsBindings.caml_pasta_fq_is_square;\n\n// Provides: caml_pasta_fq_sqrt\n// Requires: tsBindings\nvar caml_pasta_fq_sqrt = tsBindings.caml_pasta_fq_sqrt;\n\n// Provides: caml_pasta_fq_of_int\n// Requires: tsBindings\nvar caml_pasta_fq_of_int = tsBindings.caml_pasta_fq_of_int;\n\n// Provides: caml_pasta_fq_to_string\n// Requires: tsBindings\nvar caml_pasta_fq_to_string = tsBindings.caml_pasta_fq_to_string;\n\n// Provides: caml_pasta_fq_of_string\n// Requires: tsBindings\nvar caml_pasta_fq_of_string = tsBindings.caml_pasta_fq_of_string;\n\n// Provides: caml_pasta_fq_print\n// Requires: tsBindings\nvar caml_pasta_fq_print = tsBindings.caml_pasta_fq_print;\n\n// Provides: caml_pasta_fq_mut_add\n// Requires: tsBindings\nvar caml_pasta_fq_mut_add = tsBindings.caml_pasta_fq_mut_add;\n\n// Provides: caml_pasta_fq_mut_sub\n// Requires: tsBindings\nvar caml_pasta_fq_mut_sub = tsBindings.caml_pasta_fq_mut_sub;\n\n// Provides: caml_pasta_fq_mut_mul\n// Requires: tsBindings\nvar caml_pasta_fq_mut_mul = tsBindings.caml_pasta_fq_mut_mul;\n\n// Provides: caml_pasta_fq_mut_square\n// Requires: tsBindings\nvar caml_pasta_fq_mut_square = tsBindings.caml_pasta_fq_mut_square;\n\n// Provides: caml_pasta_fq_compare\n// Requires: tsBindings\nvar caml_pasta_fq_compare = tsBindings.caml_pasta_fq_compare;\n\n// Provides: caml_pasta_fq_equal\n// Requires: tsBindings\nvar caml_pasta_fq_equal = tsBindings.caml_pasta_fq_equal;\n\n// Provides: caml_pasta_fq_random\n// Requires: tsBindings\nvar caml_pasta_fq_random = tsBindings.caml_pasta_fq_random;\n\n// Provides: caml_pasta_fq_rng\n// Requires: tsBindings\nvar caml_pasta_fq_rng = tsBindings.caml_pasta_fq_rng;\n\n// Provides: caml_pasta_fq_to_bigint\n// Requires: tsBindings\nvar caml_pasta_fq_to_bigint = tsBindings.caml_pasta_fq_to_bigint;\n\n// Provides: caml_pasta_fq_of_bigint\n// Requires: tsBindings\nvar caml_pasta_fq_of_bigint = tsBindings.caml_pasta_fq_of_bigint;\n\n// Provides: caml_pasta_fq_two_adic_root_of_unity\n// Requires: tsBindings\nvar caml_pasta_fq_two_adic_root_of_unity = tsBindings.caml_pasta_fq_two_adic_root_of_unity;\n\n// Provides: caml_pasta_fq_domain_generator\n// Requires: tsBindings\nvar caml_pasta_fq_domain_generator = tsBindings.caml_pasta_fq_domain_generator;\n\n// Provides: caml_pasta_fq_to_bytes\n// Requires: tsBindings\nvar caml_pasta_fq_to_bytes = tsBindings.caml_pasta_fq_to_bytes;\n\n// Provides: caml_pasta_fq_of_bytes\n// Requires: tsBindings\nvar caml_pasta_fq_of_bytes = tsBindings.caml_pasta_fq_of_bytes;\n\n// Provides: caml_pasta_fq_deep_copy\n// Requires: tsBindings\nvar caml_pasta_fq_deep_copy = tsBindings.caml_pasta_fq_deep_copy;\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\n// Requires: deferred_of_promise\nfunction deferred_run(func) {\n if (func.length > 1) {\n // we add this restriction to be able to use .then(func) below,\n // which allows us to implement external functions that are synchronous\n // in native Rust with async functions in JS\n throw Error(\n 'deferred_run cannot be called with a function that takes more than 1 argument.'\n );\n }\n return deferred_of_promise(\n // the ocaml types don't know this, but func can actually be async or sync\n globalThis.Promise.resolve().then(func)\n );\n}\n\n// Provides: deferred_map\n// Requires: deferred_of_promise\nfunction deferred_map(deferred, func) {\n return deferred_of_promise(\n deferred.promise.then(function (value) {\n // we might be given a `func` with multiple arguments,\n // have to match ocaml call semantics\n if (func.length === 1) return func(value);\n return function () {\n return func.apply(null, [value].concat(Array.from(arguments)));\n };\n })\n );\n}\n\n// Provides: deferred_bind\n// Requires: deferred_of_promise\nfunction deferred_bind(deferred, func) {\n return deferred_of_promise(\n deferred.promise.then(function (input) {\n var anotherDeferred = func(input);\n return anotherDeferred.promise;\n })\n );\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: globalThis.Promise.resolve(value),\n value: value,\n isError: false,\n isDetermined: true,\n };\n}\n\n// Provides: deferred_create\n// Requires: deferred_of_promise\nfunction deferred_create(promise_creator) {\n return deferred_of_promise(\n new globalThis.Promise(function (resolve) {\n promise_creator(resolve);\n })\n );\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 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 : Pickles_types.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","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","open 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","# 1 \"lib/read.mll\"\n \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 #ifdef INT\n try `Int (extract_positive_int lexbuf)\n with Int_overflow ->\n #endif\n #ifdef INTLIT\n `Intlit (lexeme lexbuf)\n #else\n lexer_error \"Int overflow\" v lexbuf\n #endif\n\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 #ifdef INT\n try `Int (extract_negative_int lexbuf)\n with Int_overflow ->\n #endif\n #ifdef INTLIT\n `Intlit (lexeme lexbuf)\n #else\n lexer_error \"Int overflow\" v lexbuf\n #endif\n\n\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# 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# 188 \"lib/read.mll\"\n ( `Bool true )\n# 1032 \"lib/read.ml\"\n\n | 1 ->\n# 189 \"lib/read.mll\"\n ( `Bool false )\n# 1037 \"lib/read.ml\"\n\n | 2 ->\n# 190 \"lib/read.mll\"\n ( `Null )\n# 1042 \"lib/read.ml\"\n\n | 3 ->\n# 191 \"lib/read.mll\"\n (\n #ifdef FLOAT\n `Float nan\n #elif defined FLOATLIT\n `Floatlit \"NaN\"\n #endif\n )\n# 1053 \"lib/read.ml\"\n\n | 4 ->\n# 198 \"lib/read.mll\"\n (\n #ifdef FLOAT\n `Float infinity\n #elif defined FLOATLIT\n `Floatlit \"Infinity\"\n #endif\n )\n# 1064 \"lib/read.ml\"\n\n | 5 ->\n# 205 \"lib/read.mll\"\n (\n #ifdef FLOAT\n `Float neg_infinity\n #elif defined FLOATLIT\n `Floatlit \"-Infinity\"\n #endif\n )\n# 1075 \"lib/read.ml\"\n\n | 6 ->\n# 212 \"lib/read.mll\"\n (\n #ifdef STRING\n Bi_outbuf.clear v.buf;\n `String (finish_string v lexbuf)\n #elif defined STRINGLIT\n `Stringlit (finish_stringlit v lexbuf)\n #endif\n )\n# 1087 \"lib/read.ml\"\n\n | 7 ->\n# 220 \"lib/read.mll\"\n ( make_positive_int v lexbuf )\n# 1092 \"lib/read.ml\"\n\n | 8 ->\n# 221 \"lib/read.mll\"\n ( make_negative_int v lexbuf )\n# 1097 \"lib/read.ml\"\n\n | 9 ->\n# 222 \"lib/read.mll\"\n (\n #ifdef FLOAT\n `Float (float_of_string (lexeme lexbuf))\n #elif defined FLOATLIT\n `Floatlit (lexeme lexbuf)\n #endif\n )\n# 1108 \"lib/read.ml\"\n\n | 10 ->\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# 1135 \"lib/read.ml\"\n\n | 11 ->\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# 1154 \"lib/read.ml\"\n\n | 12 ->\n# 270 \"lib/read.mll\"\n (\n #ifdef TUPLE\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 1178 \"lib/read.ml\"\n\n | 13 ->\n# 291 \"lib/read.mll\"\n (\n #ifdef VARIANT\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 1192 \"lib/read.ml\"\n\n | 14 ->\n# 302 \"lib/read.mll\"\n ( read_json v lexbuf )\n# 1197 \"lib/read.ml\"\n\n | 15 ->\n# 303 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_json v lexbuf )\n# 1202 \"lib/read.ml\"\n\n | 16 ->\n# 304 \"lib/read.mll\"\n ( newline v lexbuf; read_json v lexbuf )\n# 1207 \"lib/read.ml\"\n\n | 17 ->\n# 305 \"lib/read.mll\"\n ( read_json v lexbuf )\n# 1212 \"lib/read.ml\"\n\n | 18 ->\n# 306 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1217 \"lib/read.ml\"\n\n | 19 ->\n# 307 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n# 1222 \"lib/read.ml\"\n\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# 311 \"lib/read.mll\"\n ( Bi_outbuf.contents v.buf )\n# 1234 \"lib/read.ml\"\n\n | 1 ->\n# 312 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n finish_string v lexbuf )\n# 1240 \"lib/read.ml\"\n\n | 2 ->\n# 314 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n finish_string v lexbuf )\n# 1246 \"lib/read.ml\"\n\n | 3 ->\n# 316 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1251 \"lib/read.ml\"\n\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# 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# 1264 \"lib/read.ml\"\n\n | 1 ->\n# 321 \"lib/read.mll\"\n ( finish_escaped_char v lexbuf;\n map_string v f lexbuf )\n# 1270 \"lib/read.ml\"\n\n | 2 ->\n# 323 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf;\n map_string v f lexbuf )\n# 1276 \"lib/read.ml\"\n\n | 3 ->\n# 325 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1281 \"lib/read.ml\"\n\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# 330 \"lib/read.mll\"\n c\n# 1294 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n# 330 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf c )\n# 1298 \"lib/read.ml\"\n\n | 1 ->\n# 331 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\b' )\n# 1303 \"lib/read.ml\"\n\n | 2 ->\n# 332 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\012' )\n# 1308 \"lib/read.ml\"\n\n | 3 ->\n# 333 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n' )\n# 1313 \"lib/read.ml\"\n\n | 4 ->\n# 334 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\r' )\n# 1318 \"lib/read.ml\"\n\n | 5 ->\n# 335 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\t' )\n# 1323 \"lib/read.ml\"\n\n | 6 ->\nlet\n# 336 \"lib/read.mll\"\n a\n# 1329 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1)\nand\n# 336 \"lib/read.mll\"\n b\n# 1334 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n# 336 \"lib/read.mll\"\n c\n# 1339 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n# 336 \"lib/read.mll\"\n d\n# 1344 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4) in\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# 1355 \"lib/read.ml\"\n\n | 7 ->\n# 345 \"lib/read.mll\"\n ( long_error \"Invalid escape sequence\" v lexbuf )\n# 1360 \"lib/read.ml\"\n\n | 8 ->\n# 346 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1365 \"lib/read.ml\"\n\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# 349 \"lib/read.mll\"\n a\n# 1378 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2)\nand\n# 349 \"lib/read.mll\"\n b\n# 1383 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 3)\nand\n# 349 \"lib/read.mll\"\n c\n# 1388 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 4)\nand\n# 349 \"lib/read.mll\"\n d\n# 1393 \"lib/read.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 5) in\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# 1405 \"lib/read.ml\"\n\n | 1 ->\n# 359 \"lib/read.mll\"\n ( long_error \"Missing escape sequence representing low surrogate \\\n for code point beyond U+FFFF\" v lexbuf )\n# 1411 \"lib/read.ml\"\n\n | 2 ->\n# 361 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1416 \"lib/read.ml\"\n\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# 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# 1433 \"lib/read.ml\"\n\n | 1 ->\n# 372 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n# 1438 \"lib/read.ml\"\n\n | 2 ->\n# 373 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1443 \"lib/read.ml\"\n\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# 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# 1458 \"lib/read.ml\"\n\n | 1 ->\n# 380 \"lib/read.mll\"\n ( None )\n# 1463 \"lib/read.ml\"\n\n | 2 ->\n# 381 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n# 1468 \"lib/read.ml\"\n\n | 3 ->\n# 382 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1473 \"lib/read.ml\"\n\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# 385 \"lib/read.mll\"\n ( () )\n# 1485 \"lib/read.ml\"\n\n | 1 ->\n# 386 \"lib/read.mll\"\n ( long_error \"Expected '<' but found\" v lexbuf )\n# 1490 \"lib/read.ml\"\n\n | 2 ->\n# 387 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1495 \"lib/read.ml\"\n\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# 390 \"lib/read.mll\"\n ( () )\n# 1507 \"lib/read.ml\"\n\n | 1 ->\n# 391 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n# 1512 \"lib/read.ml\"\n\n | 2 ->\n# 392 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1517 \"lib/read.ml\"\n\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# 395 \"lib/read.mll\"\n ( () )\n# 1529 \"lib/read.ml\"\n\n | 1 ->\n# 396 \"lib/read.mll\"\n ( long_error \"Expected ',' but found\" v lexbuf )\n# 1534 \"lib/read.ml\"\n\n | 2 ->\n# 397 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1539 \"lib/read.ml\"\n\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# 400 \"lib/read.mll\"\n ( `Edgy_bracket )\n# 1551 \"lib/read.ml\"\n\n | 1 ->\n# 401 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n `Double_quote )\n# 1557 \"lib/read.ml\"\n\n | 2 ->\n# 403 \"lib/read.mll\"\n ( `Square_bracket )\n# 1562 \"lib/read.ml\"\n\n | 3 ->\n# 404 \"lib/read.mll\"\n ( long_error \"Expected '<', '\\\"' or '[' but found\" v lexbuf )\n# 1567 \"lib/read.ml\"\n\n | 4 ->\n# 405 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1572 \"lib/read.ml\"\n\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# 408 \"lib/read.mll\"\n ( () )\n# 1584 \"lib/read.ml\"\n\n | 1 ->\n# 409 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n# 1589 \"lib/read.ml\"\n\n | 2 ->\n# 410 \"lib/read.mll\"\n ( newline v lexbuf; finish_comment v lexbuf )\n# 1594 \"lib/read.ml\"\n\n | 3 ->\n# 411 \"lib/read.mll\"\n ( finish_comment v lexbuf )\n# 1599 \"lib/read.ml\"\n\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# 419 \"lib/read.mll\"\n ( true )\n# 1611 \"lib/read.ml\"\n\n | 1 ->\n# 420 \"lib/read.mll\"\n ( false )\n# 1616 \"lib/read.ml\"\n\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# 423 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n# 1628 \"lib/read.ml\"\n\n | 1 ->\n# 424 \"lib/read.mll\"\n ( finish_comment v lexbuf; read_space v lexbuf )\n# 1633 \"lib/read.ml\"\n\n | 2 ->\n# 425 \"lib/read.mll\"\n ( newline v lexbuf; read_space v lexbuf )\n# 1638 \"lib/read.ml\"\n\n | 3 ->\n# 426 \"lib/read.mll\"\n ( read_space v lexbuf )\n# 1643 \"lib/read.ml\"\n\n | 4 ->\n# 427 \"lib/read.mll\"\n ( () )\n# 1648 \"lib/read.ml\"\n\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# 430 \"lib/read.mll\"\n ( () )\n# 1660 \"lib/read.ml\"\n\n | 1 ->\n# 431 \"lib/read.mll\"\n ( long_error \"Expected 'null' but found\" v lexbuf )\n# 1665 \"lib/read.ml\"\n\n | 2 ->\n# 432 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1670 \"lib/read.ml\"\n\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# 435 \"lib/read.mll\"\n ( true )\n# 1682 \"lib/read.ml\"\n\n | 1 ->\n# 436 \"lib/read.mll\"\n ( false )\n# 1687 \"lib/read.ml\"\n\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# 439 \"lib/read.mll\"\n ( true )\n# 1699 \"lib/read.ml\"\n\n | 1 ->\n# 440 \"lib/read.mll\"\n ( false )\n# 1704 \"lib/read.ml\"\n\n | 2 ->\n# 443 \"lib/read.mll\"\n ( true )\n# 1709 \"lib/read.ml\"\n\n | 3 ->\n# 444 \"lib/read.mll\"\n ( false )\n# 1714 \"lib/read.ml\"\n\n | 4 ->\n# 446 \"lib/read.mll\"\n ( long_error \"Expected 'true' or 'false' but found\" v lexbuf )\n# 1719 \"lib/read.ml\"\n\n | 5 ->\n# 447 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1724 \"lib/read.ml\"\n\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# 450 \"lib/read.mll\"\n ( try extract_positive_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n# 1738 \"lib/read.ml\"\n\n | 1 ->\n# 453 \"lib/read.mll\"\n ( try extract_negative_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf )\n# 1745 \"lib/read.ml\"\n\n | 2 ->\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# 1763 \"lib/read.ml\"\n\n | 3 ->\n# 470 \"lib/read.mll\"\n ( long_error \"Expected integer but found\" v lexbuf )\n# 1768 \"lib/read.ml\"\n\n | 4 ->\n# 471 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1773 \"lib/read.ml\"\n\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# 474 \"lib/read.mll\"\n ( try Int32.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n# 1787 \"lib/read.ml\"\n\n | 1 ->\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# 1805 \"lib/read.ml\"\n\n | 2 ->\n# 491 \"lib/read.mll\"\n ( long_error \"Expected int32 but found\" v lexbuf )\n# 1810 \"lib/read.ml\"\n\n | 3 ->\n# 492 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1815 \"lib/read.ml\"\n\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# 495 \"lib/read.mll\"\n ( try Int64.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf )\n# 1829 \"lib/read.ml\"\n\n | 1 ->\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# 1847 \"lib/read.ml\"\n\n | 2 ->\n# 512 \"lib/read.mll\"\n ( long_error \"Expected int64 but found\" v lexbuf )\n# 1852 \"lib/read.ml\"\n\n | 3 ->\n# 513 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1857 \"lib/read.ml\"\n\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# 516 \"lib/read.mll\"\n ( nan )\n# 1869 \"lib/read.ml\"\n\n | 1 ->\n# 517 \"lib/read.mll\"\n ( infinity )\n# 1874 \"lib/read.ml\"\n\n | 2 ->\n# 518 \"lib/read.mll\"\n ( neg_infinity )\n# 1879 \"lib/read.ml\"\n\n | 3 ->\n# 519 \"lib/read.mll\"\n ( float_of_string (lexeme lexbuf) )\n# 1884 \"lib/read.ml\"\n\n | 4 ->\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# 1906 \"lib/read.ml\"\n\n | 5 ->\n# 538 \"lib/read.mll\"\n ( long_error \"Expected number but found\" v lexbuf )\n# 1911 \"lib/read.ml\"\n\n | 6 ->\n# 539 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1916 \"lib/read.ml\"\n\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# 542 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n# 1929 \"lib/read.ml\"\n\n | 1 ->\n# 544 \"lib/read.mll\"\n ( long_error \"Expected '\\\"' but found\" v lexbuf )\n# 1934 \"lib/read.ml\"\n\n | 2 ->\n# 545 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1939 \"lib/read.ml\"\n\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# 548 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n finish_string v lexbuf )\n# 1952 \"lib/read.ml\"\n\n | 1 ->\nlet\n# 550 \"lib/read.mll\"\n s\n# 1958 \"lib/read.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 551 \"lib/read.mll\"\n ( s )\n# 1962 \"lib/read.ml\"\n\n | 2 ->\n# 552 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n# 1967 \"lib/read.ml\"\n\n | 3 ->\n# 553 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 1972 \"lib/read.ml\"\n\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# 556 \"lib/read.mll\"\n ( Bi_outbuf.clear v.buf;\n map_string v f lexbuf )\n# 1985 \"lib/read.ml\"\n\n | 1 ->\n# 559 \"lib/read.mll\"\n ( map_lexeme f lexbuf )\n# 1990 \"lib/read.ml\"\n\n | 2 ->\n# 560 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n# 1995 \"lib/read.ml\"\n\n | 3 ->\n# 561 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2000 \"lib/read.ml\"\n\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# 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# 2026 \"lib/read.ml\"\n\n | 1 ->\n# 579 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n# 2031 \"lib/read.ml\"\n\n | 2 ->\n# 580 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2036 \"lib/read.ml\"\n\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# 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# 2062 \"lib/read.ml\"\n\n | 1 ->\n# 598 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n# 2067 \"lib/read.ml\"\n\n | 2 ->\n# 599 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2072 \"lib/read.ml\"\n\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# 602 \"lib/read.mll\"\n ( raise End_of_array )\n# 2084 \"lib/read.ml\"\n\n | 1 ->\n# 603 \"lib/read.mll\"\n ( () )\n# 2089 \"lib/read.ml\"\n\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# 606 \"lib/read.mll\"\n ( () )\n# 2101 \"lib/read.ml\"\n\n | 1 ->\n# 607 \"lib/read.mll\"\n ( raise End_of_array )\n# 2106 \"lib/read.ml\"\n\n | 2 ->\n# 608 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n# 2111 \"lib/read.ml\"\n\n | 3 ->\n# 609 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2116 \"lib/read.ml\"\n\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# 613 \"lib/read.mll\"\n (\n #ifdef TUPLE\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 2150 \"lib/read.ml\"\n\n | 1 ->\n# 636 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n# 2155 \"lib/read.ml\"\n\n | 2 ->\n# 637 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2160 \"lib/read.ml\"\n\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# 640 \"lib/read.mll\"\n ( raise End_of_tuple )\n# 2172 \"lib/read.ml\"\n\n | 1 ->\n# 641 \"lib/read.mll\"\n ( () )\n# 2177 \"lib/read.ml\"\n\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# 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# 2192 \"lib/read.ml\"\n\n | 1 ->\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# 2200 \"lib/read.ml\"\n\n | 2 ->\n# 652 \"lib/read.mll\"\n ( () )\n# 2205 \"lib/read.ml\"\n\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# 655 \"lib/read.mll\"\n ( () )\n# 2217 \"lib/read.ml\"\n\n | 1 ->\n# 656 \"lib/read.mll\"\n ( raise End_of_tuple )\n# 2222 \"lib/read.ml\"\n\n | 2 ->\n# 657 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n# 2227 \"lib/read.ml\"\n\n | 3 ->\n# 658 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2232 \"lib/read.ml\"\n\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# 661 \"lib/read.mll\"\n ( () )\n# 2244 \"lib/read.ml\"\n\n | 1 ->\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# 2252 \"lib/read.ml\"\n\n | 2 ->\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# 2260 \"lib/read.ml\"\n\n | 3 ->\n# 670 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n# 2265 \"lib/read.ml\"\n\n | 4 ->\n# 671 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2270 \"lib/read.ml\"\n\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# 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# 2304 \"lib/read.ml\"\n\n | 1 ->\n# 698 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n# 2309 \"lib/read.ml\"\n\n | 2 ->\n# 699 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2314 \"lib/read.ml\"\n\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# 702 \"lib/read.mll\"\n ( () )\n# 2326 \"lib/read.ml\"\n\n | 1 ->\n# 703 \"lib/read.mll\"\n ( long_error \"Expected '{' but found\" v lexbuf )\n# 2331 \"lib/read.ml\"\n\n | 2 ->\n# 704 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2336 \"lib/read.ml\"\n\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# 707 \"lib/read.mll\"\n ( raise End_of_object )\n# 2348 \"lib/read.ml\"\n\n | 1 ->\n# 708 \"lib/read.mll\"\n ( () )\n# 2353 \"lib/read.ml\"\n\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# 711 \"lib/read.mll\"\n ( () )\n# 2365 \"lib/read.ml\"\n\n | 1 ->\n# 712 \"lib/read.mll\"\n ( raise End_of_object )\n# 2370 \"lib/read.ml\"\n\n | 2 ->\n# 713 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n# 2375 \"lib/read.ml\"\n\n | 3 ->\n# 714 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2380 \"lib/read.ml\"\n\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# 717 \"lib/read.mll\"\n ( () )\n# 2392 \"lib/read.ml\"\n\n | 1 ->\n# 718 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n# 2397 \"lib/read.ml\"\n\n | 2 ->\n# 719 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2402 \"lib/read.ml\"\n\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# 722 \"lib/read.mll\"\n ( false )\n# 2414 \"lib/read.ml\"\n\n | 1 ->\n# 723 \"lib/read.mll\"\n ( true )\n# 2419 \"lib/read.ml\"\n\n | 2 ->\n# 724 \"lib/read.mll\"\n ( long_error \"Expected '(' or '[' but found\" v lexbuf )\n# 2424 \"lib/read.ml\"\n\n | 3 ->\n# 725 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2429 \"lib/read.ml\"\n\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# 728 \"lib/read.mll\"\n ( () )\n# 2441 \"lib/read.ml\"\n\n | 1 ->\n# 729 \"lib/read.mll\"\n ( long_error \"Expected '(' but found\" v lexbuf )\n# 2446 \"lib/read.ml\"\n\n | 2 ->\n# 730 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2451 \"lib/read.ml\"\n\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# 733 \"lib/read.mll\"\n ( () )\n# 2463 \"lib/read.ml\"\n\n | 1 ->\n# 734 \"lib/read.mll\"\n ( long_error \"Expected ')' but found\" v lexbuf )\n# 2468 \"lib/read.ml\"\n\n | 2 ->\n# 735 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2473 \"lib/read.ml\"\n\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# 738 \"lib/read.mll\"\n ( () )\n# 2485 \"lib/read.ml\"\n\n | 1 ->\n# 739 \"lib/read.mll\"\n ( long_error \"Expected '[' but found\" v lexbuf )\n# 2490 \"lib/read.ml\"\n\n | 2 ->\n# 740 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2495 \"lib/read.ml\"\n\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# 743 \"lib/read.mll\"\n ( () )\n# 2507 \"lib/read.ml\"\n\n | 1 ->\n# 744 \"lib/read.mll\"\n ( long_error \"Expected ']' but found\" v lexbuf )\n# 2512 \"lib/read.ml\"\n\n | 2 ->\n# 745 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2517 \"lib/read.ml\"\n\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# 751 \"lib/read.mll\"\n ( () )\n# 2529 \"lib/read.ml\"\n\n | 1 ->\n# 752 \"lib/read.mll\"\n ( () )\n# 2534 \"lib/read.ml\"\n\n | 2 ->\n# 753 \"lib/read.mll\"\n ( () )\n# 2539 \"lib/read.ml\"\n\n | 3 ->\n# 754 \"lib/read.mll\"\n ( () )\n# 2544 \"lib/read.ml\"\n\n | 4 ->\n# 755 \"lib/read.mll\"\n ( () )\n# 2549 \"lib/read.ml\"\n\n | 5 ->\n# 756 \"lib/read.mll\"\n ( () )\n# 2554 \"lib/read.ml\"\n\n | 6 ->\n# 757 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n# 2559 \"lib/read.ml\"\n\n | 7 ->\n# 758 \"lib/read.mll\"\n ( () )\n# 2564 \"lib/read.ml\"\n\n | 8 ->\n# 759 \"lib/read.mll\"\n ( () )\n# 2569 \"lib/read.ml\"\n\n | 9 ->\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# 2595 \"lib/read.ml\"\n\n | 10 ->\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# 2613 \"lib/read.ml\"\n\n | 11 ->\n# 799 \"lib/read.mll\"\n (\n #ifdef TUPLE\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 2636 \"lib/read.ml\"\n\n | 12 ->\n# 819 \"lib/read.mll\"\n (\n #ifdef VARIANT\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n finish_skip_variant v lexbuf\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 2650 \"lib/read.ml\"\n\n | 13 ->\n# 830 \"lib/read.mll\"\n ( skip_json v lexbuf )\n# 2655 \"lib/read.ml\"\n\n | 14 ->\n# 831 \"lib/read.mll\"\n ( finish_comment v lexbuf; skip_json v lexbuf )\n# 2660 \"lib/read.ml\"\n\n | 15 ->\n# 832 \"lib/read.mll\"\n ( newline v lexbuf; skip_json v lexbuf )\n# 2665 \"lib/read.ml\"\n\n | 16 ->\n# 833 \"lib/read.mll\"\n ( skip_json v lexbuf )\n# 2670 \"lib/read.ml\"\n\n | 17 ->\n# 834 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2675 \"lib/read.ml\"\n\n | 18 ->\n# 835 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n# 2680 \"lib/read.ml\"\n\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# 841 \"lib/read.mll\"\n ( () )\n# 2692 \"lib/read.ml\"\n\n | 1 ->\n# 842 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n# 2697 \"lib/read.ml\"\n\n | 2 ->\n# 843 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2702 \"lib/read.ml\"\n\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# 846 \"lib/read.mll\"\n ( skip_json v lexbuf;\n read_space v lexbuf;\n read_gt v lexbuf )\n# 2716 \"lib/read.ml\"\n\n | 1 ->\n# 849 \"lib/read.mll\"\n ( () )\n# 2721 \"lib/read.ml\"\n\n | 2 ->\n# 850 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n# 2726 \"lib/read.ml\"\n\n | 3 ->\n# 851 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2731 \"lib/read.ml\"\n\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# 854 \"lib/read.mll\"\n ( finish_skip_stringlit v lexbuf )\n# 2743 \"lib/read.ml\"\n\n | 1 ->\n# 855 \"lib/read.mll\"\n ( () )\n# 2748 \"lib/read.ml\"\n\n | 2 ->\n# 856 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n# 2753 \"lib/read.ml\"\n\n | 3 ->\n# 857 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2758 \"lib/read.ml\"\n\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# 870 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n# 2770 \"lib/read.ml\"\n\n | 1 ->\n# 872 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n# 2775 \"lib/read.ml\"\n\n | 2 ->\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# 2802 \"lib/read.ml\"\n\n | 3 ->\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# 2821 \"lib/read.ml\"\n\n | 4 ->\n# 913 \"lib/read.mll\"\n (\n #ifdef TUPLE\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 2845 \"lib/read.ml\"\n\n | 5 ->\n# 934 \"lib/read.mll\"\n (\n #ifdef VARIANT\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n )\n# 2860 \"lib/read.ml\"\n\n | 6 ->\n# 946 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n# 2865 \"lib/read.ml\"\n\n | 7 ->\n# 947 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_json v lexbuf )\n# 2872 \"lib/read.ml\"\n\n | 8 ->\n# 950 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_json v lexbuf )\n# 2879 \"lib/read.ml\"\n\n | 9 ->\n# 953 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; buffer_json v lexbuf )\n# 2884 \"lib/read.ml\"\n\n | 10 ->\n# 954 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2889 \"lib/read.ml\"\n\n | 11 ->\n# 955 \"lib/read.mll\"\n ( long_error \"Invalid token\" v lexbuf )\n# 2894 \"lib/read.ml\"\n\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# 961 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\"';\n add_lexeme v.buf lexbuf\n )\n# 2908 \"lib/read.ml\"\n\n | 1 ->\n# 964 \"lib/read.mll\"\n ( long_error \"Invalid string literal\" v lexbuf )\n# 2913 \"lib/read.ml\"\n\n | 2 ->\n# 965 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2918 \"lib/read.ml\"\n\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# 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# 2933 \"lib/read.ml\"\n\n | 1 ->\n# 972 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n# 2938 \"lib/read.ml\"\n\n | 2 ->\n# 973 \"lib/read.mll\"\n ( long_error \"Expected ':' or '>' but found\" v lexbuf )\n# 2943 \"lib/read.ml\"\n\n | 3 ->\n# 974 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2948 \"lib/read.ml\"\n\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# 977 \"lib/read.mll\"\n ( finish_buffer_stringlit v lexbuf )\n# 2960 \"lib/read.ml\"\n\n | 1 ->\n# 978 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf )\n# 2965 \"lib/read.ml\"\n\n | 2 ->\n# 979 \"lib/read.mll\"\n ( long_error \"Expected string or identifier but found\" v lexbuf )\n# 2970 \"lib/read.ml\"\n\n | 3 ->\n# 980 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 2975 \"lib/read.ml\"\n\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# 983 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n newline v lexbuf;\n buffer_space v lexbuf )\n# 2990 \"lib/read.ml\"\n\n | 1 ->\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# 2998 \"lib/read.ml\"\n\n | 2 ->\n# 991 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_space v lexbuf )\n# 3006 \"lib/read.ml\"\n\n | 3 ->\n# 995 \"lib/read.mll\"\n (\n add_lexeme v.buf lexbuf;\n buffer_space v lexbuf )\n# 3013 \"lib/read.ml\"\n\n | 4 ->\n# 998 \"lib/read.mll\"\n ( () )\n# 3018 \"lib/read.ml\"\n\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# 1001 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf '}';\n raise End_of_object )\n# 3032 \"lib/read.ml\"\n\n | 1 ->\n# 1004 \"lib/read.mll\"\n ( () )\n# 3037 \"lib/read.ml\"\n\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# 1007 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n# 3049 \"lib/read.ml\"\n\n | 1 ->\n# 1008 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '}'; raise End_of_object )\n# 3054 \"lib/read.ml\"\n\n | 2 ->\n# 1009 \"lib/read.mll\"\n ( long_error \"Expected ',' or '}' but found\" v lexbuf )\n# 3059 \"lib/read.ml\"\n\n | 3 ->\n# 1010 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 3064 \"lib/read.ml\"\n\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# 1013 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n# 3076 \"lib/read.ml\"\n\n | 1 ->\n# 1014 \"lib/read.mll\"\n ( () )\n# 3081 \"lib/read.ml\"\n\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# 1017 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n# 3093 \"lib/read.ml\"\n\n | 1 ->\n# 1018 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ']'; raise End_of_array )\n# 3098 \"lib/read.ml\"\n\n | 2 ->\n# 1019 \"lib/read.mll\"\n ( long_error \"Expected ',' or ']' but found\" v lexbuf )\n# 3103 \"lib/read.ml\"\n\n | 3 ->\n# 1020 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 3108 \"lib/read.ml\"\n\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# 1023 \"lib/read.mll\"\n (\n Bi_outbuf.add_char v.buf ')';\n raise End_of_tuple )\n# 3122 \"lib/read.ml\"\n\n | 1 ->\n# 1026 \"lib/read.mll\"\n ( () )\n# 3127 \"lib/read.ml\"\n\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# 1029 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ',' )\n# 3139 \"lib/read.ml\"\n\n | 1 ->\n# 1030 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ')'; raise End_of_tuple )\n# 3144 \"lib/read.ml\"\n\n | 2 ->\n# 1031 \"lib/read.mll\"\n ( long_error \"Expected ',' or ')' but found\" v lexbuf )\n# 3149 \"lib/read.ml\"\n\n | 3 ->\n# 1032 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 3154 \"lib/read.ml\"\n\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# 1035 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf ':' )\n# 3166 \"lib/read.ml\"\n\n | 1 ->\n# 1036 \"lib/read.mll\"\n ( long_error \"Expected ':' but found\" v lexbuf )\n# 3171 \"lib/read.ml\"\n\n | 2 ->\n# 1037 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 3176 \"lib/read.ml\"\n\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# 1040 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '>' )\n# 3188 \"lib/read.ml\"\n\n | 1 ->\n# 1041 \"lib/read.mll\"\n ( long_error \"Expected '>' but found\" v lexbuf )\n# 3193 \"lib/read.ml\"\n\n | 2 ->\n# 1042 \"lib/read.mll\"\n ( custom_error \"Unexpected end of input\" v lexbuf )\n# 3198 \"lib/read.ml\"\n\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# 1045 \"lib/read.mll\"\n ( Bi_outbuf.add_string v.buf \"*/\" )\n# 3210 \"lib/read.ml\"\n\n | 1 ->\n# 1046 \"lib/read.mll\"\n ( long_error \"Unterminated comment\" v lexbuf )\n# 3215 \"lib/read.ml\"\n\n | 2 ->\n# 1047 \"lib/read.mll\"\n ( Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n finish_buffer_comment v lexbuf )\n# 3222 \"lib/read.ml\"\n\n | 3 ->\n# 1050 \"lib/read.mll\"\n ( add_lexeme v.buf lexbuf; finish_buffer_comment v lexbuf )\n# 3227 \"lib/read.ml\"\n\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# 1053 \"lib/read.mll\"\n ( Lexing.lexeme lexbuf )\n# 3239 \"lib/read.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_junk_rec lexbuf __ocaml_lex_state\n\n;;\n\n# 1055 \"lib/read.mll\"\n \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# 3411 \"lib/read.ml\"\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","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 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 (* it would be better to use `with_all_version_tags` on just\n the module where we need a version tag, but that doesn't\n (yet) work with %%versioned_binable\n *)\n [@@@with_top_version_tag]\n\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 Bounded_types.String.Of_stringable (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","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","#2 \"utils/config.mlp\"\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 main OCaml version string has moved to ../build-aux/ocaml_version.m4 *)\nlet version = Sys.ocaml_version\n\nlet bindir = \"%%BINDIR%%\"\n\nlet standard_library_default = \"%%LIBDIR%%\"\n\nlet standard_library =\n try\n Sys.getenv \"OCAMLLIB\"\n with Not_found ->\n try\n Sys.getenv \"CAMLLIB\"\n with Not_found ->\n standard_library_default\n\nlet ccomp_type = \"%%CCOMPTYPE%%\"\nlet c_compiler = \"%%CC%%\"\nlet c_output_obj = \"%%OUTPUTOBJ%%\"\nlet c_has_debug_prefix_map = %%CC_HAS_DEBUG_PREFIX_MAP%%\nlet as_has_debug_prefix_map = %%AS_HAS_DEBUG_PREFIX_MAP%%\nlet ocamlc_cflags = \"%%OCAMLC_CFLAGS%%\"\nlet ocamlc_cppflags = \"%%OCAMLC_CPPFLAGS%%\"\n(* #7678: ocamlopt uses these only to compile .c files, and the behaviour for\n the two drivers should be identical. *)\nlet ocamlopt_cflags = \"%%OCAMLC_CFLAGS%%\"\nlet ocamlopt_cppflags = \"%%OCAMLOPT_CPPFLAGS%%\"\nlet bytecomp_c_libraries = \"%%BYTECCLIBS%%\"\n(* bytecomp_c_compiler and native_c_compiler have been supported for a\n long time and are retained for backwards compatibility.\n For programs that don't need compatibility with older OCaml releases\n the recommended approach is to use the constituent variables\n c_compiler, ocamlc_cflags, ocamlc_cppflags etc., directly.\n*)\nlet bytecomp_c_compiler =\n c_compiler ^ \" \" ^ ocamlc_cflags ^ \" \" ^ ocamlc_cppflags\nlet native_c_compiler =\n c_compiler ^ \" \" ^ ocamlopt_cflags ^ \" \" ^ ocamlopt_cppflags\nlet native_c_libraries = \"%%NATIVECCLIBS%%\"\nlet native_pack_linker = \"%%PACKLD%%\"\nlet ranlib = \"%%RANLIBCMD%%\"\nlet default_rpath = \"%%RPATH%%\"\nlet mksharedlibrpath = \"%%MKSHAREDLIBRPATH%%\"\nlet ar = \"%%ARCMD%%\"\nlet supports_shared_libraries = %%SUPPORTS_SHARED_LIBRARIES%%\nlet mkdll, mkexe, mkmaindll =\n (* @@DRA Cygwin - but only if shared libraries are enabled, which we\n should be able to detect? *)\n if Sys.win32 || Sys.cygwin && supports_shared_libraries then\n try\n let flexlink =\n let flexlink = Sys.getenv \"OCAML_FLEXLINK\" in\n let f i =\n let c = flexlink.[i] in\n if c = '/' && Sys.win32 then '\\\\' else c in\n (String.init (String.length flexlink) f) ^ \" %%FLEXLINK_FLAGS%%\" in\n flexlink ^ \"%%FLEXLINK_DLL_LDFLAGS%%\",\n flexlink ^ \" -exe%%FLEXLINK_LDFLAGS%%\",\n flexlink ^ \" -maindll%%FLEXLINK_DLL_LDFLAGS%%\"\n with Not_found ->\n \"%%MKDLL%%\", \"%%MKEXE%%\", \"%%MKMAINDLL%%\"\n else\n \"%%MKDLL%%\", \"%%MKEXE%%\", \"%%MKMAINDLL%%\"\n\nlet flambda = %%FLAMBDA%%\nlet with_flambda_invariants = %%WITH_FLAMBDA_INVARIANTS%%\nlet with_cmm_invariants = %%WITH_CMM_INVARIANTS%%\nlet safe_string = %%FORCE_SAFE_STRING%%\nlet default_safe_string = %%DEFAULT_SAFE_STRING%%\nlet windows_unicode = %%WINDOWS_UNICODE%% != 0\nlet naked_pointers = %%NAKED_POINTERS%%\n\nlet flat_float_array = %%FLAT_FLOAT_ARRAY%%\n\nlet function_sections = %%FUNCTION_SECTIONS%%\nlet afl_instrument = %%AFL_INSTRUMENT%%\n\nlet exec_magic_number = \"Caml1999X031\"\n (* exec_magic_number is duplicated in runtime/caml/exec.h *)\nand cmi_magic_number = \"Caml1999I031\"\nand cmo_magic_number = \"Caml1999O031\"\nand cma_magic_number = \"Caml1999A031\"\nand cmx_magic_number =\n if flambda then\n \"Caml1999y031\"\n else\n \"Caml1999Y031\"\nand cmxa_magic_number =\n if flambda then\n \"Caml1999z031\"\n else\n \"Caml1999Z031\"\nand ast_impl_magic_number = \"Caml1999M031\"\nand ast_intf_magic_number = \"Caml1999N031\"\nand cmxs_magic_number = \"Caml1999D031\"\nand cmt_magic_number = \"Caml1999T031\"\nand linear_magic_number = \"Caml1999L031\"\n\nlet interface_suffix = ref \".mli\"\n\nlet max_tag = 245\n(* This is normally the same as in obj.ml, but we have to define it\n separately because it can differ when we're in the middle of a\n bootstrapping phase. *)\nlet lazy_tag = 246\n\nlet max_young_wosize = 256\nlet stack_threshold = 256 (* see runtime/caml/config.h *)\nlet stack_safety_margin = 60\n\nlet architecture = \"%%ARCH%%\"\nlet model = \"%%MODEL%%\"\nlet system = \"%%SYSTEM%%\"\n\nlet asm = \"%%ASM%%\"\nlet asm_cfi_supported = %%ASM_CFI_SUPPORTED%%\nlet with_frame_pointers = %%WITH_FRAME_POINTERS%%\nlet profinfo = %%WITH_PROFINFO%%\nlet profinfo_width = %%PROFINFO_WIDTH%%\n\nlet ext_exe = \"%%EXE%%\"\nlet ext_obj = \"%%EXT_OBJ%%\"\nlet ext_asm = \"%%EXT_ASM%%\"\nlet ext_lib = \"%%EXT_LIB%%\"\nlet ext_dll = \"%%EXT_DLL%%\"\n\nlet host = \"%%HOST%%\"\nlet target = \"%%TARGET%%\"\n\nlet default_executable_name =\n match Sys.os_type with\n \"Unix\" -> \"a.out\"\n | \"Win32\" | \"Cygwin\" -> \"camlprog.exe\"\n | _ -> \"camlprog\"\n\nlet systhread_supported = %%SYSTHREAD_SUPPORT%%;;\n\nlet flexdll_dirs = [%%FLEXDLL_DIR%%];;\n\ntype configuration_value =\n | String of string\n | Int of int\n | Bool of bool\n\nlet configuration_variables =\n let p x v = (x, String v) in\n let p_int x v = (x, Int v) in\n let p_bool x v = (x, Bool v) in\n[\n p \"version\" version;\n p \"standard_library_default\" standard_library_default;\n p \"standard_library\" standard_library;\n p \"ccomp_type\" ccomp_type;\n p \"c_compiler\" c_compiler;\n p \"ocamlc_cflags\" ocamlc_cflags;\n p \"ocamlc_cppflags\" ocamlc_cppflags;\n p \"ocamlopt_cflags\" ocamlopt_cflags;\n p \"ocamlopt_cppflags\" ocamlopt_cppflags;\n p \"bytecomp_c_compiler\" bytecomp_c_compiler;\n p \"native_c_compiler\" native_c_compiler;\n p \"bytecomp_c_libraries\" bytecomp_c_libraries;\n p \"native_c_libraries\" native_c_libraries;\n p \"native_pack_linker\" native_pack_linker;\n p \"ranlib\" ranlib;\n p \"architecture\" architecture;\n p \"model\" model;\n p_int \"int_size\" Sys.int_size;\n p_int \"word_size\" Sys.word_size;\n p \"system\" system;\n p \"asm\" asm;\n p_bool \"asm_cfi_supported\" asm_cfi_supported;\n p_bool \"with_frame_pointers\" with_frame_pointers;\n p \"ext_exe\" ext_exe;\n p \"ext_obj\" ext_obj;\n p \"ext_asm\" ext_asm;\n p \"ext_lib\" ext_lib;\n p \"ext_dll\" ext_dll;\n p \"os_type\" Sys.os_type;\n p \"default_executable_name\" default_executable_name;\n p_bool \"systhread_supported\" systhread_supported;\n p \"host\" host;\n p \"target\" target;\n p_bool \"flambda\" flambda;\n p_bool \"safe_string\" safe_string;\n p_bool \"default_safe_string\" default_safe_string;\n p_bool \"flat_float_array\" flat_float_array;\n p_bool \"function_sections\" function_sections;\n p_bool \"afl_instrument\" afl_instrument;\n p_bool \"windows_unicode\" windows_unicode;\n p_bool \"supports_shared_libraries\" supports_shared_libraries;\n p_bool \"naked_pointers\" naked_pointers;\n\n p \"exec_magic_number\" exec_magic_number;\n p \"cmi_magic_number\" cmi_magic_number;\n p \"cmo_magic_number\" cmo_magic_number;\n p \"cma_magic_number\" cma_magic_number;\n p \"cmx_magic_number\" cmx_magic_number;\n p \"cmxa_magic_number\" cmxa_magic_number;\n p \"ast_impl_magic_number\" ast_impl_magic_number;\n p \"ast_intf_magic_number\" ast_intf_magic_number;\n p \"cmxs_magic_number\" cmxs_magic_number;\n p \"cmt_magic_number\" cmt_magic_number;\n p \"linear_magic_number\" linear_magic_number;\n]\n\nlet print_config_value oc = function\n | String s ->\n Printf.fprintf oc \"%s\" s\n | Int n ->\n Printf.fprintf oc \"%d\" n\n | Bool p ->\n Printf.fprintf oc \"%B\" p\n\nlet print_config oc =\n let print (x, v) =\n Printf.fprintf oc \"%s: %a\\n\" x print_config_value v in\n List.iter print configuration_variables;\n flush oc;\n;;\n\nlet config_var x =\n match List.assoc_opt x configuration_variables with\n | None -> None\n | Some v ->\n let s = match v with\n | String s -> s\n | Int n -> Int.to_string n\n | Bool b -> string_of_bool b\n in\n Some s\n\nlet merlin = false\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(* Errors *)\n\nexception Fatal_error\n\nlet fatal_errorf fmt =\n Format.kfprintf\n (fun _ -> raise Fatal_error)\n Format.err_formatter\n (\"@?>> Fatal error: \" ^^ fmt ^^ \"@.\")\n\nlet fatal_error msg = fatal_errorf \"%s\" msg\n\n(* Exceptions *)\n\nlet try_finally ?(always=(fun () -> ())) ?(exceptionally=(fun () -> ())) work =\n match work () with\n | result ->\n begin match always () with\n | () -> result\n | exception always_exn ->\n let always_bt = Printexc.get_raw_backtrace () in\n exceptionally ();\n Printexc.raise_with_backtrace always_exn always_bt\n end\n | exception work_exn ->\n let work_bt = Printexc.get_raw_backtrace () in\n begin match always () with\n | () ->\n exceptionally ();\n Printexc.raise_with_backtrace work_exn work_bt\n | exception always_exn ->\n let always_bt = Printexc.get_raw_backtrace () in\n exceptionally ();\n Printexc.raise_with_backtrace always_exn always_bt\n end\n\nlet reraise_preserving_backtrace e f =\n let bt = Printexc.get_raw_backtrace () in\n f ();\n Printexc.raise_with_backtrace e bt\n\ntype ref_and_value = R : 'a ref * 'a -> ref_and_value\n\nlet protect_refs =\n let set_refs l = List.iter (fun (R (r, v)) -> r := v) l in\n fun refs f ->\n let backup = List.map (fun (R (r, _)) -> R (r, !r)) refs in\n set_refs refs;\n Fun.protect ~finally:(fun () -> set_refs backup) f\n\n(* List functions *)\n\nlet rec map_end f l1 l2 =\n match l1 with\n [] -> l2\n | hd::tl -> f hd :: map_end f tl l2\n\nlet rec map_left_right f = function\n [] -> []\n | hd::tl -> let res = f hd in res :: map_left_right f tl\n\nlet rec for_all2 pred l1 l2 =\n match (l1, l2) with\n ([], []) -> true\n | (hd1::tl1, hd2::tl2) -> pred hd1 hd2 && for_all2 pred tl1 tl2\n | (_, _) -> false\n\nlet rec replicate_list elem n =\n if n <= 0 then [] else elem :: replicate_list elem (n-1)\n\nlet rec list_remove x = function\n [] -> []\n | hd :: tl ->\n if hd = x then tl else hd :: list_remove x tl\n\nlet rec split_last = function\n [] -> assert false\n | [x] -> ([], x)\n | hd :: tl ->\n let (lst, last) = split_last tl in\n (hd :: lst, last)\n\nmodule Stdlib = struct\n module List = struct\n type 'a t = 'a list\n\n let rec compare cmp l1 l2 =\n match l1, l2 with\n | [], [] -> 0\n | [], _::_ -> -1\n | _::_, [] -> 1\n | h1::t1, h2::t2 ->\n let c = cmp h1 h2 in\n if c <> 0 then c\n else compare cmp t1 t2\n\n let rec equal eq l1 l2 =\n match l1, l2 with\n | ([], []) -> true\n | (hd1 :: tl1, hd2 :: tl2) -> eq hd1 hd2 && equal eq tl1 tl2\n | (_, _) -> false\n\n let map2_prefix f l1 l2 =\n let rec aux acc l1 l2 =\n match l1, l2 with\n | [], _ -> (List.rev acc, l2)\n | _ :: _, [] -> raise (Invalid_argument \"map2_prefix\")\n | h1::t1, h2::t2 ->\n let h = f h1 h2 in\n aux (h :: acc) t1 t2\n in\n aux [] l1 l2\n\n let some_if_all_elements_are_some l =\n let rec aux acc l =\n match l with\n | [] -> Some (List.rev acc)\n | None :: _ -> None\n | Some h :: t -> aux (h :: acc) t\n in\n aux [] l\n\n let split_at n l =\n let rec aux n acc l =\n if n = 0\n then List.rev acc, l\n else\n match l with\n | [] -> raise (Invalid_argument \"split_at\")\n | t::q -> aux (n-1) (t::acc) q\n in\n aux n [] l\n\n let rec is_prefix ~equal t ~of_ =\n match t, of_ with\n | [], [] -> true\n | _::_, [] -> false\n | [], _::_ -> true\n | x1::t, x2::of_ -> equal x1 x2 && is_prefix ~equal t ~of_\n\n type 'a longest_common_prefix_result = {\n longest_common_prefix : 'a list;\n first_without_longest_common_prefix : 'a list;\n second_without_longest_common_prefix : 'a list;\n }\n\n let find_and_chop_longest_common_prefix ~equal ~first ~second =\n let rec find_prefix ~longest_common_prefix_rev l1 l2 =\n match l1, l2 with\n | elt1 :: l1, elt2 :: l2 when equal elt1 elt2 ->\n let longest_common_prefix_rev = elt1 :: longest_common_prefix_rev in\n find_prefix ~longest_common_prefix_rev l1 l2\n | l1, l2 ->\n { longest_common_prefix = List.rev longest_common_prefix_rev;\n first_without_longest_common_prefix = l1;\n second_without_longest_common_prefix = l2;\n }\n in\n find_prefix ~longest_common_prefix_rev:[] first second\n end\n\n module Option = struct\n type 'a t = 'a option\n\n let print print_contents ppf t =\n match t with\n | None -> Format.pp_print_string ppf \"None\"\n | Some contents ->\n Format.fprintf ppf \"@[(Some@ %a)@]\" print_contents contents\n end\n\n module Array = struct\n let exists2 p a1 a2 =\n let n = Array.length a1 in\n if Array.length a2 <> n then invalid_arg \"Misc.Stdlib.Array.exists2\";\n let rec loop i =\n if i = n then false\n else if p (Array.unsafe_get a1 i) (Array.unsafe_get a2 i) then true\n else loop (succ i) in\n loop 0\n\n let for_alli p a =\n let n = Array.length a in\n let rec loop i =\n if i = n then true\n else if p i (Array.unsafe_get a i) then loop (succ i)\n else false in\n loop 0\n\n let all_somes a =\n try\n Some (Array.map (function None -> raise_notrace Exit | Some x -> x) a)\n with\n | Exit -> None\n end\n\n module String = struct\n include String\n module Set = Set.Make(String)\n module Map = Map.Make(String)\n module Tbl = Hashtbl.Make(struct\n include String\n let hash = Hashtbl.hash\n end)\n\n let for_all f t =\n let len = String.length t in\n let rec loop i =\n i = len || (f t.[i] && loop (i + 1))\n in\n loop 0\n\n let print ppf t =\n Format.pp_print_string ppf t\n end\n\n external compare : 'a -> 'a -> int = \"%compare\"\nend\n\n(* File functions *)\n\nlet find_in_path path name =\n if not (Filename.is_implicit name) then\n if Sys.file_exists name then name else raise Not_found\n else begin\n let rec try_dir = function\n [] -> raise Not_found\n | dir::rem ->\n let fullname = Filename.concat dir name in\n if Sys.file_exists fullname then fullname else try_dir rem\n in try_dir path\n end\n\nlet find_in_path_rel path name =\n let rec simplify s =\n let open Filename in\n let base = basename s in\n let dir = dirname s in\n if dir = s then dir\n else if base = current_dir_name then simplify dir\n else concat (simplify dir) base\n in\n let rec try_dir = function\n [] -> raise Not_found\n | dir::rem ->\n let fullname = simplify (Filename.concat dir name) in\n if Sys.file_exists fullname then fullname else try_dir rem\n in try_dir path\n\nlet find_in_path_uncap path name =\n let uname = String.uncapitalize_ascii name in\n let rec try_dir = function\n [] -> raise Not_found\n | dir::rem ->\n let fullname = Filename.concat dir name\n and ufullname = Filename.concat dir uname in\n if Sys.file_exists ufullname then ufullname\n else if Sys.file_exists fullname then fullname\n else try_dir rem\n in try_dir path\n\nlet remove_file filename =\n try\n if Sys.file_exists filename\n then Sys.remove filename\n with Sys_error _msg ->\n ()\n\n(* Expand a -I option: if it starts with +, make it relative to the standard\n library directory *)\n\nlet expand_directory alt s =\n if String.length s > 0 && s.[0] = '+'\n then Filename.concat alt\n (String.sub s 1 (String.length s - 1))\n else s\n\nlet path_separator =\n match Sys.os_type with\n | \"Win32\" -> ';'\n | _ -> ':'\n\nlet split_path_contents ?(sep = path_separator) = function\n | \"\" -> []\n | s -> String.split_on_char sep s\n\n(* Hashtable functions *)\n\nlet create_hashtable size init =\n let tbl = Hashtbl.create size in\n List.iter (fun (key, data) -> Hashtbl.add tbl key data) init;\n tbl\n\n(* File copy *)\n\nlet copy_file ic oc =\n let buff = Bytes.create 0x1000 in\n let rec copy () =\n let n = input ic buff 0 0x1000 in\n if n = 0 then () else (output oc buff 0 n; copy())\n in copy()\n\nlet copy_file_chunk ic oc len =\n let buff = Bytes.create 0x1000 in\n let rec copy n =\n if n <= 0 then () else begin\n let r = input ic buff 0 (Int.min n 0x1000) in\n if r = 0 then raise End_of_file else (output oc buff 0 r; copy(n-r))\n end\n in copy len\n\nlet string_of_file ic =\n let b = Buffer.create 0x10000 in\n let buff = Bytes.create 0x1000 in\n let rec copy () =\n let n = input ic buff 0 0x1000 in\n if n = 0 then Buffer.contents b else\n (Buffer.add_subbytes b buff 0 n; copy())\n in copy()\n\nlet output_to_file_via_temporary ?(mode = [Open_text]) filename fn =\n let (temp_filename, oc) =\n Filename.open_temp_file\n ~mode ~perms:0o666 ~temp_dir:(Filename.dirname filename)\n (Filename.basename filename) \".tmp\" in\n (* The 0o666 permissions will be modified by the umask. It's just\n like what [open_out] and [open_out_bin] do.\n With temp_dir = dirname filename, we ensure that the returned\n temp file is in the same directory as filename itself, making\n it safe to rename temp_filename to filename later.\n With prefix = basename filename, we are almost certain that\n the first generated name will be unique. A fixed prefix\n would work too but might generate more collisions if many\n files are being produced simultaneously in the same directory. *)\n match fn temp_filename oc with\n | res ->\n close_out oc;\n begin try\n Sys.rename temp_filename filename; res\n with exn ->\n remove_file temp_filename; raise exn\n end\n | exception exn ->\n close_out oc; remove_file temp_filename; raise exn\n\nlet protect_writing_to_file ~filename ~f =\n let outchan = open_out_bin filename in\n try_finally ~always:(fun () -> close_out outchan)\n ~exceptionally:(fun () -> remove_file filename)\n (fun () -> f outchan)\n\n(* Integer operations *)\n\nlet rec log2 n =\n if n <= 1 then 0 else 1 + log2(n asr 1)\n\nlet align n a =\n if n >= 0 then (n + a - 1) land (-a) else n land (-a)\n\nlet no_overflow_add a b = (a lxor b) lor (a lxor (lnot (a+b))) < 0\n\nlet no_overflow_sub a b = (a lxor (lnot b)) lor (b lxor (a-b)) < 0\n\n(* Taken from Hacker's Delight, chapter \"Overflow Detection\" *)\nlet no_overflow_mul a b =\n not ((a = min_int && b < 0) || (b <> 0 && (a * b) / b <> a))\n\nlet no_overflow_lsl a k =\n 0 <= k && k < Sys.word_size - 1 && min_int asr k <= a && a <= max_int asr k\n\nmodule Int_literal_converter = struct\n (* To convert integer literals, allowing max_int + 1 (PR#4210) *)\n let cvt_int_aux str neg of_string =\n if String.length str = 0 || str.[0]= '-'\n then of_string str\n else neg (of_string (\"-\" ^ str))\n let int s = cvt_int_aux s (~-) int_of_string\n let int32 s = cvt_int_aux s Int32.neg Int32.of_string\n let int64 s = cvt_int_aux s Int64.neg Int64.of_string\n let nativeint s = cvt_int_aux s Nativeint.neg Nativeint.of_string\nend\n\n(* String operations *)\n\nlet chop_extensions file =\n let dirname = Filename.dirname file and basename = Filename.basename file in\n try\n let pos = String.index basename '.' in\n let basename = String.sub basename 0 pos in\n if Filename.is_implicit file && dirname = Filename.current_dir_name then\n basename\n else\n Filename.concat dirname basename\n with Not_found -> file\n\nlet search_substring pat str start =\n let rec search i j =\n if j >= String.length pat then i\n else if i + j >= String.length str then raise Not_found\n else if str.[i + j] = pat.[j] then search i (j+1)\n else search (i+1) 0\n in search start 0\n\nlet replace_substring ~before ~after str =\n let rec search acc curr =\n match search_substring before str curr with\n | next ->\n let prefix = String.sub str curr (next - curr) in\n search (prefix :: acc) (next + String.length before)\n | exception Not_found ->\n let suffix = String.sub str curr (String.length str - curr) in\n List.rev (suffix :: acc)\n in String.concat after (search [] 0)\n\nlet rev_split_words s =\n let rec split1 res i =\n if i >= String.length s then res else begin\n match s.[i] with\n ' ' | '\\t' | '\\r' | '\\n' -> split1 res (i+1)\n | _ -> split2 res i (i+1)\n end\n and split2 res i j =\n if j >= String.length s then String.sub s i (j-i) :: res else begin\n match s.[j] with\n ' ' | '\\t' | '\\r' | '\\n' -> split1 (String.sub s i (j-i) :: res) (j+1)\n | _ -> split2 res i (j+1)\n end\n in split1 [] 0\n\nlet get_ref r =\n let v = !r in\n r := []; v\n\nlet set_or_ignore f opt x =\n match f x with\n | None -> ()\n | Some y -> opt := Some y\n\nlet fst3 (x, _, _) = x\nlet snd3 (_,x,_) = x\nlet thd3 (_,_,x) = x\n\nlet fst4 (x, _, _, _) = x\nlet snd4 (_,x,_, _) = x\nlet thd4 (_,_,x,_) = x\nlet for4 (_,_,_,x) = x\n\n\nmodule LongString = struct\n type t = bytes array\n\n let create str_size =\n let tbl_size = str_size / Sys.max_string_length + 1 in\n let tbl = Array.make tbl_size Bytes.empty in\n for i = 0 to tbl_size - 2 do\n tbl.(i) <- Bytes.create Sys.max_string_length;\n done;\n tbl.(tbl_size - 1) <- Bytes.create (str_size mod Sys.max_string_length);\n tbl\n\n let length tbl =\n let tbl_size = Array.length tbl in\n Sys.max_string_length * (tbl_size - 1) + Bytes.length tbl.(tbl_size - 1)\n\n let get tbl ind =\n Bytes.get tbl.(ind / Sys.max_string_length) (ind mod Sys.max_string_length)\n\n let set tbl ind c =\n Bytes.set tbl.(ind / Sys.max_string_length) (ind mod Sys.max_string_length)\n c\n\n let blit src srcoff dst dstoff len =\n for i = 0 to len - 1 do\n set dst (dstoff + i) (get src (srcoff + i))\n done\n\n let blit_string src srcoff dst dstoff len =\n for i = 0 to len - 1 do\n set dst (dstoff + i) (String.get src (srcoff + i))\n done\n\n let output oc tbl pos len =\n for i = pos to pos + len - 1 do\n output_char oc (get tbl i)\n done\n\n let input_bytes_into tbl ic len =\n let count = ref len in\n Array.iter (fun str ->\n let chunk = Int.min !count (Bytes.length str) in\n really_input ic str 0 chunk;\n count := !count - chunk) tbl\n\n let input_bytes ic len =\n let tbl = create len in\n input_bytes_into tbl ic len;\n tbl\nend\n\n\nlet edit_distance a b cutoff =\n let la, lb = String.length a, String.length b in\n let cutoff =\n (* using max_int for cutoff would cause overflows in (i + cutoff + 1);\n we bring it back to the (max la lb) worstcase *)\n Int.min (Int.max la lb) cutoff in\n if abs (la - lb) > cutoff then None\n else begin\n (* initialize with 'cutoff + 1' so that not-yet-written-to cases have\n the worst possible cost; this is useful when computing the cost of\n a case just at the boundary of the cutoff diagonal. *)\n let m = Array.make_matrix (la + 1) (lb + 1) (cutoff + 1) in\n m.(0).(0) <- 0;\n for i = 1 to la do\n m.(i).(0) <- i;\n done;\n for j = 1 to lb do\n m.(0).(j) <- j;\n done;\n for i = 1 to la do\n for j = Int.max 1 (i - cutoff - 1) to Int.min lb (i + cutoff + 1) do\n let cost = if a.[i-1] = b.[j-1] then 0 else 1 in\n let best =\n (* insert, delete or substitute *)\n Int.min (1 + Int.min m.(i-1).(j) m.(i).(j-1)) (m.(i-1).(j-1) + cost)\n in\n let best =\n (* swap two adjacent letters; we use \"cost\" again in case of\n a swap between two identical letters; this is slightly\n redundant as this is a double-substitution case, but it\n was done this way in most online implementations and\n imitation has its virtues *)\n if not (i > 1 && j > 1 && a.[i-1] = b.[j-2] && a.[i-2] = b.[j-1])\n then best\n else Int.min best (m.(i-2).(j-2) + cost)\n in\n m.(i).(j) <- best\n done;\n done;\n let result = m.(la).(lb) in\n if result > cutoff\n then None\n else Some result\n end\n\nlet spellcheck env 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 compare target acc head =\n match edit_distance target head cutoff with\n | None -> acc\n | Some dist ->\n let (best_choice, best_dist) = acc in\n if dist < best_dist then ([head], dist)\n else if dist = best_dist then (head :: best_choice, dist)\n else acc\n in\n let env = List.sort_uniq (fun s1 s2 -> String.compare s2 s1) env in\n fst (List.fold_left (compare name) ([], max_int) env)\n\nlet did_you_mean ppf get_choices =\n (* flush now to get the error report early, in the (unheard of) case\n where the search in the get_choices function would take a bit of\n time; in the worst case, the user has seen the error, she can\n interrupt the process before the spell-checking terminates. *)\n Format.fprintf ppf \"@?\";\n match get_choices () with\n | [] -> ()\n | choices ->\n let rest, last = split_last choices in\n Format.fprintf ppf \"@\\nHint: Did you mean %s%s%s?@?\"\n (String.concat \", \" rest)\n (if rest = [] then \"\" else \" or \")\n last\n\nlet cut_at s c =\n let pos = String.index s c in\n String.sub s 0 pos, String.sub s (pos+1) (String.length s - pos - 1)\n\nlet ordinal_suffix n =\n let teen = (n mod 100)/10 = 1 in\n match n mod 10 with\n | 1 when not teen -> \"st\"\n | 2 when not teen -> \"nd\"\n | 3 when not teen -> \"rd\"\n | _ -> \"th\"\n\n(* Color handling *)\nmodule Color = struct\n (* use ANSI color codes, see https://en.wikipedia.org/wiki/ANSI_escape_code *)\n type color =\n | Black\n | Red\n | Green\n | Yellow\n | Blue\n | Magenta\n | Cyan\n | White\n ;;\n\n type style =\n | FG of color (* foreground *)\n | BG of color (* background *)\n | Bold\n | Reset\n\n let ansi_of_color = function\n | Black -> \"0\"\n | Red -> \"1\"\n | Green -> \"2\"\n | Yellow -> \"3\"\n | Blue -> \"4\"\n | Magenta -> \"5\"\n | Cyan -> \"6\"\n | White -> \"7\"\n\n let code_of_style = function\n | FG c -> \"3\" ^ ansi_of_color c\n | BG c -> \"4\" ^ ansi_of_color c\n | Bold -> \"1\"\n | Reset -> \"0\"\n\n let ansi_of_style_l l =\n let s = match l with\n | [] -> code_of_style Reset\n | [s] -> code_of_style s\n | _ -> String.concat \";\" (List.map code_of_style l)\n in\n \"\\x1b[\" ^ s ^ \"m\"\n\n\n type Format.stag += Style of style list\n type styles = {\n error: style list;\n warning: style list;\n loc: style list;\n }\n\n let default_styles = {\n warning = [Bold; FG Magenta];\n error = [Bold; FG Red];\n loc = [Bold];\n }\n\n let cur_styles = ref default_styles\n let get_styles () = !cur_styles\n let set_styles s = cur_styles := s\n\n (* map a tag to a style, if the tag is known.\n @raise Not_found otherwise *)\n let style_of_tag s = match s with\n | Format.String_tag \"error\" -> (!cur_styles).error\n | Format.String_tag \"warning\" -> (!cur_styles).warning\n | Format.String_tag \"loc\" -> (!cur_styles).loc\n | Style s -> s\n | _ -> raise Not_found\n\n let color_enabled = ref true\n\n (* either prints the tag of [s] or delegates to [or_else] *)\n let mark_open_tag ~or_else s =\n try\n let style = style_of_tag s in\n if !color_enabled then ansi_of_style_l style else \"\"\n with Not_found -> or_else s\n\n let mark_close_tag ~or_else s =\n try\n let _ = style_of_tag s in\n if !color_enabled then ansi_of_style_l [Reset] else \"\"\n with Not_found -> or_else s\n\n (* add color handling to formatter [ppf] *)\n let set_color_tag_handling ppf =\n let open Format in\n let functions = pp_get_formatter_stag_functions ppf () in\n let functions' = {functions with\n mark_open_stag=(mark_open_tag ~or_else:functions.mark_open_stag);\n mark_close_stag=(mark_close_tag ~or_else:functions.mark_close_stag);\n } in\n pp_set_mark_tags ppf true; (* enable tags *)\n pp_set_formatter_stag_functions ppf functions';\n ()\n\n external isatty : out_channel -> bool = \"caml_sys_isatty\"\n\n (* reasonable heuristic on whether colors should be enabled *)\n let should_enable_color () =\n let term = try Sys.getenv \"TERM\" with Not_found -> \"\" in\n term <> \"dumb\"\n && term <> \"\"\n && isatty stderr\n\n type setting = Auto | Always | Never\n\n let default_setting = Auto\n\n let setup =\n let first = ref true in (* initialize only once *)\n let formatter_l =\n [Format.std_formatter; Format.err_formatter; Format.str_formatter]\n in\n let enable_color = function\n | Auto -> should_enable_color ()\n | Always -> true\n | Never -> false\n in\n fun o ->\n if !first then (\n first := false;\n Format.set_mark_tags true;\n List.iter set_color_tag_handling formatter_l;\n color_enabled := (match o with\n | Some s -> enable_color s\n | None -> enable_color default_setting)\n );\n ()\nend\n\nmodule Error_style = struct\n type setting =\n | Contextual\n | Short\n\n let default_setting = Contextual\nend\n\nlet normalise_eol s =\n let b = Buffer.create 80 in\n for i = 0 to String.length s - 1 do\n if s.[i] <> '\\r' then Buffer.add_char b s.[i]\n done;\n Buffer.contents b\n\nlet delete_eol_spaces src =\n let len_src = String.length src in\n let dst = Bytes.create len_src in\n let rec loop i_src i_dst =\n if i_src = len_src then\n i_dst\n else\n match src.[i_src] with\n | ' ' | '\\t' ->\n loop_spaces 1 (i_src + 1) i_dst\n | c ->\n Bytes.set dst i_dst c;\n loop (i_src + 1) (i_dst + 1)\n and loop_spaces spaces i_src i_dst =\n if i_src = len_src then\n i_dst\n else\n match src.[i_src] with\n | ' ' | '\\t' ->\n loop_spaces (spaces + 1) (i_src + 1) i_dst\n | '\\n' ->\n Bytes.set dst i_dst '\\n';\n loop (i_src + 1) (i_dst + 1)\n | _ ->\n for n = 0 to spaces do\n Bytes.set dst (i_dst + n) src.[i_src - spaces + n]\n done;\n loop (i_src + 1) (i_dst + spaces + 1)\n in\n let stop = loop 0 0 in\n Bytes.sub_string dst 0 stop\n\nlet pp_two_columns ?(sep = \"|\") ?max_lines ppf (lines: (string * string) list) =\n let left_column_size =\n List.fold_left (fun acc (s, _) -> Int.max acc (String.length s)) 0 lines in\n let lines_nb = List.length lines in\n let ellipsed_first, ellipsed_last =\n match max_lines with\n | Some max_lines when lines_nb > max_lines ->\n let printed_lines = max_lines - 1 in (* the ellipsis uses one line *)\n let lines_before = printed_lines / 2 + printed_lines mod 2 in\n let lines_after = printed_lines / 2 in\n (lines_before, lines_nb - lines_after - 1)\n | _ -> (-1, -1)\n in\n Format.fprintf ppf \"@[\";\n List.iteri (fun k (line_l, line_r) ->\n if k = ellipsed_first then Format.fprintf ppf \"...@,\";\n if ellipsed_first <= k && k <= ellipsed_last then ()\n else Format.fprintf ppf \"%*s %s %s@,\" left_column_size line_l sep line_r\n ) lines;\n Format.fprintf ppf \"@]\"\n\n(* showing configuration and configuration variables *)\nlet show_config_and_exit () =\n Config.print_config stdout;\n exit 0\n\nlet show_config_variable_and_exit x =\n match Config.config_var x with\n | Some v ->\n (* we intentionally don't print a newline to avoid Windows \\r\n issues: bash only strips the trailing \\n when using a command\n substitution $(ocamlc -config-var foo), so a trailing \\r would\n remain if printing a newline under Windows and scripts would\n have to use $(ocamlc -config-var foo | tr -d '\\r')\n for portability. Ugh. *)\n print_string v;\n exit 0\n | None ->\n exit 2\n\nlet get_build_path_prefix_map =\n let init = ref false in\n let map_cache = ref None in\n fun () ->\n if not !init then begin\n init := true;\n match Sys.getenv \"BUILD_PATH_PREFIX_MAP\" with\n | exception Not_found -> ()\n | encoded_map ->\n match Build_path_prefix_map.decode_map encoded_map with\n | Error err ->\n fatal_errorf\n \"Invalid value for the environment variable \\\n BUILD_PATH_PREFIX_MAP: %s\" err\n | Ok map -> map_cache := Some map\n end;\n !map_cache\n\nlet debug_prefix_map_flags () =\n if not Config.as_has_debug_prefix_map then\n []\n else begin\n match get_build_path_prefix_map () with\n | None -> []\n | Some map ->\n List.fold_right\n (fun map_elem acc ->\n match map_elem with\n | None -> acc\n | Some { Build_path_prefix_map.target; source; } ->\n (Printf.sprintf \"--debug-prefix-map %s=%s\"\n (Filename.quote source)\n (Filename.quote target)) :: acc)\n map\n []\n end\n\nlet print_if ppf flag printer arg =\n if !flag then Format.fprintf ppf \"%a@.\" printer arg;\n arg\n\n\ntype filepath = string\ntype modname = string\ntype crcs = (modname * Digest.t option) list\n\ntype alerts = string Stdlib.String.Map.t\n\nmodule Magic_number = struct\n type native_obj_config = {\n flambda : bool;\n }\n let native_obj_config = {\n flambda = Config.flambda;\n }\n\n type version = int\n\n type kind =\n | Exec\n | Cmi | Cmo | Cma\n | Cmx of native_obj_config | Cmxa of native_obj_config\n | Cmxs\n | Cmt\n | Ast_impl | Ast_intf\n\n (* please keep up-to-date, this is used for sanity checking *)\n let all_native_obj_configs = [\n {flambda = true};\n {flambda = false};\n ]\n let all_kinds = [\n Exec;\n Cmi; Cmo; Cma;\n ]\n @ List.map (fun conf -> Cmx conf) all_native_obj_configs\n @ List.map (fun conf -> Cmxa conf) all_native_obj_configs\n @ [\n Cmt;\n Ast_impl; Ast_intf;\n ]\n\n type raw = string\n type info = {\n kind: kind;\n version: version;\n }\n\n type raw_kind = string\n\n let parse_kind : raw_kind -> kind option = function\n | \"Caml1999X\" -> Some Exec\n | \"Caml1999I\" -> Some Cmi\n | \"Caml1999O\" -> Some Cmo\n | \"Caml1999A\" -> Some Cma\n | \"Caml1999y\" -> Some (Cmx {flambda = true})\n | \"Caml1999Y\" -> Some (Cmx {flambda = false})\n | \"Caml1999z\" -> Some (Cmxa {flambda = true})\n | \"Caml1999Z\" -> Some (Cmxa {flambda = false})\n\n (* Caml2007D and Caml2012T were used instead of the common Caml1999 prefix\n between the introduction of those magic numbers and October 2017\n (8ba70ff194b66c0a50ffb97d41fe9c4bdf9362d6).\n\n We accept them here, but will always produce/show kind prefixes\n that follow the current convention, Caml1999{D,T}. *)\n | \"Caml2007D\" | \"Caml1999D\" -> Some Cmxs\n | \"Caml2012T\" | \"Caml1999T\" -> Some Cmt\n\n | \"Caml1999M\" -> Some Ast_impl\n | \"Caml1999N\" -> Some Ast_intf\n | _ -> None\n\n (* note: over time the magic kind number has changed for certain kinds;\n this function returns them as they are produced by the current compiler,\n but [parse_kind] accepts older formats as well. *)\n let raw_kind : kind -> raw = function\n | Exec -> \"Caml1999X\"\n | Cmi -> \"Caml1999I\"\n | Cmo -> \"Caml1999O\"\n | Cma -> \"Caml1999A\"\n | Cmx config ->\n if config.flambda\n then \"Caml1999y\"\n else \"Caml1999Y\"\n | Cmxa config ->\n if config.flambda\n then \"Caml1999z\"\n else \"Caml1999Z\"\n | Cmxs -> \"Caml1999D\"\n | Cmt -> \"Caml1999T\"\n | Ast_impl -> \"Caml1999M\"\n | Ast_intf -> \"Caml1999N\"\n\n let string_of_kind : kind -> string = function\n | Exec -> \"exec\"\n | Cmi -> \"cmi\"\n | Cmo -> \"cmo\"\n | Cma -> \"cma\"\n | Cmx _ -> \"cmx\"\n | Cmxa _ -> \"cmxa\"\n | Cmxs -> \"cmxs\"\n | Cmt -> \"cmt\"\n | Ast_impl -> \"ast_impl\"\n | Ast_intf -> \"ast_intf\"\n\n let human_description_of_native_obj_config : native_obj_config -> string =\n fun[@warning \"+9\"] {flambda} ->\n if flambda then \"flambda\" else \"non flambda\"\n\n let human_name_of_kind : kind -> string = function\n | Exec -> \"executable\"\n | Cmi -> \"compiled interface file\"\n | Cmo -> \"bytecode object file\"\n | Cma -> \"bytecode library\"\n | Cmx config ->\n Printf.sprintf \"native compilation unit description (%s)\"\n (human_description_of_native_obj_config config)\n | Cmxa config ->\n Printf.sprintf \"static native library (%s)\"\n (human_description_of_native_obj_config config)\n | Cmxs -> \"dynamic native library\"\n | Cmt -> \"compiled typedtree file\"\n | Ast_impl -> \"serialized implementation AST\"\n | Ast_intf -> \"serialized interface AST\"\n\n let kind_length = 9\n let version_length = 3\n let magic_length =\n kind_length + version_length\n\n type parse_error =\n | Truncated of string\n | Not_a_magic_number of string\n\n let explain_parse_error kind_opt error =\n Printf.sprintf\n \"We expected a valid %s, but the file %s.\"\n (Option.fold ~none:\"object file\" ~some:human_name_of_kind kind_opt)\n (match error with\n | Truncated \"\" -> \"is empty\"\n | Truncated _ -> \"is truncated\"\n | Not_a_magic_number _ -> \"has a different format\")\n\n let parse s : (info, parse_error) result =\n if String.length s = magic_length then begin\n let raw_kind = String.sub s 0 kind_length in\n let raw_version = String.sub s kind_length version_length in\n match parse_kind raw_kind with\n | None -> Error (Not_a_magic_number s)\n | Some kind ->\n begin match int_of_string raw_version with\n | exception _ -> Error (Truncated s)\n | version -> Ok { kind; version }\n end\n end\n else begin\n (* a header is \"truncated\" if it starts like a valid magic number,\n that is if its longest segment of length at most [kind_length]\n is a prefix of [raw_kind kind] for some kind [kind] *)\n let sub_length = Int.min kind_length (String.length s) in\n let starts_as kind =\n String.sub s 0 sub_length = String.sub (raw_kind kind) 0 sub_length\n in\n if List.exists starts_as all_kinds then Error (Truncated s)\n else Error (Not_a_magic_number s)\n end\n\n let read_info ic =\n let header = Buffer.create magic_length in\n begin\n try Buffer.add_channel header ic magic_length\n with End_of_file -> ()\n end;\n parse (Buffer.contents header)\n\n let raw { kind; version; } =\n Printf.sprintf \"%s%03d\" (raw_kind kind) version\n\n let current_raw kind =\n let open Config in\n match[@warning \"+9\"] kind with\n | Exec -> exec_magic_number\n | Cmi -> cmi_magic_number\n | Cmo -> cmo_magic_number\n | Cma -> cma_magic_number\n | Cmx config ->\n (* the 'if' guarantees that in the common case\n we return the \"trusted\" value from Config. *)\n let reference = cmx_magic_number in\n if config = native_obj_config then reference\n else\n (* otherwise we stitch together the magic number\n for a different configuration by concatenating\n the right magic kind at this configuration\n and the rest of the current raw number for our configuration. *)\n let raw_kind = raw_kind kind in\n let len = String.length raw_kind in\n raw_kind ^ String.sub reference len (String.length reference - len)\n | Cmxa config ->\n let reference = cmxa_magic_number in\n if config = native_obj_config then reference\n else\n let raw_kind = raw_kind kind in\n let len = String.length raw_kind in\n raw_kind ^ String.sub reference len (String.length reference - len)\n | Cmxs -> cmxs_magic_number\n | Cmt -> cmt_magic_number\n | Ast_intf -> ast_intf_magic_number\n | Ast_impl -> ast_impl_magic_number\n\n (* it would seem more direct to define current_version with the\n correct numbers and current_raw on top of it, but for now we\n consider the Config.foo values to be ground truth, and don't want\n to trust the present module instead. *)\n let current_version kind =\n let raw = current_raw kind in\n try int_of_string (String.sub raw kind_length version_length)\n with _ -> assert false\n\n type 'a unexpected = { expected : 'a; actual : 'a }\n type unexpected_error =\n | Kind of kind unexpected\n | Version of kind * version unexpected\n\n let explain_unexpected_error = function\n | Kind { actual; expected } ->\n Printf.sprintf \"We expected a %s (%s) but got a %s (%s) instead.\"\n (human_name_of_kind expected) (string_of_kind expected)\n (human_name_of_kind actual) (string_of_kind actual)\n | Version (kind, { actual; expected }) ->\n Printf.sprintf \"This seems to be a %s (%s) for %s version of OCaml.\"\n (human_name_of_kind kind) (string_of_kind kind)\n (if actual < expected then \"an older\" else \"a newer\")\n\n let check_current expected_kind { kind; version } : _ result =\n if kind <> expected_kind then begin\n let actual, expected = kind, expected_kind in\n Error (Kind { actual; expected })\n end else begin\n let actual, expected = version, current_version kind in\n if actual <> expected\n then Error (Version (kind, { actual; expected }))\n else Ok ()\n end\n\n type error =\n | Parse_error of parse_error\n | Unexpected_error of unexpected_error\n\n let read_current_info ~expected_kind ic =\n match read_info ic with\n | Error err -> Error (Parse_error err)\n | Ok info ->\n let kind = Option.value ~default:info.kind expected_kind in\n match check_current kind info with\n | Error err -> Error (Unexpected_error err)\n | Ok () -> Ok info\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Chambart, OCamlPro *)\n(* *)\n(* Copyright 2015 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 \"+a-18-40-42-48\"]\n\ntype file = string\n\nexternal time_include_children: bool -> float = \"caml_sys_time_include_children\"\nlet cpu_time () = time_include_children true\n\nmodule Measure = struct\n type t = {\n time : float;\n allocated_words : float;\n top_heap_words : int;\n }\n let create () =\n let stat = Gc.quick_stat () in\n {\n time = cpu_time ();\n allocated_words = stat.minor_words +. stat.major_words;\n top_heap_words = stat.top_heap_words;\n }\n let zero = { time = 0.; allocated_words = 0.; top_heap_words = 0 }\nend\n\nmodule Measure_diff = struct\n let timestamp = let r = ref (-1) in fun () -> incr r; !r\n type t = {\n timestamp : int;\n duration : float;\n allocated_words : float;\n top_heap_words_increase : int;\n }\n let zero () = {\n timestamp = timestamp ();\n duration = 0.;\n allocated_words = 0.;\n top_heap_words_increase = 0;\n }\n let accumulate t (m1 : Measure.t) (m2 : Measure.t) = {\n timestamp = t.timestamp;\n duration = t.duration +. (m2.time -. m1.time);\n allocated_words =\n t.allocated_words +. (m2.allocated_words -. m1.allocated_words);\n top_heap_words_increase =\n t.top_heap_words_increase + (m2.top_heap_words - m1.top_heap_words);\n }\n let of_diff m1 m2 =\n accumulate (zero ()) m1 m2\nend\n\ntype hierarchy =\n | E of (string, Measure_diff.t * hierarchy) Hashtbl.t\n[@@unboxed]\n\nlet create () = E (Hashtbl.create 2)\nlet hierarchy = ref (create ())\nlet initial_measure = ref None\nlet reset () = hierarchy := create (); initial_measure := None\n\nlet record_call ?(accumulate = false) name f =\n let E prev_hierarchy = !hierarchy in\n let start_measure = Measure.create () in\n if !initial_measure = None then initial_measure := Some start_measure;\n let this_measure_diff, this_table =\n (* We allow the recording of multiple categories by the same name, for tools\n like ocamldoc that use the compiler libs but don't care about profile\n information, and so may record, say, \"parsing\" multiple times. *)\n if accumulate\n then\n match Hashtbl.find prev_hierarchy name with\n | exception Not_found -> Measure_diff.zero (), Hashtbl.create 2\n | measure_diff, E table ->\n Hashtbl.remove prev_hierarchy name;\n measure_diff, table\n else Measure_diff.zero (), Hashtbl.create 2\n in\n hierarchy := E this_table;\n Misc.try_finally f\n ~always:(fun () ->\n hierarchy := E prev_hierarchy;\n let end_measure = Measure.create () in\n let measure_diff =\n Measure_diff.accumulate this_measure_diff start_measure end_measure in\n Hashtbl.add prev_hierarchy name (measure_diff, E this_table))\n\nlet record ?accumulate pass f x = record_call ?accumulate pass (fun () -> f x)\n\ntype display = {\n to_string : max:float -> width:int -> string;\n worth_displaying : max:float -> bool;\n}\n\nlet time_display v : display =\n (* Because indentation is meaningful, and because the durations are\n the first element of each row, we can't pad them with spaces. *)\n let to_string_without_unit v ~width = Printf.sprintf \"%0*.03f\" width v in\n let to_string ~max:_ ~width =\n to_string_without_unit v ~width:(width - 1) ^ \"s\" in\n let worth_displaying ~max:_ =\n float_of_string (to_string_without_unit v ~width:0) <> 0. in\n { to_string; worth_displaying }\n\nlet memory_word_display =\n (* To make memory numbers easily comparable across rows, we choose a single\n scale for an entire column. To keep the display compact and not overly\n precise (no one cares about the exact number of bytes), we pick the largest\n scale we can and we only show 3 digits. Avoiding showing tiny numbers also\n allows us to avoid displaying passes that barely allocate compared to the\n rest of the compiler. *)\n let bytes_of_words words = words *. float_of_int (Sys.word_size / 8) in\n let to_string_without_unit v ~width scale =\n let precision = 3 and precision_power = 1e3 in\n let v_rescaled = bytes_of_words v /. scale in\n let v_rounded =\n floor (v_rescaled *. precision_power +. 0.5) /. precision_power in\n let v_str = Printf.sprintf \"%.*f\" precision v_rounded in\n let index_of_dot = String.index v_str '.' in\n let v_str_truncated =\n String.sub v_str 0\n (if index_of_dot >= precision\n then index_of_dot\n else precision + 1)\n in\n Printf.sprintf \"%*s\" width v_str_truncated\n in\n let choose_memory_scale =\n let units = [|\"B\"; \"kB\"; \"MB\"; \"GB\"|] in\n fun words ->\n let bytes = bytes_of_words words in\n let scale = ref (Array.length units - 1) in\n while !scale > 0 && bytes < 1024. ** float_of_int !scale do\n decr scale\n done;\n 1024. ** float_of_int !scale, units.(!scale)\n in\n fun ?previous v : display ->\n let to_string ~max ~width =\n let scale, scale_str = choose_memory_scale max in\n let width = width - String.length scale_str in\n to_string_without_unit v ~width scale ^ scale_str\n in\n let worth_displaying ~max =\n let scale, _ = choose_memory_scale max in\n float_of_string (to_string_without_unit v ~width:0 scale) <> 0.\n && match previous with\n | None -> true\n | Some p ->\n (* This branch is for numbers that represent absolute quantity, rather\n than differences. It allows us to skip displaying the same absolute\n quantity many times in a row. *)\n to_string_without_unit p ~width:0 scale\n <> to_string_without_unit v ~width:0 scale\n in\n { to_string; worth_displaying }\n\nlet profile_list (E table) =\n let l = Hashtbl.fold (fun k d l -> (k, d) :: l) table [] in\n List.sort (fun (_, (p1, _)) (_, (p2, _)) ->\n compare p1.Measure_diff.timestamp p2.Measure_diff.timestamp) l\n\nlet compute_other_category (E table : hierarchy) (total : Measure_diff.t) =\n let r = ref total in\n Hashtbl.iter (fun _pass ((p2 : Measure_diff.t), _) ->\n let p1 = !r in\n r := {\n timestamp = p1.timestamp;\n duration = p1.duration -. p2.duration;\n allocated_words = p1.allocated_words -. p2.allocated_words;\n top_heap_words_increase =\n p1.top_heap_words_increase - p2.top_heap_words_increase;\n }\n ) table;\n !r\n\ntype row = R of string * (float * display) list * row list\ntype column = [ `Time | `Alloc | `Top_heap | `Abs_top_heap ]\n\nlet rec rows_of_hierarchy ~nesting make_row name measure_diff hierarchy env =\n let rows =\n rows_of_hierarchy_list\n ~nesting:(nesting + 1) make_row hierarchy measure_diff env in\n let values, env =\n make_row env measure_diff ~toplevel_other:(nesting = 0 && name = \"other\") in\n R (name, values, rows), env\n\nand rows_of_hierarchy_list ~nesting make_row hierarchy total env =\n let list = profile_list hierarchy in\n let list =\n if list <> [] || nesting = 0\n then list @ [ \"other\", (compute_other_category hierarchy total, create ()) ]\n else []\n in\n let env = ref env in\n List.map (fun (name, (measure_diff, hierarchy)) ->\n let a, env' =\n rows_of_hierarchy ~nesting make_row name measure_diff hierarchy !env in\n env := env';\n a\n ) list\n\nlet rows_of_hierarchy hierarchy measure_diff initial_measure columns =\n (* Computing top heap size is a bit complicated: if the compiler applies a\n list of passes n times (rather than applying pass1 n times, then pass2 n\n times etc), we only show one row for that pass but what does \"top heap\n size at the end of that pass\" even mean?\n It seems the only sensible answer is to pretend the compiler applied pass1\n n times, pass2 n times by accumulating all the heap size increases that\n happened during each pass, and then compute what the heap size would have\n been. So that's what we do.\n There's a bit of extra complication, which is that the heap can increase in\n between measurements. So the heap sizes can be a bit off until the \"other\"\n rows account for what's missing. We special case the toplevel \"other\" row\n so that any increases that happened before the start of the compilation is\n correctly reported, as a lot of code may run before the start of the\n compilation (eg functor applications). *)\n let make_row prev_top_heap_words (p : Measure_diff.t) ~toplevel_other =\n let top_heap_words =\n prev_top_heap_words\n + p.top_heap_words_increase\n - if toplevel_other\n then initial_measure.Measure.top_heap_words\n else 0\n in\n let make value ~f = value, f value in\n List.map (function\n | `Time ->\n make p.duration ~f:time_display\n | `Alloc ->\n make p.allocated_words ~f:memory_word_display\n | `Top_heap ->\n make (float_of_int p.top_heap_words_increase) ~f:memory_word_display\n | `Abs_top_heap ->\n make (float_of_int top_heap_words)\n ~f:(memory_word_display ~previous:(float_of_int prev_top_heap_words))\n ) columns,\n top_heap_words\n in\n rows_of_hierarchy_list ~nesting:0 make_row hierarchy measure_diff\n initial_measure.top_heap_words\n\nlet max_by_column ~n_columns rows =\n let a = Array.make n_columns 0. in\n let rec loop (R (_, values, rows)) =\n List.iteri (fun i (v, _) -> a.(i) <- Float.max a.(i) v) values;\n List.iter loop rows\n in\n List.iter loop rows;\n a\n\nlet width_by_column ~n_columns ~display_cell rows =\n let a = Array.make n_columns 1 in\n let rec loop (R (_, values, rows)) =\n List.iteri (fun i cell ->\n let _, str = display_cell i cell ~width:0 in\n a.(i) <- Int.max a.(i) (String.length str)\n ) values;\n List.iter loop rows;\n in\n List.iter loop rows;\n a\n\nlet display_rows ppf rows =\n let n_columns =\n match rows with\n | [] -> 0\n | R (_, values, _) :: _ -> List.length values\n in\n let maxs = max_by_column ~n_columns rows in\n let display_cell i (_, c) ~width =\n let display_cell = c.worth_displaying ~max:maxs.(i) in\n display_cell, if display_cell\n then c.to_string ~max:maxs.(i) ~width\n else String.make width '-'\n in\n let widths = width_by_column ~n_columns ~display_cell rows in\n let rec loop (R (name, values, rows)) ~indentation =\n let worth_displaying, cell_strings =\n values\n |> List.mapi (fun i cell -> display_cell i cell ~width:widths.(i))\n |> List.split\n in\n if List.exists (fun b -> b) worth_displaying then\n Format.fprintf ppf \"%s%s %s@\\n\"\n indentation (String.concat \" \" cell_strings) name;\n List.iter (loop ~indentation:(\" \" ^ indentation)) rows;\n in\n List.iter (loop ~indentation:\"\") rows\n\nlet print ppf columns =\n match columns with\n | [] -> ()\n | _ :: _ ->\n let initial_measure =\n match !initial_measure with\n | Some v -> v\n | None -> Measure.zero\n in\n let total = Measure_diff.of_diff Measure.zero (Measure.create ()) in\n display_rows ppf\n (rows_of_hierarchy !hierarchy total initial_measure columns)\n\nlet column_mapping = [\n \"time\", `Time;\n \"alloc\", `Alloc;\n \"top-heap\", `Top_heap;\n \"absolute-top-heap\", `Abs_top_heap;\n]\n\nlet column_names = List.map fst column_mapping\n\nlet options_doc =\n Printf.sprintf\n \" Print performance information for each pass\\\n \\n The columns are: %s.\"\n (String.concat \" \" column_names)\n\nlet all_columns = List.map snd column_mapping\n\nlet generate = \"generate\"\nlet transl = \"transl\"\nlet typing = \"typing\"\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Weis && Damien Doligez, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1998 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(* When you change this, you need to update:\n - the list 'description' at the bottom of this file\n - man/ocamlc.m\n*)\n\ntype loc = {\n loc_start: Lexing.position;\n loc_end: Lexing.position;\n loc_ghost: bool;\n}\n\ntype field_usage_warning =\n | Unused\n | Not_read\n | Not_mutated\n\ntype constructor_usage_warning =\n | Unused\n | Not_constructed\n | Only_exported_private\n\ntype t =\n | Comment_start (* 1 *)\n | Comment_not_end (* 2 *)\n(*| Deprecated --> alert \"deprecated\" *) (* 3 *)\n | Fragile_match of string (* 4 *)\n | Ignored_partial_application (* 5 *)\n | Labels_omitted of string list (* 6 *)\n | Method_override of string list (* 7 *)\n | Partial_match of string (* 8 *)\n | Missing_record_field_pattern of string (* 9 *)\n | Non_unit_statement (* 10 *)\n | Redundant_case (* 11 *)\n | Redundant_subpat (* 12 *)\n | Instance_variable_override of string list (* 13 *)\n | Illegal_backslash (* 14 *)\n | Implicit_public_methods of string list (* 15 *)\n | Unerasable_optional_argument (* 16 *)\n | Undeclared_virtual_method of string (* 17 *)\n | Not_principal of string (* 18 *)\n | Non_principal_labels of string (* 19 *)\n | Ignored_extra_argument (* 20 *)\n | Nonreturning_statement (* 21 *)\n | Preprocessor of string (* 22 *)\n | Useless_record_with (* 23 *)\n | Bad_module_name of string (* 24 *)\n | All_clauses_guarded (* 8, used to be 25 *)\n | Unused_var of string (* 26 *)\n | Unused_var_strict of string (* 27 *)\n | Wildcard_arg_to_constant_constr (* 28 *)\n | Eol_in_string (* 29 *)\n | Duplicate_definitions of string * string * string * string (*30 *)\n | Module_linked_twice of string * string * string (* 31 *)\n | Unused_value_declaration of string (* 32 *)\n | Unused_open of string (* 33 *)\n | Unused_type_declaration of string (* 34 *)\n | Unused_for_index of string (* 35 *)\n | Unused_ancestor of string (* 36 *)\n | Unused_constructor of string * constructor_usage_warning (* 37 *)\n | Unused_extension of string * bool * constructor_usage_warning (* 38 *)\n | Unused_rec_flag (* 39 *)\n | Name_out_of_scope of string * string list * bool (* 40 *)\n | Ambiguous_name of string list * string list * bool * string (* 41 *)\n | Disambiguated_name of string (* 42 *)\n | Nonoptional_label of string (* 43 *)\n | Open_shadow_identifier of string * string (* 44 *)\n | Open_shadow_label_constructor of string * string (* 45 *)\n | Bad_env_variable of string * string (* 46 *)\n | Attribute_payload of string * string (* 47 *)\n | Eliminated_optional_arguments of string list (* 48 *)\n | No_cmi_file of string * string option (* 49 *)\n | Unexpected_docstring of bool (* 50 *)\n | Wrong_tailcall_expectation of bool (* 51 *)\n | Fragile_literal_pattern (* 52 *)\n | Misplaced_attribute of string (* 53 *)\n | Duplicated_attribute of string (* 54 *)\n | Inlining_impossible of string (* 55 *)\n | Unreachable_case (* 56 *)\n | Ambiguous_var_in_pattern_guard of string list (* 57 *)\n | No_cmx_file of string (* 58 *)\n | Flambda_assignment_to_non_mutable_value (* 59 *)\n | Unused_module of string (* 60 *)\n | Unboxable_type_in_prim_decl of string (* 61 *)\n | Constraint_on_gadt (* 62 *)\n | Erroneous_printed_signature of string (* 63 *)\n | Unsafe_array_syntax_without_parsing (* 64 *)\n | Redefining_unit of string (* 65 *)\n | Unused_open_bang of string (* 66 *)\n | Unused_functor_parameter of string (* 67 *)\n | Match_on_mutable_state_prevent_uncurry (* 68 *)\n | Unused_field of string * field_usage_warning (* 69 *)\n | Missing_mli (* 70 *)\n | Unused_tmc_attribute (* 71 *)\n | Tmc_breaks_tailcall (* 72 *)\n;;\n\n(* If you remove a warning, leave a hole in the numbering. NEVER change\n the numbers of existing warnings.\n If you add a new warning, add it at the end with a new number;\n do NOT reuse one of the holes.\n*)\n\ntype alert = {kind:string; message:string; def:loc; use:loc}\n\nlet number = function\n | Comment_start -> 1\n | Comment_not_end -> 2\n | Fragile_match _ -> 4\n | Ignored_partial_application -> 5\n | Labels_omitted _ -> 6\n | Method_override _ -> 7\n | Partial_match _ -> 8\n | Missing_record_field_pattern _ -> 9\n | Non_unit_statement -> 10\n | Redundant_case -> 11\n | Redundant_subpat -> 12\n | Instance_variable_override _ -> 13\n | Illegal_backslash -> 14\n | Implicit_public_methods _ -> 15\n | Unerasable_optional_argument -> 16\n | Undeclared_virtual_method _ -> 17\n | Not_principal _ -> 18\n | Non_principal_labels _ -> 19\n | Ignored_extra_argument -> 20\n | Nonreturning_statement -> 21\n | Preprocessor _ -> 22\n | Useless_record_with -> 23\n | Bad_module_name _ -> 24\n | All_clauses_guarded -> 8 (* used to be 25 *)\n | Unused_var _ -> 26\n | Unused_var_strict _ -> 27\n | Wildcard_arg_to_constant_constr -> 28\n | Eol_in_string -> 29\n | Duplicate_definitions _ -> 30\n | Module_linked_twice _ -> 31\n | Unused_value_declaration _ -> 32\n | Unused_open _ -> 33\n | Unused_type_declaration _ -> 34\n | Unused_for_index _ -> 35\n | Unused_ancestor _ -> 36\n | Unused_constructor _ -> 37\n | Unused_extension _ -> 38\n | Unused_rec_flag -> 39\n | Name_out_of_scope _ -> 40\n | Ambiguous_name _ -> 41\n | Disambiguated_name _ -> 42\n | Nonoptional_label _ -> 43\n | Open_shadow_identifier _ -> 44\n | Open_shadow_label_constructor _ -> 45\n | Bad_env_variable _ -> 46\n | Attribute_payload _ -> 47\n | Eliminated_optional_arguments _ -> 48\n | No_cmi_file _ -> 49\n | Unexpected_docstring _ -> 50\n | Wrong_tailcall_expectation _ -> 51\n | Fragile_literal_pattern -> 52\n | Misplaced_attribute _ -> 53\n | Duplicated_attribute _ -> 54\n | Inlining_impossible _ -> 55\n | Unreachable_case -> 56\n | Ambiguous_var_in_pattern_guard _ -> 57\n | No_cmx_file _ -> 58\n | Flambda_assignment_to_non_mutable_value -> 59\n | Unused_module _ -> 60\n | Unboxable_type_in_prim_decl _ -> 61\n | Constraint_on_gadt -> 62\n | Erroneous_printed_signature _ -> 63\n | Unsafe_array_syntax_without_parsing -> 64\n | Redefining_unit _ -> 65\n | Unused_open_bang _ -> 66\n | Unused_functor_parameter _ -> 67\n | Match_on_mutable_state_prevent_uncurry -> 68\n | Unused_field _ -> 69\n | Missing_mli -> 70\n | Unused_tmc_attribute -> 71\n | Tmc_breaks_tailcall -> 72\n;;\n\nlet last_warning_number = 72\n;;\n\ntype description =\n { number : int;\n names : string list;\n (* The first element of the list is the current name, any following ones are\n deprecated. The current name should always be derived mechanically from\n the constructor name. *)\n description : string; }\n\nlet descriptions = [\n { number = 1;\n names = [\"comment-start\"];\n description = \"Suspicious-looking start-of-comment mark.\" };\n { number = 2;\n names = [\"comment-not-end\"];\n description = \"Suspicious-looking end-of-comment mark.\" };\n { number = 3;\n names = [];\n description = \"Deprecated synonym for the 'deprecated' alert.\" };\n { number = 4;\n names = [\"fragile-match\"];\n description =\n \"Fragile pattern matching: matching that will remain complete even\\n\\\n \\ if additional constructors are added to one of the variant types\\n\\\n \\ matched.\" };\n { number = 5;\n names = [\"ignored-partial-application\"];\n description =\n \"Partially applied function: expression whose result has function\\n\\\n \\ type and is ignored.\" };\n { number = 6;\n names = [\"labels-omitted\"];\n description = \"Label omitted in function application.\" };\n { number = 7;\n names = [\"method-override\"];\n description = \"Method overridden.\" };\n { number = 8;\n names = [\"partial-match\"];\n description = \"Partial match: missing cases in pattern-matching.\" };\n { number = 9;\n names = [\"missing-record-field-pattern\"];\n description = \"Missing fields in a record pattern.\" };\n { number = 10;\n names = [\"non-unit-statement\"];\n description =\n \"Expression on the left-hand side of a sequence that doesn't have type\\n\\\n \\ \\\"unit\\\" (and that is not a function, see warning number 5).\" };\n { number = 11;\n names = [\"redundant-case\"];\n description =\n \"Redundant case in a pattern matching (unused match case).\" };\n { number = 12;\n names = [\"redundant-subpat\"];\n description = \"Redundant sub-pattern in a pattern-matching.\" };\n { number = 13;\n names = [\"instance-variable-override\"];\n description = \"Instance variable overridden.\" };\n { number = 14;\n names = [\"illegal-backslash\"];\n description = \"Illegal backslash escape in a string constant.\" };\n { number = 15;\n names = [\"implicit-public-methods\"];\n description = \"Private method made public implicitly.\" };\n { number = 16;\n names = [\"unerasable-optional-argument\"];\n description = \"Unerasable optional argument.\" };\n { number = 17;\n names = [\"undeclared-virtual-method\"];\n description = \"Undeclared virtual method.\" };\n { number = 18;\n names = [\"not-principal\"];\n description = \"Non-principal type.\" };\n { number = 19;\n names = [\"non-principal-labels\"];\n description = \"Type without principality.\" };\n { number = 20;\n names = [\"ignored-extra-argument\"];\n description = \"Unused function argument.\" };\n { number = 21;\n names = [\"nonreturning-statement\"];\n description = \"Non-returning statement.\" };\n { number = 22;\n names = [\"preprocessor\"];\n description = \"Preprocessor warning.\" };\n { number = 23;\n names = [\"useless-record-with\"];\n description = \"Useless record \\\"with\\\" clause.\" };\n { number = 24;\n names = [\"bad-module-name\"];\n description =\n \"Bad module name: the source file name is not a valid OCaml module name.\"};\n { number = 25;\n names = [];\n description = \"Ignored: now part of warning 8.\" };\n { number = 26;\n names = [\"unused-var\"];\n description =\n \"Suspicious unused variable: unused variable that is bound\\n\\\n \\ with \\\"let\\\" or \\\"as\\\", and doesn't start with an underscore (\\\"_\\\")\\n\\\n \\ character.\" };\n { number = 27;\n names = [\"unused-var-strict\"];\n description =\n \"Innocuous unused variable: unused variable that is not bound with\\n\\\n \\ \\\"let\\\" nor \\\"as\\\", and doesn't start with an underscore (\\\"_\\\")\\n\\\n \\ character.\" };\n { number = 28;\n names = [\"wildcard-arg-to-constant-constr\"];\n description =\n \"Wildcard pattern given as argument to a constant constructor.\" };\n { number = 29;\n names = [\"eol-in-string\"];\n description =\n \"Unescaped end-of-line in a string constant (non-portable code).\" };\n { number = 30;\n names = [\"duplicate-definitions\"];\n description =\n \"Two labels or constructors of the same name are defined in two\\n\\\n \\ mutually recursive types.\" };\n { number = 31;\n names = [\"module-linked-twice\"];\n description = \"A module is linked twice in the same executable.\" };\n { number = 32;\n names = [\"unused-value-declaration\"];\n description = \"Unused value declaration.\" };\n { number = 33;\n names = [\"unused-open\"];\n description = \"Unused open statement.\" };\n { number = 34;\n names = [\"unused-type-declaration\"];\n description = \"Unused type declaration.\" };\n { number = 35;\n names = [\"unused-for-index\"];\n description = \"Unused for-loop index.\" };\n { number = 36;\n names = [\"unused-ancestor\"];\n description = \"Unused ancestor variable.\" };\n { number = 37;\n names = [\"unused-constructor\"];\n description = \"Unused constructor.\" };\n { number = 38;\n names = [\"unused-extension\"];\n description = \"Unused extension constructor.\" };\n { number = 39;\n names = [\"unused-rec-flag\"];\n description = \"Unused rec flag.\" };\n { number = 40;\n names = [\"name-out-of-scope\"];\n description = \"Constructor or label name used out of scope.\" };\n { number = 41;\n names = [\"ambiguous-name\"];\n description = \"Ambiguous constructor or label name.\" };\n { number = 42;\n names = [\"disambiguated-name\"];\n description =\n \"Disambiguated constructor or label name (compatibility warning).\" };\n { number = 43;\n names = [\"nonoptional-label\"];\n description = \"Nonoptional label applied as optional.\" };\n { number = 44;\n names = [\"open-shadow-identifier\"];\n description = \"Open statement shadows an already defined identifier.\" };\n { number = 45;\n names = [\"open-shadow-label-constructor\"];\n description =\n \"Open statement shadows an already defined label or constructor.\" };\n { number = 46;\n names = [\"bad-env-variable\"];\n description = \"Error in environment variable.\" };\n { number = 47;\n names = [\"attribute-payload\"];\n description = \"Illegal attribute payload.\" };\n { number = 48;\n names = [\"eliminated-optional-arguments\"];\n description = \"Implicit elimination of optional arguments.\" };\n { number = 49;\n names = [\"no-cmi-file\"];\n description = \"Absent cmi file when looking up module alias.\" };\n { number = 50;\n names = [\"unexpected-docstring\"];\n description = \"Unexpected documentation comment.\" };\n { number = 51;\n names = [\"wrong-tailcall-expectation\"];\n description =\n \"Function call annotated with an incorrect @tailcall attribute\" };\n { number = 52;\n names = [\"fragile-literal-pattern\"];\n description = \"Fragile constant pattern.\" };\n { number = 53;\n names = [\"misplaced-attribute\"];\n description = \"Attribute cannot appear in this context.\" };\n { number = 54;\n names = [\"duplicated-attribute\"];\n description = \"Attribute used more than once on an expression.\" };\n { number = 55;\n names = [\"inlining-impossible\"];\n description = \"Inlining impossible.\" };\n { number = 56;\n names = [\"unreachable-case\"];\n description =\n \"Unreachable case in a pattern-matching (based on type information).\" };\n { number = 57;\n names = [\"ambiguous-var-in-pattern-guard\"];\n description = \"Ambiguous or-pattern variables under guard.\" };\n { number = 58;\n names = [\"no-cmx-file\"];\n description = \"Missing cmx file.\" };\n { number = 59;\n names = [\"flambda-assignment-to-non-mutable-value\"];\n description = \"Assignment to non-mutable value.\" };\n { number = 60;\n names = [\"unused-module\"];\n description = \"Unused module declaration.\" };\n { number = 61;\n names = [\"unboxable-type-in-prim-decl\"];\n description = \"Unboxable type in primitive declaration.\" };\n { number = 62;\n names = [\"constraint-on-gadt\"];\n description = \"Type constraint on GADT type declaration.\" };\n { number = 63;\n names = [\"erroneous-printed-signature\"];\n description = \"Erroneous printed signature.\" };\n { number = 64;\n names = [\"unsafe-array-syntax-without-parsing\"];\n description =\n \"-unsafe used with a preprocessor returning a syntax tree.\" };\n { number = 65;\n names = [\"redefining-unit\"];\n description = \"Type declaration defining a new '()' constructor.\" };\n { number = 66;\n names = [\"unused-open-bang\"];\n description = \"Unused open! statement.\" };\n { number = 67;\n names = [\"unused-functor-parameter\"];\n description = \"Unused functor parameter.\" };\n { number = 68;\n names = [\"match-on-mutable-state-prevent-uncurry\"];\n description =\n \"Pattern-matching depending on mutable state prevents the remaining \\n\\\n \\ arguments from being uncurried.\" };\n { number = 69;\n names = [\"unused-field\"];\n description = \"Unused record field.\" };\n { number = 70;\n names = [\"missing-mli\"];\n description = \"Missing interface file.\" };\n { number = 71;\n names = [\"unused-tmc-attribute\"];\n description = \"Unused @tail_mod_cons attribute\" };\n { number = 72;\n names = [\"tmc-breaks-tailcall\"];\n description = \"A tail call is turned into a non-tail call \\\n by the @tail_mod_cons transformation.\" };\n]\n;;\n\nlet name_to_number =\n let h = Hashtbl.create last_warning_number in\n List.iter (fun {number; names; _} ->\n List.iter (fun name -> Hashtbl.add h name number) names\n ) descriptions;\n fun s -> Hashtbl.find_opt h s\n;;\n\n(* Must be the max number returned by the [number] function. *)\n\nlet letter = function\n | 'a' ->\n let rec loop i = if i = 0 then [] else i :: loop (i - 1) in\n loop last_warning_number\n | 'b' -> []\n | 'c' -> [1; 2]\n | 'd' -> [3]\n | 'e' -> [4]\n | 'f' -> [5]\n | 'g' -> []\n | 'h' -> []\n | 'i' -> []\n | 'j' -> []\n | 'k' -> [32; 33; 34; 35; 36; 37; 38; 39]\n | 'l' -> [6]\n | 'm' -> [7]\n | 'n' -> []\n | 'o' -> []\n | 'p' -> [8]\n | 'q' -> []\n | 'r' -> [9]\n | 's' -> [10]\n | 't' -> []\n | 'u' -> [11; 12]\n | 'v' -> [13]\n | 'w' -> []\n | 'x' -> [14; 15; 16; 17; 18; 19; 20; 21; 22; 23; 24; 30]\n | 'y' -> [26]\n | 'z' -> [27]\n | _ -> assert false\n;;\n\ntype state =\n {\n active: bool array;\n error: bool array;\n alerts: (Misc.Stdlib.String.Set.t * bool); (* false:set complement *)\n alert_errors: (Misc.Stdlib.String.Set.t * bool); (* false:set complement *)\n }\n\nlet current =\n ref\n {\n active = Array.make (last_warning_number + 1) true;\n error = Array.make (last_warning_number + 1) false;\n alerts = (Misc.Stdlib.String.Set.empty, false); (* all enabled *)\n alert_errors = (Misc.Stdlib.String.Set.empty, true); (* all soft *)\n }\n\nlet disabled = ref false\n\nlet without_warnings f =\n Misc.protect_refs [Misc.R(disabled, true)] f\n\nlet backup () = !current\n\nlet restore x = current := x\n\nlet is_active x =\n not !disabled && (!current).active.(number x)\n\nlet is_error x =\n not !disabled && (!current).error.(number x)\n\nlet alert_is_active {kind; _} =\n not !disabled &&\n let (set, pos) = (!current).alerts in\n Misc.Stdlib.String.Set.mem kind set = pos\n\nlet alert_is_error {kind; _} =\n not !disabled &&\n let (set, pos) = (!current).alert_errors in\n Misc.Stdlib.String.Set.mem kind set = pos\n\nlet with_state state f =\n let prev = backup () in\n restore state;\n try\n let r = f () in\n restore prev;\n r\n with exn ->\n restore prev;\n raise exn\n\nlet mk_lazy f =\n let state = backup () in\n lazy (with_state state f)\n\nlet set_alert ~error ~enable s =\n let upd =\n match s with\n | \"all\" ->\n (Misc.Stdlib.String.Set.empty, not enable)\n | s ->\n let (set, pos) =\n if error then (!current).alert_errors else (!current).alerts\n in\n let f =\n if enable = pos\n then Misc.Stdlib.String.Set.add\n else Misc.Stdlib.String.Set.remove\n in\n (f s set, pos)\n in\n if error then\n current := {(!current) with alert_errors=upd}\n else\n current := {(!current) with alerts=upd}\n\nlet parse_alert_option s =\n let n = String.length s in\n let id_char = function\n | 'a'..'z' | 'A'..'Z' | '_' | '\\'' | '0'..'9' -> true\n | _ -> false\n in\n let rec parse_id i =\n if i < n && id_char s.[i] then parse_id (i + 1) else i\n in\n let rec scan i =\n if i = n then ()\n else if i + 1 = n then raise (Arg.Bad \"Ill-formed list of alert settings\")\n else match s.[i], s.[i+1] with\n | '+', '+' -> id (set_alert ~error:true ~enable:true) (i + 2)\n | '+', _ -> id (set_alert ~error:false ~enable:true) (i + 1)\n | '-', '-' -> id (set_alert ~error:true ~enable:false) (i + 2)\n | '-', _ -> id (set_alert ~error:false ~enable:false) (i + 1)\n | '@', _ ->\n id (fun s ->\n set_alert ~error:true ~enable:true s;\n set_alert ~error:false ~enable:true s)\n (i + 1)\n | _ -> raise (Arg.Bad \"Ill-formed list of alert settings\")\n and id f i =\n let j = parse_id i in\n if j = i then raise (Arg.Bad \"Ill-formed list of alert settings\");\n let id = String.sub s i (j - i) in\n f id;\n scan j\n in\n scan 0\n\ntype modifier =\n | Set (** +a *)\n | Clear (** -a *)\n | Set_all (** @a *)\n\ntype token =\n | Letter of char * modifier option\n | Num of int * int * modifier\n\nlet letter_alert tokens =\n let print_warning_char ppf c =\n let lowercase = Char.lowercase_ascii c = c in\n Format.fprintf ppf \"%c%c\"\n (if lowercase then '-' else '+') c\n in\n let print_modifier ppf = function\n | Set_all -> Format.fprintf ppf \"@\"\n | Clear -> Format.fprintf ppf \"-\"\n | Set -> Format.fprintf ppf \"+\"\n in\n let print_token ppf = function\n | Num (a,b,m) -> if a = b then\n Format.fprintf ppf \"%a%d\" print_modifier m a\n else\n Format.fprintf ppf \"%a%d..%d\" print_modifier m a b\n | Letter(l,Some m) -> Format.fprintf ppf \"%a%c\" print_modifier m l\n | Letter(l,None) -> print_warning_char ppf l\n in\n let consecutive_letters =\n (* we are tracking sequences of 2 or more consecutive unsigned letters\n in warning strings, for instance in '-w \"not-principa\"'. *)\n let commit_chunk l = function\n | [] | [ _ ] -> l\n | _ :: _ :: _ as chunk -> List.rev chunk :: l\n in\n let group_consecutive_letters (l,current) = function\n | Letter (x, None) -> (l, x::current)\n | _ -> (commit_chunk l current, [])\n in\n let l, on_going =\n List.fold_left group_consecutive_letters ([],[]) tokens\n in\n commit_chunk l on_going\n in\n match consecutive_letters with\n | [] -> None\n | example :: _ ->\n let pos = { Lexing.dummy_pos with pos_fname = \"_none_\" } in\n let nowhere = { loc_start=pos; loc_end=pos; loc_ghost=true } in\n let spelling_hint ppf =\n let max_seq_len =\n List.fold_left (fun l x -> Int.max l (List.length x))\n 0 consecutive_letters\n in\n if max_seq_len >= 5 then\n Format.fprintf ppf\n \"@ @[Hint: Did you make a spelling mistake \\\n when using a mnemonic name?@]\"\n else\n ()\n in\n let message =\n Format.asprintf\n \"@[@[Setting a warning with a sequence of lowercase \\\n or uppercase letters,@ like '%a',@ is deprecated.@]@ \\\n @[Use the equivalent signed form:@ %t.@]@ \\\n @[Hint: Enabling or disabling a warning by its mnemonic name \\\n requires a + or - prefix.@]\\\n %t@?@]\"\n Format.(pp_print_list ~pp_sep:(fun _ -> ignore) pp_print_char) example\n (fun ppf -> List.iter (print_token ppf) tokens)\n spelling_hint\n in\n Some {\n kind=\"ocaml_deprecated_cli\";\n use=nowhere; def=nowhere;\n message\n }\n\n\nlet parse_warnings s =\n let error () = raise (Arg.Bad \"Ill-formed list of warnings\") in\n let rec get_num n i =\n if i >= String.length s then i, n\n else match s.[i] with\n | '0'..'9' -> get_num (10 * n + Char.code s.[i] - Char.code '0') (i + 1)\n | _ -> i, n\n in\n let get_range i =\n let i, n1 = get_num 0 i in\n if i + 2 < String.length s && s.[i] = '.' && s.[i + 1] = '.' then\n let i, n2 = get_num 0 (i + 2) in\n if n2 < n1 then error ();\n i, n1, n2\n else\n i, n1, n1\n in\n let rec loop tokens i =\n if i >= String.length s then List.rev tokens else\n match s.[i] with\n | 'A' .. 'Z' | 'a' .. 'z' ->\n loop (Letter(s.[i],None)::tokens) (i+1)\n | '+' -> loop_letter_num tokens Set (i+1)\n | '-' -> loop_letter_num tokens Clear (i+1)\n | '@' -> loop_letter_num tokens Set_all (i+1)\n | _ -> error ()\n and loop_letter_num tokens modifier i =\n if i >= String.length s then error () else\n match s.[i] with\n | '0' .. '9' ->\n let i, n1, n2 = get_range i in\n loop (Num(n1,n2,modifier)::tokens) i\n | 'A' .. 'Z' | 'a' .. 'z' ->\n loop (Letter(s.[i],Some modifier)::tokens) (i+1)\n | _ -> error ()\n in\n loop [] 0\n\nlet parse_opt error active errflag s =\n let flags = if errflag then error else active in\n let action modifier i = match modifier with\n | Set ->\n if i = 3 then set_alert ~error:errflag ~enable:true \"deprecated\"\n else flags.(i) <- true\n | Clear ->\n if i = 3 then set_alert ~error:errflag ~enable:false \"deprecated\"\n else flags.(i) <- false\n | Set_all ->\n if i = 3 then begin\n set_alert ~error:false ~enable:true \"deprecated\";\n set_alert ~error:true ~enable:true \"deprecated\"\n end\n else begin\n active.(i) <- true;\n error.(i) <- true\n end\n in\n let eval = function\n | Letter(c, m) ->\n let lc = Char.lowercase_ascii c in\n let modifier = match m with\n | None -> if c = lc then Clear else Set\n | Some m -> m\n in\n List.iter (action modifier) (letter lc)\n | Num(n1,n2,modifier) ->\n for n = n1 to Int.min n2 last_warning_number do action modifier n done\n in\n let parse_and_eval s =\n let tokens = parse_warnings s in\n List.iter eval tokens;\n letter_alert tokens\n in\n match name_to_number s with\n | Some n -> action Set n; None\n | None ->\n if s = \"\" then parse_and_eval s\n else begin\n let rest = String.sub s 1 (String.length s - 1) in\n match s.[0], name_to_number rest with\n | '+', Some n -> action Set n; None\n | '-', Some n -> action Clear n; None\n | '@', Some n -> action Set_all n; None\n | _ -> parse_and_eval s\n end\n;;\n\nlet parse_options errflag s =\n let error = Array.copy (!current).error in\n let active = Array.copy (!current).active in\n let alerts = parse_opt error active errflag s in\n current := {(!current) with error; active};\n alerts\n\n(* If you change these, don't forget to change them in man/ocamlc.m *)\nlet defaults_w = \"+a-4-7-9-27-29-30-32..42-44-45-48-50-60-66..70\";;\nlet defaults_warn_error = \"-a+31\";;\n\nlet () = ignore @@ parse_options false defaults_w;;\nlet () = ignore @@ parse_options true defaults_warn_error;;\n\nlet ref_manual_explanation () =\n (* manual references are checked a posteriori by the manual\n cross-reference consistency check in manual/tests*)\n let[@manual.ref \"s:comp-warnings\"] chapter, section = 11, 5 in\n Printf.sprintf \"(See manual section %d.%d)\" chapter section\n\nlet message = function\n | Comment_start ->\n \"this `(*' is the start of a comment.\\n\\\n Hint: Did you forget spaces when writing the infix operator `( * )'?\"\n | Comment_not_end -> \"this is not the end of a comment.\"\n | Fragile_match \"\" ->\n \"this pattern-matching is fragile.\"\n | Fragile_match s ->\n \"this pattern-matching is fragile.\\n\\\n It will remain exhaustive when constructors are added to type \" ^ s ^ \".\"\n | Ignored_partial_application ->\n \"this function application is partial,\\n\\\n maybe some arguments are missing.\"\n | Labels_omitted [] -> assert false\n | Labels_omitted [l] ->\n \"label \" ^ l ^ \" was omitted in the application of this function.\"\n | Labels_omitted ls ->\n \"labels \" ^ String.concat \", \" ls ^\n \" were omitted in the application of this function.\"\n | Method_override [lab] ->\n \"the method \" ^ lab ^ \" is overridden.\"\n | Method_override (cname :: slist) ->\n String.concat \" \"\n (\"the following methods are overridden by the class\"\n :: cname :: \":\\n \" :: slist)\n | Method_override [] -> assert false\n | Partial_match \"\" -> \"this pattern-matching is not exhaustive.\"\n | Partial_match s ->\n \"this pattern-matching is not exhaustive.\\n\\\n Here is an example of a case that is not matched:\\n\" ^ s\n | Missing_record_field_pattern s ->\n \"the following labels are not bound in this record pattern:\\n\" ^ s ^\n \"\\nEither bind these labels explicitly or add '; _' to the pattern.\"\n | Non_unit_statement ->\n \"this expression should have type unit.\"\n | Redundant_case -> \"this match case is unused.\"\n | Redundant_subpat -> \"this sub-pattern is unused.\"\n | Instance_variable_override [lab] ->\n \"the instance variable \" ^ lab ^ \" is overridden.\"\n | Instance_variable_override (cname :: slist) ->\n String.concat \" \"\n (\"the following instance variables are overridden by the class\"\n :: cname :: \":\\n \" :: slist)\n | Instance_variable_override [] -> assert false\n | Illegal_backslash -> \"illegal backslash escape in string.\"\n | Implicit_public_methods l ->\n \"the following private methods were made public implicitly:\\n \"\n ^ String.concat \" \" l ^ \".\"\n | Unerasable_optional_argument -> \"this optional argument cannot be erased.\"\n | Undeclared_virtual_method m -> \"the virtual method \"^m^\" is not declared.\"\n | Not_principal s -> s^\" is not principal.\"\n | Non_principal_labels s -> s^\" without principality.\"\n | Ignored_extra_argument -> \"this argument will not be used by the function.\"\n | Nonreturning_statement ->\n \"this statement never returns (or has an unsound type.)\"\n | Preprocessor s -> s\n | Useless_record_with ->\n \"all the fields are explicitly listed in this record:\\n\\\n the 'with' clause is useless.\"\n | Bad_module_name (modname) ->\n \"bad source file name: \\\"\" ^ modname ^ \"\\\" is not a valid module name.\"\n | All_clauses_guarded ->\n \"this pattern-matching is not exhaustive.\\n\\\n All clauses in this pattern-matching are guarded.\"\n | Unused_var v | Unused_var_strict v -> \"unused variable \" ^ v ^ \".\"\n | Wildcard_arg_to_constant_constr ->\n \"wildcard pattern given as argument to a constant constructor\"\n | Eol_in_string ->\n \"unescaped end-of-line in a string constant (non-portable code)\"\n | Duplicate_definitions (kind, cname, tc1, tc2) ->\n Printf.sprintf \"the %s %s is defined in both types %s and %s.\"\n kind cname tc1 tc2\n | Module_linked_twice(modname, file1, file2) ->\n Printf.sprintf\n \"files %s and %s both define a module named %s\"\n file1 file2 modname\n | Unused_value_declaration v -> \"unused value \" ^ v ^ \".\"\n | Unused_open s -> \"unused open \" ^ s ^ \".\"\n | Unused_open_bang s -> \"unused open! \" ^ s ^ \".\"\n | Unused_type_declaration s -> \"unused type \" ^ s ^ \".\"\n | Unused_for_index s -> \"unused for-loop index \" ^ s ^ \".\"\n | Unused_ancestor s -> \"unused ancestor variable \" ^ s ^ \".\"\n | Unused_constructor (s, Unused) -> \"unused constructor \" ^ s ^ \".\"\n | Unused_constructor (s, Not_constructed) ->\n \"constructor \" ^ s ^\n \" is never used to build values.\\n\\\n (However, this constructor appears in patterns.)\"\n | Unused_constructor (s, Only_exported_private) ->\n \"constructor \" ^ s ^\n \" is never used to build values.\\n\\\n Its type is exported as a private type.\"\n | Unused_extension (s, is_exception, complaint) ->\n let kind =\n if is_exception then \"exception\" else \"extension constructor\" in\n let name = kind ^ \" \" ^ s in\n begin match complaint with\n | Unused -> \"unused \" ^ name\n | Not_constructed ->\n name ^\n \" is never used to build values.\\n\\\n (However, this constructor appears in patterns.)\"\n | Only_exported_private ->\n name ^\n \" is never used to build values.\\n\\\n It is exported or rebound as a private extension.\"\n end\n | Unused_rec_flag ->\n \"unused rec flag.\"\n | Name_out_of_scope (ty, [nm], false) ->\n nm ^ \" was selected from type \" ^ ty ^\n \".\\nIt is not visible in the current scope, and will not \\n\\\n be selected if the type becomes unknown.\"\n | Name_out_of_scope (_, _, false) -> assert false\n | Name_out_of_scope (ty, slist, true) ->\n \"this record of type \"^ ty ^\" contains fields that are \\n\\\n not visible in the current scope: \"\n ^ String.concat \" \" slist ^ \".\\n\\\n They will not be selected if the type becomes unknown.\"\n | Ambiguous_name ([s], tl, false, expansion) ->\n s ^ \" belongs to several types: \" ^ String.concat \" \" tl ^\n \"\\nThe first one was selected. Please disambiguate if this is wrong.\"\n ^ expansion\n | Ambiguous_name (_, _, false, _ ) -> assert false\n | Ambiguous_name (_slist, tl, true, expansion) ->\n \"these field labels belong to several types: \" ^\n String.concat \" \" tl ^\n \"\\nThe first one was selected. Please disambiguate if this is wrong.\"\n ^ expansion\n | Disambiguated_name s ->\n \"this use of \" ^ s ^ \" relies on type-directed disambiguation,\\n\\\n it will not compile with OCaml 4.00 or earlier.\"\n | Nonoptional_label s ->\n \"the label \" ^ s ^ \" is not optional.\"\n | Open_shadow_identifier (kind, s) ->\n Printf.sprintf\n \"this open statement shadows the %s identifier %s (which is later used)\"\n kind s\n | Open_shadow_label_constructor (kind, s) ->\n Printf.sprintf\n \"this open statement shadows the %s %s (which is later used)\"\n kind s\n | Bad_env_variable (var, s) ->\n Printf.sprintf \"illegal environment variable %s : %s\" var s\n | Attribute_payload (a, s) ->\n Printf.sprintf \"illegal payload for attribute '%s'.\\n%s\" a s\n | Eliminated_optional_arguments sl ->\n Printf.sprintf \"implicit elimination of optional argument%s %s\"\n (if List.length sl = 1 then \"\" else \"s\")\n (String.concat \", \" sl)\n | No_cmi_file(name, None) ->\n \"no cmi file was found in path for module \" ^ name\n | No_cmi_file(name, Some msg) ->\n Printf.sprintf\n \"no valid cmi file was found in path for module %s. %s\"\n name msg\n | Unexpected_docstring unattached ->\n if unattached then \"unattached documentation comment (ignored)\"\n else \"ambiguous documentation comment\"\n | Wrong_tailcall_expectation b ->\n Printf.sprintf \"expected %s\"\n (if b then \"tailcall\" else \"non-tailcall\")\n | Fragile_literal_pattern ->\n Printf.sprintf\n \"Code should not depend on the actual values of\\n\\\n this constructor's arguments. They are only for information\\n\\\n and may change in future versions. %t\" ref_manual_explanation\n | Unreachable_case ->\n \"this match case is unreachable.\\n\\\n Consider replacing it with a refutation case ' -> .'\"\n | Misplaced_attribute attr_name ->\n Printf.sprintf \"the %S attribute cannot appear in this context\" attr_name\n | Duplicated_attribute attr_name ->\n Printf.sprintf \"the %S attribute is used more than once on this \\\n expression\"\n attr_name\n | Inlining_impossible reason ->\n Printf.sprintf \"Cannot inline: %s\" reason\n | Ambiguous_var_in_pattern_guard vars ->\n let vars = List.sort String.compare vars in\n let vars_explanation =\n let in_different_places =\n \"in different places in different or-pattern alternatives\"\n in\n match vars with\n | [] -> assert false\n | [x] -> \"variable \" ^ x ^ \" appears \" ^ in_different_places\n | _::_ ->\n let vars = String.concat \", \" vars in\n \"variables \" ^ vars ^ \" appear \" ^ in_different_places\n in\n Printf.sprintf\n \"Ambiguous or-pattern variables under guard;\\n\\\n %s.\\n\\\n Only the first match will be used to evaluate the guard expression.\\n\\\n %t\"\n vars_explanation ref_manual_explanation\n | No_cmx_file name ->\n Printf.sprintf\n \"no cmx file was found in path for module %s, \\\n and its interface was not compiled with -opaque\" name\n | Flambda_assignment_to_non_mutable_value ->\n \"A potential assignment to a non-mutable value was detected \\n\\\n in this source file. Such assignments may generate incorrect code \\n\\\n when using Flambda.\"\n | Unused_module s -> \"unused module \" ^ s ^ \".\"\n | Unboxable_type_in_prim_decl t ->\n Printf.sprintf\n \"This primitive declaration uses type %s, whose representation\\n\\\n may be either boxed or unboxed. Without an annotation to indicate\\n\\\n which representation is intended, the boxed representation has been\\n\\\n selected by default. This default choice may change in future\\n\\\n versions of the compiler, breaking the primitive implementation.\\n\\\n You should explicitly annotate the declaration of %s\\n\\\n with [@@boxed] or [@@unboxed], so that its external interface\\n\\\n remains stable in the future.\" t t\n | Constraint_on_gadt ->\n \"Type constraints do not apply to GADT cases of variant types.\"\n | Erroneous_printed_signature s ->\n \"The printed interface differs from the inferred interface.\\n\\\n The inferred interface contained items which could not be printed\\n\\\n properly due to name collisions between identifiers.\"\n ^ s\n ^ \"\\nBeware that this warning is purely informational and will not catch\\n\\\n all instances of erroneous printed interface.\"\n | Unsafe_array_syntax_without_parsing ->\n \"option -unsafe used with a preprocessor returning a syntax tree\"\n | Redefining_unit name ->\n Printf.sprintf\n \"This type declaration is defining a new '()' constructor\\n\\\n which shadows the existing one.\\n\\\n Hint: Did you mean 'type %s = unit'?\" name\n | Unused_functor_parameter s -> \"unused functor parameter \" ^ s ^ \".\"\n | Match_on_mutable_state_prevent_uncurry ->\n \"This pattern depends on mutable state.\\n\\\n It prevents the remaining arguments from being uncurried, which will \\\n cause additional closure allocations.\"\n | Unused_field (s, Unused) -> \"unused record field \" ^ s ^ \".\"\n | Unused_field (s, Not_read) ->\n \"record field \" ^ s ^\n \" is never read.\\n\\\n (However, this field is used to build or mutate values.)\"\n | Unused_field (s, Not_mutated) ->\n \"mutable record field \" ^ s ^\n \" is never mutated.\"\n | Missing_mli ->\n \"Cannot find interface file.\"\n | Unused_tmc_attribute ->\n \"This function is marked @tail_mod_cons\\n\\\n but is never applied in TMC position.\"\n | Tmc_breaks_tailcall ->\n \"This call\\n\\\n is in tail-modulo-cons positionin a TMC function,\\n\\\n but the function called is not itself specialized for TMC,\\n\\\n so the call will not be transformed into a tail call.\\n\\\n Please either mark the called function with the [@tail_mod_cons]\\n\\\n attribute, or mark this call with the [@tailcall false] attribute\\n\\\n to make its non-tailness explicit.\"\n;;\n\nlet nerrors = ref 0;;\n\ntype reporting_information =\n { id : string\n ; message : string\n ; is_error : bool\n ; sub_locs : (loc * string) list;\n }\n\nlet id_name w =\n let n = number w in\n match List.find_opt (fun {number; _} -> number = n) descriptions with\n | Some {names = s :: _; _} ->\n Printf.sprintf \"%d [%s]\" n s\n | _ ->\n string_of_int n\n\nlet report w =\n match is_active w with\n | false -> `Inactive\n | true ->\n if is_error w then incr nerrors;\n `Active\n { id = id_name w;\n message = message w;\n is_error = is_error w;\n sub_locs = [];\n }\n\nlet report_alert (alert : alert) =\n match alert_is_active alert with\n | false -> `Inactive\n | true ->\n let is_error = alert_is_error alert in\n if is_error then incr nerrors;\n let message = Misc.normalise_eol alert.message in\n (* Reduce \\r\\n to \\n:\n - Prevents any \\r characters being printed on Unix when processing\n Windows sources\n - Prevents \\r\\r\\n being generated on Windows, which affects the\n testsuite\n *)\n let sub_locs =\n if not alert.def.loc_ghost && not alert.use.loc_ghost then\n [\n alert.def, \"Definition\";\n alert.use, \"Expected signature\";\n ]\n else\n []\n in\n `Active\n {\n id = alert.kind;\n message;\n is_error;\n sub_locs;\n }\n\nexception Errors;;\n\nlet reset_fatal () =\n nerrors := 0\n\nlet check_fatal () =\n if !nerrors > 0 then begin\n nerrors := 0;\n raise Errors;\n end;\n;;\n\nlet help_warnings () =\n List.iter\n (fun {number; description; names} ->\n let name =\n match names with\n | s :: _ -> \" [\" ^ s ^ \"]\"\n | [] -> \"\"\n in\n Printf.printf \"%3i%s %s\\n\" number name description)\n descriptions;\n print_endline \" A all warnings\";\n for i = Char.code 'b' to Char.code 'z' do\n let c = Char.chr i in\n match letter c with\n | [] -> ()\n | [n] ->\n Printf.printf \" %c Alias for warning %i.\\n\" (Char.uppercase_ascii c) n\n | l ->\n Printf.printf \" %c warnings %s.\\n\"\n (Char.uppercase_ascii c)\n (String.concat \", \" (List.map Int.to_string l))\n done;\n exit 0\n;;\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Leo White *)\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 Location\n\n(* Docstrings *)\n\n(* A docstring is \"attached\" if it has been inserted in the AST. This\n is used for generating unexpected docstring warnings. *)\ntype ds_attached =\n | Unattached (* Not yet attached anything.*)\n | Info (* Attached to a field or constructor. *)\n | Docs (* Attached to an item or as floating text. *)\n\n(* A docstring is \"associated\" with an item if there are no blank lines between\n them. This is used for generating docstring ambiguity warnings. *)\ntype ds_associated =\n | Zero (* Not associated with an item *)\n | One (* Associated with one item *)\n | Many (* Associated with multiple items (ambiguity) *)\n\ntype docstring =\n { ds_body: string;\n ds_loc: Location.t;\n mutable ds_attached: ds_attached;\n mutable ds_associated: ds_associated; }\n\n(* List of docstrings *)\n\nlet docstrings : docstring list ref = ref []\n\n(* Warn for unused and ambiguous docstrings *)\n\nlet warn_bad_docstrings () =\n if Warnings.is_active (Warnings.Unexpected_docstring true) then begin\n List.iter\n (fun ds ->\n match ds.ds_attached with\n | Info -> ()\n | Unattached ->\n prerr_warning ds.ds_loc (Warnings.Unexpected_docstring true)\n | Docs ->\n match ds.ds_associated with\n | Zero | One -> ()\n | Many ->\n prerr_warning ds.ds_loc (Warnings.Unexpected_docstring false))\n (List.rev !docstrings)\nend\n\n(* Docstring constructors and destructors *)\n\nlet docstring body loc =\n let ds =\n { ds_body = body;\n ds_loc = loc;\n ds_attached = Unattached;\n ds_associated = Zero; }\n in\n ds\n\nlet register ds =\n docstrings := ds :: !docstrings\n\nlet docstring_body ds = ds.ds_body\n\nlet docstring_loc ds = ds.ds_loc\n\n(* Docstrings attached to items *)\n\ntype docs =\n { docs_pre: docstring option;\n docs_post: docstring option; }\n\nlet empty_docs = { docs_pre = None; docs_post = None }\n\nlet doc_loc = {txt = \"ocaml.doc\"; loc = Location.none}\n\nlet docs_attr ds =\n let open Parsetree in\n let body = ds.ds_body in\n let loc = ds.ds_loc in\n let exp =\n { pexp_desc = Pexp_constant (Pconst_string(body, loc, None));\n pexp_loc = loc;\n pexp_loc_stack = [];\n pexp_attributes = []; }\n in\n let item =\n { pstr_desc = Pstr_eval (exp, []); pstr_loc = loc }\n in\n { attr_name = doc_loc;\n attr_payload = PStr [item];\n attr_loc = loc }\n\nlet add_docs_attrs docs attrs =\n let attrs =\n match docs.docs_pre with\n | None | Some { ds_body=\"\"; _ } -> attrs\n | Some ds -> docs_attr ds :: attrs\n in\n let attrs =\n match docs.docs_post with\n | None | Some { ds_body=\"\"; _ } -> attrs\n | Some ds -> attrs @ [docs_attr ds]\n in\n attrs\n\n(* Docstrings attached to constructors or fields *)\n\ntype info = docstring option\n\nlet empty_info = None\n\nlet info_attr = docs_attr\n\nlet add_info_attrs info attrs =\n match info with\n | None | Some {ds_body=\"\"; _} -> attrs\n | Some ds -> attrs @ [info_attr ds]\n\n(* Docstrings not attached to a specific item *)\n\ntype text = docstring list\n\nlet empty_text = []\nlet empty_text_lazy = lazy []\n\nlet text_loc = {txt = \"ocaml.text\"; loc = Location.none}\n\nlet text_attr ds =\n let open Parsetree in\n let body = ds.ds_body in\n let loc = ds.ds_loc in\n let exp =\n { pexp_desc = Pexp_constant (Pconst_string(body, loc, None));\n pexp_loc = loc;\n pexp_loc_stack = [];\n pexp_attributes = []; }\n in\n let item =\n { pstr_desc = Pstr_eval (exp, []); pstr_loc = loc }\n in\n { attr_name = text_loc;\n attr_payload = PStr [item];\n attr_loc = loc }\n\nlet add_text_attrs dsl attrs =\n let fdsl = List.filter (function {ds_body=\"\"} -> false| _ ->true) dsl in\n (List.map text_attr fdsl) @ attrs\n\n(* Find the first non-info docstring in a list, attach it and return it *)\nlet get_docstring ~info dsl =\n let rec loop = function\n | [] -> None\n | {ds_attached = Info; _} :: rest -> loop rest\n | ds :: _ ->\n ds.ds_attached <- if info then Info else Docs;\n Some ds\n in\n loop dsl\n\n(* Find all the non-info docstrings in a list, attach them and return them *)\nlet get_docstrings dsl =\n let rec loop acc = function\n | [] -> List.rev acc\n | {ds_attached = Info; _} :: rest -> loop acc rest\n | ds :: rest ->\n ds.ds_attached <- Docs;\n loop (ds :: acc) rest\n in\n loop [] dsl\n\n(* \"Associate\" all the docstrings in a list *)\nlet associate_docstrings dsl =\n List.iter\n (fun ds ->\n match ds.ds_associated with\n | Zero -> ds.ds_associated <- One\n | (One | Many) -> ds.ds_associated <- Many)\n dsl\n\n(* Map from positions to pre docstrings *)\n\nlet pre_table : (Lexing.position, docstring list) Hashtbl.t =\n Hashtbl.create 50\n\nlet set_pre_docstrings pos dsl =\n if dsl <> [] then Hashtbl.add pre_table pos dsl\n\nlet get_pre_docs pos =\n try\n let dsl = Hashtbl.find pre_table pos in\n associate_docstrings dsl;\n get_docstring ~info:false dsl\n with Not_found -> None\n\nlet mark_pre_docs pos =\n try\n let dsl = Hashtbl.find pre_table pos in\n associate_docstrings dsl\n with Not_found -> ()\n\n(* Map from positions to post docstrings *)\n\nlet post_table : (Lexing.position, docstring list) Hashtbl.t =\n Hashtbl.create 50\n\nlet set_post_docstrings pos dsl =\n if dsl <> [] then Hashtbl.add post_table pos dsl\n\nlet get_post_docs pos =\n try\n let dsl = Hashtbl.find post_table pos in\n associate_docstrings dsl;\n get_docstring ~info:false dsl\n with Not_found -> None\n\nlet mark_post_docs pos =\n try\n let dsl = Hashtbl.find post_table pos in\n associate_docstrings dsl\n with Not_found -> ()\n\nlet get_info pos =\n try\n let dsl = Hashtbl.find post_table pos in\n get_docstring ~info:true dsl\n with Not_found -> None\n\n(* Map from positions to floating docstrings *)\n\nlet floating_table : (Lexing.position, docstring list) Hashtbl.t =\n Hashtbl.create 50\n\nlet set_floating_docstrings pos dsl =\n if dsl <> [] then Hashtbl.add floating_table pos dsl\n\nlet get_text pos =\n try\n let dsl = Hashtbl.find floating_table pos in\n get_docstrings dsl\n with Not_found -> []\n\nlet get_post_text pos =\n try\n let dsl = Hashtbl.find post_table pos in\n get_docstrings dsl\n with Not_found -> []\n\n(* Maps from positions to extra docstrings *)\n\nlet pre_extra_table : (Lexing.position, docstring list) Hashtbl.t =\n Hashtbl.create 50\n\nlet set_pre_extra_docstrings pos dsl =\n if dsl <> [] then Hashtbl.add pre_extra_table pos dsl\n\nlet get_pre_extra_text pos =\n try\n let dsl = Hashtbl.find pre_extra_table pos in\n get_docstrings dsl\n with Not_found -> []\n\nlet post_extra_table : (Lexing.position, docstring list) Hashtbl.t =\n Hashtbl.create 50\n\nlet set_post_extra_docstrings pos dsl =\n if dsl <> [] then Hashtbl.add post_extra_table pos dsl\n\nlet get_post_extra_text pos =\n try\n let dsl = Hashtbl.find post_extra_table pos in\n get_docstrings dsl\n with Not_found -> []\n\n(* Docstrings from parser actions *)\nmodule WithParsing = struct\nlet symbol_docs () =\n { docs_pre = get_pre_docs (Parsing.symbol_start_pos ());\n docs_post = get_post_docs (Parsing.symbol_end_pos ()); }\n\nlet symbol_docs_lazy () =\n let p1 = Parsing.symbol_start_pos () in\n let p2 = Parsing.symbol_end_pos () in\n lazy { docs_pre = get_pre_docs p1;\n docs_post = get_post_docs p2; }\n\nlet rhs_docs pos1 pos2 =\n { docs_pre = get_pre_docs (Parsing.rhs_start_pos pos1);\n docs_post = get_post_docs (Parsing.rhs_end_pos pos2); }\n\nlet rhs_docs_lazy pos1 pos2 =\n let p1 = Parsing.rhs_start_pos pos1 in\n let p2 = Parsing.rhs_end_pos pos2 in\n lazy { docs_pre = get_pre_docs p1;\n docs_post = get_post_docs p2; }\n\nlet mark_symbol_docs () =\n mark_pre_docs (Parsing.symbol_start_pos ());\n mark_post_docs (Parsing.symbol_end_pos ())\n\nlet mark_rhs_docs pos1 pos2 =\n mark_pre_docs (Parsing.rhs_start_pos pos1);\n mark_post_docs (Parsing.rhs_end_pos pos2)\n\nlet symbol_info () =\n get_info (Parsing.symbol_end_pos ())\n\nlet rhs_info pos =\n get_info (Parsing.rhs_end_pos pos)\n\nlet symbol_text () =\n get_text (Parsing.symbol_start_pos ())\n\nlet symbol_text_lazy () =\n let pos = Parsing.symbol_start_pos () in\n lazy (get_text pos)\n\nlet rhs_text pos =\n get_text (Parsing.rhs_start_pos pos)\n\nlet rhs_post_text pos =\n get_post_text (Parsing.rhs_end_pos pos)\n\nlet rhs_text_lazy pos =\n let pos = Parsing.rhs_start_pos pos in\n lazy (get_text pos)\n\nlet symbol_pre_extra_text () =\n get_pre_extra_text (Parsing.symbol_start_pos ())\n\nlet symbol_post_extra_text () =\n get_post_extra_text (Parsing.symbol_end_pos ())\n\nlet rhs_pre_extra_text pos =\n get_pre_extra_text (Parsing.rhs_start_pos pos)\n\nlet rhs_post_extra_text pos =\n get_post_extra_text (Parsing.rhs_end_pos pos)\nend\n\ninclude WithParsing\n\nmodule WithMenhir = struct\nlet symbol_docs (startpos, endpos) =\n { docs_pre = get_pre_docs startpos;\n docs_post = get_post_docs endpos; }\n\nlet symbol_docs_lazy (p1, p2) =\n lazy { docs_pre = get_pre_docs p1;\n docs_post = get_post_docs p2; }\n\nlet rhs_docs pos1 pos2 =\n { docs_pre = get_pre_docs pos1;\n docs_post = get_post_docs pos2; }\n\nlet rhs_docs_lazy p1 p2 =\n lazy { docs_pre = get_pre_docs p1;\n docs_post = get_post_docs p2; }\n\nlet mark_symbol_docs (startpos, endpos) =\n mark_pre_docs startpos;\n mark_post_docs endpos;\n ()\n\nlet mark_rhs_docs pos1 pos2 =\n mark_pre_docs pos1;\n mark_post_docs pos2;\n ()\n\nlet symbol_info endpos =\n get_info endpos\n\nlet rhs_info endpos =\n get_info endpos\n\nlet symbol_text startpos =\n get_text startpos\n\nlet symbol_text_lazy startpos =\n lazy (get_text startpos)\n\nlet rhs_text pos =\n get_text pos\n\nlet rhs_post_text pos =\n get_post_text pos\n\nlet rhs_text_lazy pos =\n lazy (get_text pos)\n\nlet symbol_pre_extra_text startpos =\n get_pre_extra_text startpos\n\nlet symbol_post_extra_text endpos =\n get_post_extra_text endpos\n\nlet rhs_pre_extra_text pos =\n get_pre_extra_text pos\n\nlet rhs_post_extra_text pos =\n get_post_extra_text pos\nend\n\n(* (Re)Initialise all comment state *)\n\nlet init () =\n docstrings := [];\n Hashtbl.reset pre_table;\n Hashtbl.reset post_table;\n Hashtbl.reset floating_table;\n Hashtbl.reset pre_extra_table;\n Hashtbl.reset post_extra_table\n","\n(* This generated code requires the following version of CamlinternalMenhirLib: *)\n\nlet () =\n CamlinternalMenhirLib.StaticVersion.require_20210419\n\nmodule MenhirBasics = struct\n \n exception Error = Parsing.Parse_error\n \n type token = \n | WITH\n | WHILE\n | WHEN\n | VIRTUAL\n | VAL\n | UNDERSCORE\n | UIDENT of (\n# 756 \"parsing/parser.mly\"\n (string)\n# 22 \"parsing/parser.ml\"\n )\n | TYPE\n | TRY\n | TRUE\n | TO\n | TILDE\n | THEN\n | STRUCT\n | STRING of (\n# 743 \"parsing/parser.mly\"\n (string * Location.t * string option)\n# 34 \"parsing/parser.ml\"\n )\n | STAR\n | SIG\n | SEMISEMI\n | SEMI\n | RPAREN\n | REC\n | RBRACKET\n | RBRACE\n | QUOTED_STRING_ITEM of (\n# 747 \"parsing/parser.mly\"\n (string * Location.t * string * Location.t * string option)\n# 47 \"parsing/parser.ml\"\n )\n | QUOTED_STRING_EXPR of (\n# 745 \"parsing/parser.mly\"\n (string * Location.t * string * Location.t * string option)\n# 52 \"parsing/parser.ml\"\n )\n | QUOTE\n | QUESTION\n | PRIVATE\n | PREFIXOP of (\n# 729 \"parsing/parser.mly\"\n (string)\n# 60 \"parsing/parser.ml\"\n )\n | PLUSEQ\n | PLUSDOT\n | PLUS\n | PERCENT\n | OR\n | OPTLABEL of (\n# 722 \"parsing/parser.mly\"\n (string)\n# 70 \"parsing/parser.ml\"\n )\n | OPEN\n | OF\n | OBJECT\n | NONREC\n | NEW\n | MUTABLE\n | MODULE\n | MINUSGREATER\n | MINUSDOT\n | MINUS\n | METHOD\n | MATCH\n | LPAREN\n | LIDENT of (\n# 705 \"parsing/parser.mly\"\n (string)\n# 88 \"parsing/parser.ml\"\n )\n | LETOP of (\n# 687 \"parsing/parser.mly\"\n (string)\n# 93 \"parsing/parser.ml\"\n )\n | LET\n | LESSMINUS\n | LESS\n | LBRACKETPERCENTPERCENT\n | LBRACKETPERCENT\n | LBRACKETLESS\n | LBRACKETGREATER\n | LBRACKETBAR\n | LBRACKETATATAT\n | LBRACKETATAT\n | LBRACKETAT\n | LBRACKET\n | LBRACELESS\n | LBRACE\n | LAZY\n | LABEL of (\n# 692 \"parsing/parser.mly\"\n (string)\n# 113 \"parsing/parser.ml\"\n )\n | INT of (\n# 691 \"parsing/parser.mly\"\n (string * char option)\n# 118 \"parsing/parser.ml\"\n )\n | INITIALIZER\n | INHERIT\n | INFIXOP4 of (\n# 685 \"parsing/parser.mly\"\n (string)\n# 125 \"parsing/parser.ml\"\n )\n | INFIXOP3 of (\n# 684 \"parsing/parser.mly\"\n (string)\n# 130 \"parsing/parser.ml\"\n )\n | INFIXOP2 of (\n# 683 \"parsing/parser.mly\"\n (string)\n# 135 \"parsing/parser.ml\"\n )\n | INFIXOP1 of (\n# 682 \"parsing/parser.mly\"\n (string)\n# 140 \"parsing/parser.ml\"\n )\n | INFIXOP0 of (\n# 681 \"parsing/parser.mly\"\n (string)\n# 145 \"parsing/parser.ml\"\n )\n | INCLUDE\n | IN\n | IF\n | HASHOP of (\n# 740 \"parsing/parser.mly\"\n (string)\n# 153 \"parsing/parser.ml\"\n )\n | HASH\n | GREATERRBRACKET\n | GREATERRBRACE\n | GREATER\n | FUNCTOR\n | FUNCTION\n | FUN\n | FOR\n | FLOAT of (\n# 670 \"parsing/parser.mly\"\n (string * char option)\n# 166 \"parsing/parser.ml\"\n )\n | FALSE\n | EXTERNAL\n | EXCEPTION\n | EQUAL\n | EOL\n | EOF\n | END\n | ELSE\n | DOWNTO\n | DOTOP of (\n# 686 \"parsing/parser.mly\"\n (string)\n# 180 \"parsing/parser.ml\"\n )\n | DOTDOT\n | DOT\n | DONE\n | DOCSTRING of (\n# 764 \"parsing/parser.mly\"\n (Docstrings.docstring)\n# 188 \"parsing/parser.ml\"\n )\n | DO\n | CONSTRAINT\n | COMMENT of (\n# 763 \"parsing/parser.mly\"\n (string * Location.t)\n# 195 \"parsing/parser.ml\"\n )\n | COMMA\n | COLONGREATER\n | COLONEQUAL\n | COLONCOLON\n | COLON\n | CLASS\n | CHAR of (\n# 650 \"parsing/parser.mly\"\n (char)\n# 206 \"parsing/parser.ml\"\n )\n | BEGIN\n | BARRBRACKET\n | BARBAR\n | BAR\n | BANG\n | BACKQUOTE\n | ASSERT\n | AS\n | ANDOP of (\n# 688 \"parsing/parser.mly\"\n (string)\n# 219 \"parsing/parser.ml\"\n )\n | AND\n | AMPERSAND\n | AMPERAMPER\n \nend\n\ninclude MenhirBasics\n\nlet _eRR =\n MenhirBasics.Error\n\n# 25 \"parsing/parser.mly\"\n \n\nopen Asttypes\nopen Longident\nopen Parsetree\nopen Ast_helper\nopen Docstrings\nopen Docstrings.WithMenhir\n\nlet mkloc = Location.mkloc\nlet mknoloc = Location.mknoloc\n\nlet make_loc (startpos, endpos) = {\n Location.loc_start = startpos;\n Location.loc_end = endpos;\n Location.loc_ghost = false;\n}\n\nlet ghost_loc (startpos, endpos) = {\n Location.loc_start = startpos;\n Location.loc_end = endpos;\n Location.loc_ghost = true;\n}\n\nlet mktyp ~loc ?attrs d = Typ.mk ~loc:(make_loc loc) ?attrs d\nlet mkpat ~loc d = Pat.mk ~loc:(make_loc loc) d\nlet mkexp ~loc d = Exp.mk ~loc:(make_loc loc) d\nlet mkmty ~loc ?attrs d = Mty.mk ~loc:(make_loc loc) ?attrs d\nlet mksig ~loc d = Sig.mk ~loc:(make_loc loc) d\nlet mkmod ~loc ?attrs d = Mod.mk ~loc:(make_loc loc) ?attrs d\nlet mkstr ~loc d = Str.mk ~loc:(make_loc loc) d\nlet mkclass ~loc ?attrs d = Cl.mk ~loc:(make_loc loc) ?attrs d\nlet mkcty ~loc ?attrs d = Cty.mk ~loc:(make_loc loc) ?attrs d\n\nlet pstr_typext (te, ext) =\n (Pstr_typext te, ext)\nlet pstr_primitive (vd, ext) =\n (Pstr_primitive vd, ext)\nlet pstr_type ((nr, ext), tys) =\n (Pstr_type (nr, tys), ext)\nlet pstr_exception (te, ext) =\n (Pstr_exception te, ext)\nlet pstr_include (body, ext) =\n (Pstr_include body, ext)\nlet pstr_recmodule (ext, bindings) =\n (Pstr_recmodule bindings, ext)\n\nlet psig_typext (te, ext) =\n (Psig_typext te, ext)\nlet psig_value (vd, ext) =\n (Psig_value vd, ext)\nlet psig_type ((nr, ext), tys) =\n (Psig_type (nr, tys), ext)\nlet psig_typesubst ((nr, ext), tys) =\n assert (nr = Recursive); (* see [no_nonrec_flag] *)\n (Psig_typesubst tys, ext)\nlet psig_exception (te, ext) =\n (Psig_exception te, ext)\nlet psig_include (body, ext) =\n (Psig_include body, ext)\n\nlet mkctf ~loc ?attrs ?docs d =\n Ctf.mk ~loc:(make_loc loc) ?attrs ?docs d\nlet mkcf ~loc ?attrs ?docs d =\n Cf.mk ~loc:(make_loc loc) ?attrs ?docs d\n\nlet mkrhs rhs loc = mkloc rhs (make_loc loc)\nlet ghrhs rhs loc = mkloc rhs (ghost_loc loc)\n\nlet push_loc x acc =\n if x.Location.loc_ghost\n then acc\n else x :: acc\n\nlet reloc_pat ~loc x =\n { x with ppat_loc = make_loc loc;\n ppat_loc_stack = push_loc x.ppat_loc x.ppat_loc_stack };;\nlet reloc_exp ~loc x =\n { x with pexp_loc = make_loc loc;\n pexp_loc_stack = push_loc x.pexp_loc x.pexp_loc_stack };;\nlet reloc_typ ~loc x =\n { x with ptyp_loc = make_loc loc;\n ptyp_loc_stack = push_loc x.ptyp_loc x.ptyp_loc_stack };;\n\nlet mkexpvar ~loc (name : string) =\n mkexp ~loc (Pexp_ident(mkrhs (Lident name) loc))\n\nlet mkoperator =\n mkexpvar\n\nlet mkpatvar ~loc name =\n mkpat ~loc (Ppat_var (mkrhs name loc))\n\n(*\n Ghost expressions and patterns:\n expressions and patterns that do not appear explicitly in the\n source file they have the loc_ghost flag set to true.\n Then the profiler will not try to instrument them and the\n -annot option will not try to display their type.\n\n Every grammar rule that generates an element with a location must\n make at most one non-ghost element, the topmost one.\n\n How to tell whether your location must be ghost:\n A location corresponds to a range of characters in the source file.\n If the location contains a piece of code that is syntactically\n valid (according to the documentation), and corresponds to the\n AST node, then the location must be real; in all other cases,\n it must be ghost.\n*)\nlet ghexp ~loc d = Exp.mk ~loc:(ghost_loc loc) d\nlet ghpat ~loc d = Pat.mk ~loc:(ghost_loc loc) d\nlet ghtyp ~loc d = Typ.mk ~loc:(ghost_loc loc) d\nlet ghloc ~loc d = { txt = d; loc = ghost_loc loc }\nlet ghstr ~loc d = Str.mk ~loc:(ghost_loc loc) d\nlet ghsig ~loc d = Sig.mk ~loc:(ghost_loc loc) d\n\nlet mkinfix arg1 op arg2 =\n Pexp_apply(op, [Nolabel, arg1; Nolabel, arg2])\n\nlet neg_string f =\n if String.length f > 0 && f.[0] = '-'\n then String.sub f 1 (String.length f - 1)\n else \"-\" ^ f\n\nlet mkuminus ~oploc name arg =\n match name, arg.pexp_desc with\n | \"-\", Pexp_constant(Pconst_integer (n,m)) ->\n Pexp_constant(Pconst_integer(neg_string n,m))\n | (\"-\" | \"-.\"), Pexp_constant(Pconst_float (f, m)) ->\n Pexp_constant(Pconst_float(neg_string f, m))\n | _ ->\n Pexp_apply(mkoperator ~loc:oploc (\"~\" ^ name), [Nolabel, arg])\n\nlet mkuplus ~oploc name arg =\n let desc = arg.pexp_desc in\n match name, desc with\n | \"+\", Pexp_constant(Pconst_integer _)\n | (\"+\" | \"+.\"), Pexp_constant(Pconst_float _) -> desc\n | _ ->\n Pexp_apply(mkoperator ~loc:oploc (\"~\" ^ name), [Nolabel, arg])\n\n(* TODO define an abstraction boundary between locations-as-pairs\n and locations-as-Location.t; it should be clear when we move from\n one world to the other *)\n\nlet mkexp_cons_desc consloc args =\n Pexp_construct(mkrhs (Lident \"::\") consloc, Some args)\nlet mkexp_cons ~loc consloc args =\n mkexp ~loc (mkexp_cons_desc consloc args)\n\nlet mkpat_cons_desc consloc args =\n Ppat_construct(mkrhs (Lident \"::\") consloc, Some ([], args))\nlet mkpat_cons ~loc consloc args =\n mkpat ~loc (mkpat_cons_desc consloc args)\n\nlet ghexp_cons_desc consloc args =\n Pexp_construct(ghrhs (Lident \"::\") consloc, Some args)\nlet ghpat_cons_desc consloc args =\n Ppat_construct(ghrhs (Lident \"::\") consloc, Some ([], args))\n\nlet rec mktailexp nilloc = let open Location in function\n [] ->\n let nil = ghloc ~loc:nilloc (Lident \"[]\") in\n Pexp_construct (nil, None), nilloc\n | e1 :: el ->\n let exp_el, el_loc = mktailexp nilloc el in\n let loc = (e1.pexp_loc.loc_start, snd el_loc) in\n let arg = ghexp ~loc (Pexp_tuple [e1; ghexp ~loc:el_loc exp_el]) in\n ghexp_cons_desc loc arg, loc\n\nlet rec mktailpat nilloc = let open Location in function\n [] ->\n let nil = ghloc ~loc:nilloc (Lident \"[]\") in\n Ppat_construct (nil, None), nilloc\n | p1 :: pl ->\n let pat_pl, el_loc = mktailpat nilloc pl in\n let loc = (p1.ppat_loc.loc_start, snd el_loc) in\n let arg = ghpat ~loc (Ppat_tuple [p1; ghpat ~loc:el_loc pat_pl]) in\n ghpat_cons_desc loc arg, loc\n\nlet mkstrexp e attrs =\n { pstr_desc = Pstr_eval (e, attrs); pstr_loc = e.pexp_loc }\n\nlet mkexp_constraint ~loc e (t1, t2) =\n match t1, t2 with\n | Some t, None -> mkexp ~loc (Pexp_constraint(e, t))\n | _, Some t -> mkexp ~loc (Pexp_coerce(e, t1, t))\n | None, None -> assert false\n\nlet mkexp_opt_constraint ~loc e = function\n | None -> e\n | Some constraint_ -> mkexp_constraint ~loc e constraint_\n\nlet mkpat_opt_constraint ~loc p = function\n | None -> p\n | Some typ -> mkpat ~loc (Ppat_constraint(p, typ))\n\nlet syntax_error () =\n raise Syntaxerr.Escape_error\n\nlet unclosed opening_name opening_loc closing_name closing_loc =\n raise(Syntaxerr.Error(Syntaxerr.Unclosed(make_loc opening_loc, opening_name,\n make_loc closing_loc, closing_name)))\n\nlet expecting loc nonterm =\n raise Syntaxerr.(Error(Expecting(make_loc loc, nonterm)))\n\n(* Using the function [not_expecting] in a semantic action means that this\n syntactic form is recognized by the parser but is in fact incorrect. This\n idiom is used in a few places to produce ad hoc syntax error messages. *)\n\n(* This idiom should be used as little as possible, because it confuses the\n analyses performed by Menhir. Because Menhir views the semantic action as\n opaque, it believes that this syntactic form is correct. This can lead\n [make generate-parse-errors] to produce sentences that cause an early\n (unexpected) syntax error and do not achieve the desired effect. This could\n also lead a completion system to propose completions which in fact are\n incorrect. In order to avoid these problems, the productions that use\n [not_expecting] should be marked with AVOID. *)\n\nlet not_expecting loc nonterm =\n raise Syntaxerr.(Error(Not_expecting(make_loc loc, nonterm)))\n\n(* Helper functions for desugaring array indexing operators *)\ntype paren_kind = Paren | Brace | Bracket\n\n(* We classify the dimension of indices: Bigarray distinguishes\n indices of dimension 1,2,3, or more. Similarly, user-defined\n indexing operator behave differently for indices of dimension 1\n or more.\n*)\ntype index_dim =\n | One\n | Two\n | Three\n | Many\ntype ('dot,'index) array_family = {\n\n name:\n Lexing.position * Lexing.position -> 'dot -> assign:bool -> paren_kind\n -> index_dim -> Longident.t Location.loc\n (*\n This functions computes the name of the explicit indexing operator\n associated with a sugared array indexing expression.\n\n For instance, for builtin arrays, if Clflags.unsafe is set,\n * [ a.[index] ] => [String.unsafe_get]\n * [ a.{x,y} <- 1 ] => [ Bigarray.Array2.unsafe_set]\n\n User-defined indexing operator follows a more local convention:\n * [ a .%(index)] => [ (.%()) ]\n * [ a.![1;2] <- 0 ] => [(.![;..]<-)]\n * [ a.My.Map.?(0) => [My.Map.(.?())]\n *);\n\n index:\n Lexing.position * Lexing.position -> paren_kind -> 'index\n -> index_dim * (arg_label * expression) list\n (*\n [index (start,stop) paren index] computes the dimension of the\n index argument and how it should be desugared when transformed\n to a list of arguments for the indexing operator.\n In particular, in both the Bigarray case and the user-defined case,\n beyond a certain dimension, multiple indices are packed into a single\n array argument:\n * [ a.(x) ] => [ [One, [Nolabel, <>] ]\n * [ a.{1,2} ] => [ [Two, [Nolabel, <<1>>; Nolabel, <<2>>] ]\n * [ a.{1,2,3,4} ] => [ [Many, [Nolabel, <<[|1;2;3;4|]>>] ] ]\n *);\n\n}\n\nlet bigarray_untuplify = function\n { pexp_desc = Pexp_tuple explist; pexp_loc = _ } -> explist\n | exp -> [exp]\n\nlet builtin_arraylike_name loc _ ~assign paren_kind n =\n let opname = if assign then \"set\" else \"get\" in\n let opname = if !Clflags.unsafe then \"unsafe_\" ^ opname else opname in\n let prefix = match paren_kind with\n | Paren -> Lident \"Array\"\n | Bracket -> Lident \"String\"\n | Brace ->\n let submodule_name = match n with\n | One -> \"Array1\"\n | Two -> \"Array2\"\n | Three -> \"Array3\"\n | Many -> \"Genarray\" in\n Ldot(Lident \"Bigarray\", submodule_name) in\n ghloc ~loc (Ldot(prefix,opname))\n\nlet builtin_arraylike_index loc paren_kind index = match paren_kind with\n | Paren | Bracket -> One, [Nolabel, index]\n | Brace ->\n (* Multi-indices for bigarray are comma-separated ([a.{1,2,3,4}]) *)\n match bigarray_untuplify index with\n | [x] -> One, [Nolabel, x]\n | [x;y] -> Two, [Nolabel, x; Nolabel, y]\n | [x;y;z] -> Three, [Nolabel, x; Nolabel, y; Nolabel, z]\n | coords -> Many, [Nolabel, ghexp ~loc (Pexp_array coords)]\n\nlet builtin_indexing_operators : (unit, expression) array_family =\n { index = builtin_arraylike_index; name = builtin_arraylike_name }\n\nlet paren_to_strings = function\n | Paren -> \"(\", \")\"\n | Bracket -> \"[\", \"]\"\n | Brace -> \"{\", \"}\"\n\nlet user_indexing_operator_name loc (prefix,ext) ~assign paren_kind n =\n let name =\n let assign = if assign then \"<-\" else \"\" in\n let mid = match n with\n | Many | Three | Two -> \";..\"\n | One -> \"\" in\n let left, right = paren_to_strings paren_kind in\n String.concat \"\" [\".\"; ext; left; mid; right; assign] in\n let lid = match prefix with\n | None -> Lident name\n | Some p -> Ldot(p,name) in\n ghloc ~loc lid\n\nlet user_index loc _ index =\n (* Multi-indices for user-defined operators are semicolon-separated\n ([a.%[1;2;3;4]]) *)\n match index with\n | [a] -> One, [Nolabel, a]\n | l -> Many, [Nolabel, mkexp ~loc (Pexp_array l)]\n\nlet user_indexing_operators:\n (Longident.t option * string, expression list) array_family\n = { index = user_index; name = user_indexing_operator_name }\n\nlet mk_indexop_expr array_indexing_operator ~loc\n (array,dot,paren,index,set_expr) =\n let assign = match set_expr with None -> false | Some _ -> true in\n let n, index = array_indexing_operator.index loc paren index in\n let fn = array_indexing_operator.name loc dot ~assign paren n in\n let set_arg = match set_expr with\n | None -> []\n | Some expr -> [Nolabel, expr] in\n let args = (Nolabel,array) :: index @ set_arg in\n mkexp ~loc (Pexp_apply(ghexp ~loc (Pexp_ident fn), args))\n\nlet indexop_unclosed_error loc_s s loc_e =\n let left, right = paren_to_strings s in\n unclosed left loc_s right loc_e\n\nlet lapply ~loc p1 p2 =\n if !Clflags.applicative_functors\n then Lapply(p1, p2)\n else raise (Syntaxerr.Error(\n Syntaxerr.Applicative_path (make_loc loc)))\n\n(* [loc_map] could be [Location.map]. *)\nlet loc_map (f : 'a -> 'b) (x : 'a Location.loc) : 'b Location.loc =\n { x with txt = f x.txt }\n\nlet make_ghost x = { x with loc = { x.loc with loc_ghost = true }}\n\nlet loc_last (id : Longident.t Location.loc) : string Location.loc =\n loc_map Longident.last id\n\nlet loc_lident (id : string Location.loc) : Longident.t Location.loc =\n loc_map (fun x -> Lident x) id\n\nlet exp_of_longident lid =\n let lid = loc_map (fun id -> Lident (Longident.last id)) lid in\n Exp.mk ~loc:lid.loc (Pexp_ident lid)\n\nlet exp_of_label lbl =\n Exp.mk ~loc:lbl.loc (Pexp_ident (loc_lident lbl))\n\nlet pat_of_label lbl =\n Pat.mk ~loc:lbl.loc (Ppat_var (loc_last lbl))\n\nlet mk_newtypes ~loc newtypes exp =\n let mkexp = mkexp ~loc in\n List.fold_right (fun newtype exp -> mkexp (Pexp_newtype (newtype, exp)))\n newtypes exp\n\nlet wrap_type_annotation ~loc newtypes core_type body =\n let mkexp, ghtyp = mkexp ~loc, ghtyp ~loc in\n let mk_newtypes = mk_newtypes ~loc in\n let exp = mkexp(Pexp_constraint(body,core_type)) in\n let exp = mk_newtypes newtypes exp in\n (exp, ghtyp(Ptyp_poly(newtypes, Typ.varify_constructors newtypes core_type)))\n\nlet wrap_exp_attrs ~loc body (ext, attrs) =\n let ghexp = ghexp ~loc in\n (* todo: keep exact location for the entire attribute *)\n let body = {body with pexp_attributes = attrs @ body.pexp_attributes} in\n match ext with\n | None -> body\n | Some id -> ghexp(Pexp_extension (id, PStr [mkstrexp body []]))\n\nlet mkexp_attrs ~loc d attrs =\n wrap_exp_attrs ~loc (mkexp ~loc d) attrs\n\nlet wrap_typ_attrs ~loc typ (ext, attrs) =\n (* todo: keep exact location for the entire attribute *)\n let typ = {typ with ptyp_attributes = attrs @ typ.ptyp_attributes} in\n match ext with\n | None -> typ\n | Some id -> ghtyp ~loc (Ptyp_extension (id, PTyp typ))\n\nlet wrap_pat_attrs ~loc pat (ext, attrs) =\n (* todo: keep exact location for the entire attribute *)\n let pat = {pat with ppat_attributes = attrs @ pat.ppat_attributes} in\n match ext with\n | None -> pat\n | Some id -> ghpat ~loc (Ppat_extension (id, PPat (pat, None)))\n\nlet mkpat_attrs ~loc d attrs =\n wrap_pat_attrs ~loc (mkpat ~loc d) attrs\n\nlet wrap_class_attrs ~loc:_ body attrs =\n {body with pcl_attributes = attrs @ body.pcl_attributes}\nlet wrap_mod_attrs ~loc:_ attrs body =\n {body with pmod_attributes = attrs @ body.pmod_attributes}\nlet wrap_mty_attrs ~loc:_ attrs body =\n {body with pmty_attributes = attrs @ body.pmty_attributes}\n\nlet wrap_str_ext ~loc body ext =\n match ext with\n | None -> body\n | Some id -> ghstr ~loc (Pstr_extension ((id, PStr [body]), []))\n\nlet wrap_mkstr_ext ~loc (item, ext) =\n wrap_str_ext ~loc (mkstr ~loc item) ext\n\nlet wrap_sig_ext ~loc body ext =\n match ext with\n | None -> body\n | Some id -> ghsig ~loc (Psig_extension ((id, PSig [body]), []))\n\nlet wrap_mksig_ext ~loc (item, ext) =\n wrap_sig_ext ~loc (mksig ~loc item) ext\n\nlet mk_quotedext ~loc (id, idloc, str, strloc, delim) =\n let exp_id = mkloc id idloc in\n let e = ghexp ~loc (Pexp_constant (Pconst_string (str, strloc, delim))) in\n (exp_id, PStr [mkstrexp e []])\n\nlet text_str pos = Str.text (rhs_text pos)\nlet text_sig pos = Sig.text (rhs_text pos)\nlet text_cstr pos = Cf.text (rhs_text pos)\nlet text_csig pos = Ctf.text (rhs_text pos)\nlet text_def pos =\n List.map (fun def -> Ptop_def [def]) (Str.text (rhs_text pos))\n\nlet extra_text startpos endpos text items =\n match items with\n | [] ->\n let post = rhs_post_text endpos in\n let post_extras = rhs_post_extra_text endpos in\n text post @ text post_extras\n | _ :: _ ->\n let pre_extras = rhs_pre_extra_text startpos in\n let post_extras = rhs_post_extra_text endpos in\n text pre_extras @ items @ text post_extras\n\nlet extra_str p1 p2 items = extra_text p1 p2 Str.text items\nlet extra_sig p1 p2 items = extra_text p1 p2 Sig.text items\nlet extra_cstr p1 p2 items = extra_text p1 p2 Cf.text items\nlet extra_csig p1 p2 items = extra_text p1 p2 Ctf.text items\nlet extra_def p1 p2 items =\n extra_text p1 p2\n (fun txt -> List.map (fun def -> Ptop_def [def]) (Str.text txt))\n items\n\nlet extra_rhs_core_type ct ~pos =\n let docs = rhs_info pos in\n { ct with ptyp_attributes = add_info_attrs docs ct.ptyp_attributes }\n\ntype let_binding =\n { lb_pattern: pattern;\n lb_expression: expression;\n lb_is_pun: bool;\n lb_attributes: attributes;\n lb_docs: docs Lazy.t;\n lb_text: text Lazy.t;\n lb_loc: Location.t; }\n\ntype let_bindings =\n { lbs_bindings: let_binding list;\n lbs_rec: rec_flag;\n lbs_extension: string Asttypes.loc option }\n\nlet mklb first ~loc (p, e, is_pun) attrs =\n {\n lb_pattern = p;\n lb_expression = e;\n lb_is_pun = is_pun;\n lb_attributes = attrs;\n lb_docs = symbol_docs_lazy loc;\n lb_text = (if first then empty_text_lazy\n else symbol_text_lazy (fst loc));\n lb_loc = make_loc loc;\n }\n\nlet addlb lbs lb =\n if lb.lb_is_pun && lbs.lbs_extension = None then syntax_error ();\n { lbs with lbs_bindings = lb :: lbs.lbs_bindings }\n\nlet mklbs ext rf lb =\n let lbs = {\n lbs_bindings = [];\n lbs_rec = rf;\n lbs_extension = ext;\n } in\n addlb lbs lb\n\nlet val_of_let_bindings ~loc lbs =\n let bindings =\n List.map\n (fun lb ->\n Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes\n ~docs:(Lazy.force lb.lb_docs)\n ~text:(Lazy.force lb.lb_text)\n lb.lb_pattern lb.lb_expression)\n lbs.lbs_bindings\n in\n let str = mkstr ~loc (Pstr_value(lbs.lbs_rec, List.rev bindings)) in\n match lbs.lbs_extension with\n | None -> str\n | Some id -> ghstr ~loc (Pstr_extension((id, PStr [str]), []))\n\nlet expr_of_let_bindings ~loc lbs body =\n let bindings =\n List.map\n (fun lb ->\n Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes\n lb.lb_pattern lb.lb_expression)\n lbs.lbs_bindings\n in\n mkexp_attrs ~loc (Pexp_let(lbs.lbs_rec, List.rev bindings, body))\n (lbs.lbs_extension, [])\n\nlet class_of_let_bindings ~loc lbs body =\n let bindings =\n List.map\n (fun lb ->\n Vb.mk ~loc:lb.lb_loc ~attrs:lb.lb_attributes\n lb.lb_pattern lb.lb_expression)\n lbs.lbs_bindings\n in\n (* Our use of let_bindings(no_ext) guarantees the following: *)\n assert (lbs.lbs_extension = None);\n mkclass ~loc (Pcl_let (lbs.lbs_rec, List.rev bindings, body))\n\n(* Alternatively, we could keep the generic module type in the Parsetree\n and extract the package type during type-checking. In that case,\n the assertions below should be turned into explicit checks. *)\nlet package_type_of_module_type pmty =\n let err loc s =\n raise (Syntaxerr.Error (Syntaxerr.Invalid_package_type (loc, s)))\n in\n let map_cstr = function\n | Pwith_type (lid, ptyp) ->\n let loc = ptyp.ptype_loc in\n if ptyp.ptype_params <> [] then\n err loc \"parametrized types are not supported\";\n if ptyp.ptype_cstrs <> [] then\n err loc \"constrained types are not supported\";\n if ptyp.ptype_private <> Public then\n err loc \"private types are not supported\";\n\n (* restrictions below are checked by the 'with_constraint' rule *)\n assert (ptyp.ptype_kind = Ptype_abstract);\n assert (ptyp.ptype_attributes = []);\n let ty =\n match ptyp.ptype_manifest with\n | Some ty -> ty\n | None -> assert false\n in\n (lid, ty)\n | _ ->\n err pmty.pmty_loc \"only 'with type t =' constraints are supported\"\n in\n match pmty with\n | {pmty_desc = Pmty_ident lid} -> (lid, [], pmty.pmty_attributes)\n | {pmty_desc = Pmty_with({pmty_desc = Pmty_ident lid}, cstrs)} ->\n (lid, List.map map_cstr cstrs, pmty.pmty_attributes)\n | _ ->\n err pmty.pmty_loc\n \"only module type identifier and 'with type' constraints are supported\"\n\nlet mk_directive_arg ~loc k =\n { pdira_desc = k;\n pdira_loc = make_loc loc;\n }\n\nlet mk_directive ~loc name arg =\n Ptop_dir {\n pdir_name = name;\n pdir_arg = arg;\n pdir_loc = make_loc loc;\n }\n\n\n# 835 \"parsing/parser.ml\"\n\nmodule Tables = struct\n \n include MenhirBasics\n \n let token2terminal : token -> int =\n fun _tok ->\n match _tok with\n | AMPERAMPER ->\n 123\n | AMPERSAND ->\n 122\n | AND ->\n 121\n | ANDOP _ ->\n 120\n | AS ->\n 119\n | ASSERT ->\n 118\n | BACKQUOTE ->\n 117\n | BANG ->\n 116\n | BAR ->\n 115\n | BARBAR ->\n 114\n | BARRBRACKET ->\n 113\n | BEGIN ->\n 112\n | CHAR _ ->\n 111\n | CLASS ->\n 110\n | COLON ->\n 109\n | COLONCOLON ->\n 108\n | COLONEQUAL ->\n 107\n | COLONGREATER ->\n 106\n | COMMA ->\n 105\n | COMMENT _ ->\n 104\n | CONSTRAINT ->\n 103\n | DO ->\n 102\n | DOCSTRING _ ->\n 101\n | DONE ->\n 100\n | DOT ->\n 99\n | DOTDOT ->\n 98\n | DOTOP _ ->\n 97\n | DOWNTO ->\n 96\n | ELSE ->\n 95\n | END ->\n 94\n | EOF ->\n 93\n | EOL ->\n 92\n | EQUAL ->\n 91\n | EXCEPTION ->\n 90\n | EXTERNAL ->\n 89\n | FALSE ->\n 88\n | FLOAT _ ->\n 87\n | FOR ->\n 86\n | FUN ->\n 85\n | FUNCTION ->\n 84\n | FUNCTOR ->\n 83\n | GREATER ->\n 82\n | GREATERRBRACE ->\n 81\n | GREATERRBRACKET ->\n 80\n | HASH ->\n 79\n | HASHOP _ ->\n 78\n | IF ->\n 77\n | IN ->\n 76\n | INCLUDE ->\n 75\n | INFIXOP0 _ ->\n 74\n | INFIXOP1 _ ->\n 73\n | INFIXOP2 _ ->\n 72\n | INFIXOP3 _ ->\n 71\n | INFIXOP4 _ ->\n 70\n | INHERIT ->\n 69\n | INITIALIZER ->\n 68\n | INT _ ->\n 67\n | LABEL _ ->\n 66\n | LAZY ->\n 65\n | LBRACE ->\n 64\n | LBRACELESS ->\n 63\n | LBRACKET ->\n 62\n | LBRACKETAT ->\n 61\n | LBRACKETATAT ->\n 60\n | LBRACKETATATAT ->\n 59\n | LBRACKETBAR ->\n 58\n | LBRACKETGREATER ->\n 57\n | LBRACKETLESS ->\n 56\n | LBRACKETPERCENT ->\n 55\n | LBRACKETPERCENTPERCENT ->\n 54\n | LESS ->\n 53\n | LESSMINUS ->\n 52\n | LET ->\n 51\n | LETOP _ ->\n 50\n | LIDENT _ ->\n 49\n | LPAREN ->\n 48\n | MATCH ->\n 47\n | METHOD ->\n 46\n | MINUS ->\n 45\n | MINUSDOT ->\n 44\n | MINUSGREATER ->\n 43\n | MODULE ->\n 42\n | MUTABLE ->\n 41\n | NEW ->\n 40\n | NONREC ->\n 39\n | OBJECT ->\n 38\n | OF ->\n 37\n | OPEN ->\n 36\n | OPTLABEL _ ->\n 35\n | OR ->\n 34\n | PERCENT ->\n 33\n | PLUS ->\n 32\n | PLUSDOT ->\n 31\n | PLUSEQ ->\n 30\n | PREFIXOP _ ->\n 29\n | PRIVATE ->\n 28\n | QUESTION ->\n 27\n | QUOTE ->\n 26\n | QUOTED_STRING_EXPR _ ->\n 25\n | QUOTED_STRING_ITEM _ ->\n 24\n | RBRACE ->\n 23\n | RBRACKET ->\n 22\n | REC ->\n 21\n | RPAREN ->\n 20\n | SEMI ->\n 19\n | SEMISEMI ->\n 18\n | SIG ->\n 17\n | STAR ->\n 16\n | STRING _ ->\n 15\n | STRUCT ->\n 14\n | THEN ->\n 13\n | TILDE ->\n 12\n | TO ->\n 11\n | TRUE ->\n 10\n | TRY ->\n 9\n | TYPE ->\n 8\n | UIDENT _ ->\n 7\n | UNDERSCORE ->\n 6\n | VAL ->\n 5\n | VIRTUAL ->\n 4\n | WHEN ->\n 3\n | WHILE ->\n 2\n | WITH ->\n 1\n \n and error_terminal =\n 0\n \n and token2value : token -> Obj.t =\n fun _tok ->\n match _tok with\n | AMPERAMPER ->\n Obj.repr ()\n | AMPERSAND ->\n Obj.repr ()\n | AND ->\n Obj.repr ()\n | ANDOP _v ->\n Obj.repr _v\n | AS ->\n Obj.repr ()\n | ASSERT ->\n Obj.repr ()\n | BACKQUOTE ->\n Obj.repr ()\n | BANG ->\n Obj.repr ()\n | BAR ->\n Obj.repr ()\n | BARBAR ->\n Obj.repr ()\n | BARRBRACKET ->\n Obj.repr ()\n | BEGIN ->\n Obj.repr ()\n | CHAR _v ->\n Obj.repr _v\n | CLASS ->\n Obj.repr ()\n | COLON ->\n Obj.repr ()\n | COLONCOLON ->\n Obj.repr ()\n | COLONEQUAL ->\n Obj.repr ()\n | COLONGREATER ->\n Obj.repr ()\n | COMMA ->\n Obj.repr ()\n | COMMENT _v ->\n Obj.repr _v\n | CONSTRAINT ->\n Obj.repr ()\n | DO ->\n Obj.repr ()\n | DOCSTRING _v ->\n Obj.repr _v\n | DONE ->\n Obj.repr ()\n | DOT ->\n Obj.repr ()\n | DOTDOT ->\n Obj.repr ()\n | DOTOP _v ->\n Obj.repr _v\n | DOWNTO ->\n Obj.repr ()\n | ELSE ->\n Obj.repr ()\n | END ->\n Obj.repr ()\n | EOF ->\n Obj.repr ()\n | EOL ->\n Obj.repr ()\n | EQUAL ->\n Obj.repr ()\n | EXCEPTION ->\n Obj.repr ()\n | EXTERNAL ->\n Obj.repr ()\n | FALSE ->\n Obj.repr ()\n | FLOAT _v ->\n Obj.repr _v\n | FOR ->\n Obj.repr ()\n | FUN ->\n Obj.repr ()\n | FUNCTION ->\n Obj.repr ()\n | FUNCTOR ->\n Obj.repr ()\n | GREATER ->\n Obj.repr ()\n | GREATERRBRACE ->\n Obj.repr ()\n | GREATERRBRACKET ->\n Obj.repr ()\n | HASH ->\n Obj.repr ()\n | HASHOP _v ->\n Obj.repr _v\n | IF ->\n Obj.repr ()\n | IN ->\n Obj.repr ()\n | INCLUDE ->\n Obj.repr ()\n | INFIXOP0 _v ->\n Obj.repr _v\n | INFIXOP1 _v ->\n Obj.repr _v\n | INFIXOP2 _v ->\n Obj.repr _v\n | INFIXOP3 _v ->\n Obj.repr _v\n | INFIXOP4 _v ->\n Obj.repr _v\n | INHERIT ->\n Obj.repr ()\n | INITIALIZER ->\n Obj.repr ()\n | INT _v ->\n Obj.repr _v\n | LABEL _v ->\n Obj.repr _v\n | LAZY ->\n Obj.repr ()\n | LBRACE ->\n Obj.repr ()\n | LBRACELESS ->\n Obj.repr ()\n | LBRACKET ->\n Obj.repr ()\n | LBRACKETAT ->\n Obj.repr ()\n | LBRACKETATAT ->\n Obj.repr ()\n | LBRACKETATATAT ->\n Obj.repr ()\n | LBRACKETBAR ->\n Obj.repr ()\n | LBRACKETGREATER ->\n Obj.repr ()\n | LBRACKETLESS ->\n Obj.repr ()\n | LBRACKETPERCENT ->\n Obj.repr ()\n | LBRACKETPERCENTPERCENT ->\n Obj.repr ()\n | LESS ->\n Obj.repr ()\n | LESSMINUS ->\n Obj.repr ()\n | LET ->\n Obj.repr ()\n | LETOP _v ->\n Obj.repr _v\n | LIDENT _v ->\n Obj.repr _v\n | LPAREN ->\n Obj.repr ()\n | MATCH ->\n Obj.repr ()\n | METHOD ->\n Obj.repr ()\n | MINUS ->\n Obj.repr ()\n | MINUSDOT ->\n Obj.repr ()\n | MINUSGREATER ->\n Obj.repr ()\n | MODULE ->\n Obj.repr ()\n | MUTABLE ->\n Obj.repr ()\n | NEW ->\n Obj.repr ()\n | NONREC ->\n Obj.repr ()\n | OBJECT ->\n Obj.repr ()\n | OF ->\n Obj.repr ()\n | OPEN ->\n Obj.repr ()\n | OPTLABEL _v ->\n Obj.repr _v\n | OR ->\n Obj.repr ()\n | PERCENT ->\n Obj.repr ()\n | PLUS ->\n Obj.repr ()\n | PLUSDOT ->\n Obj.repr ()\n | PLUSEQ ->\n Obj.repr ()\n | PREFIXOP _v ->\n Obj.repr _v\n | PRIVATE ->\n Obj.repr ()\n | QUESTION ->\n Obj.repr ()\n | QUOTE ->\n Obj.repr ()\n | QUOTED_STRING_EXPR _v ->\n Obj.repr _v\n | QUOTED_STRING_ITEM _v ->\n Obj.repr _v\n | RBRACE ->\n Obj.repr ()\n | RBRACKET ->\n Obj.repr ()\n | REC ->\n Obj.repr ()\n | RPAREN ->\n Obj.repr ()\n | SEMI ->\n Obj.repr ()\n | SEMISEMI ->\n Obj.repr ()\n | SIG ->\n Obj.repr ()\n | STAR ->\n Obj.repr ()\n | STRING _v ->\n Obj.repr _v\n | STRUCT ->\n Obj.repr ()\n | THEN ->\n Obj.repr ()\n | TILDE ->\n Obj.repr ()\n | TO ->\n Obj.repr ()\n | TRUE ->\n Obj.repr ()\n | TRY ->\n Obj.repr ()\n | TYPE ->\n Obj.repr ()\n | UIDENT _v ->\n Obj.repr _v\n | UNDERSCORE ->\n Obj.repr ()\n | VAL ->\n Obj.repr ()\n | VIRTUAL ->\n Obj.repr ()\n | WHEN ->\n Obj.repr ()\n | WHILE ->\n Obj.repr ()\n | WITH ->\n Obj.repr ()\n \n and default_reduction =\n (16, \"\\000\\000\\000\\000\\000\\000\\003\\004\\003\\003\\003\\002\\003\\001\\003\\000\\002\\211\\002\\255\\002\\254\\002\\253\\002\\252\\002\\251\\002\\250\\002\\249\\002\\248\\002\\247\\002\\246\\002\\245\\002\\244\\002\\243\\002\\242\\002\\241\\002\\240\\002\\239\\002\\238\\002\\237\\002\\210\\002\\236\\002\\235\\002\\234\\002\\233\\002\\232\\002\\231\\002\\230\\002\\229\\002\\228\\002\\227\\002\\226\\002\\225\\002\\224\\002\\223\\002\\222\\002\\221\\002\\220\\002\\219\\002\\218\\002\\217\\002\\216\\002\\215\\002\\214\\002\\213\\002\\212\\000\\000\\000\\000\\000,\\000\\186\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003I\\001\\175\\001\\154\\001\\172\\001\\171\\001\\170\\001\\176\\001\\180\\000\\000\\003J\\001\\174\\001\\173\\001\\155\\001\\178\\001\\169\\001\\168\\001\\167\\001\\166\\001\\165\\001\\163\\001\\179\\001\\177\\000\\000\\000\\000\\000\\000\\000\\222\\000\\000\\000\\000\\001\\158\\000\\000\\000\\000\\000\\000\\001\\160\\000\\000\\000\\000\\000\\000\\001\\162\\001\\184\\001\\181\\001\\164\\001\\156\\001\\182\\001\\183\\000\\000\\003H\\003G\\003K\\000\\000\\000\\000\\000\\026\\001H\\000\\188\\000\\000\\000\\218\\000\\219\\000\\000\\000\\000\\000\\000\\001\\206\\001\\205\\000\\000\\000\\000\\000\\025\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003D\\000\\000\\003?\\000\\000\\000\\000\\003A\\000\\000\\003C\\000\\000\\003@\\003B\\000\\000\\003:\\000\\000\\0039\\0035\\002<\\000\\000\\0038\\000\\000\\002=\\000\\000\\000\\000\\000\\000\\000\\000\\000l\\000\\000\\000\\000\\000j\\000\\000\\000\\000\\001F\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\184\\001T\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002'\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000g\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\192\\000\\000\\002p\\002q\\000\\000\\002n\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001k\\001j\\000\\000\\002\\190\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\225\\000\\017\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001R\\000\\000\\000\\000\\001U\\001S\\001[\\000C\\002\\145\\000\\000\\001\\024\\003\\029\\003\\028\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000i\\000\\000\\000\\233\\000\\000\\002s\\002r\\000\\000\\000\\000\\000\\000\\001\\188\\000\\000\\000\\000\\000'\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001Z\\000\\000\\001Y\\000\\000\\001I\\001X\\000\\000\\001G\\000d\\000 \\000\\000\\000\\000\\001\\131\\000\\027\\000\\000\\000\\000\\000\\000\\000\\000\\0034\\000*\\000\\000\\000\\000\\000!\\000\\028\\000\\000\\000\\000\\000\\000\\000\\201\\000\\000\\000\\000\\000\\000\\000\\203\\002F\\0028\\000\\000\\000$\\000\\000\\0029\\000\\000\\000\\000\\001\\185\\000\\000\\000\\000\\000\\000\\000\\018\\000\\000\\000\\000\\000\\000\\000\\019\\003\\030\\000\\000\\003\\031\\000\\000\\000{\\000\\000\\000\\000\\000#\\000\\000\\000\\000\\000\\000\\000%\\000\\000\\000&\\000\\000\\000(\\000\\000\\000\\000\\000)\\002.\\002-\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000e\\000\\000\\002\\197\\000h\\000k\\000f\\002\\186\\003L\\002\\187\\001\\249\\002\\189\\000\\000\\000\\000\\002\\194\\002m\\002\\196\\000\\000\\000\\000\\000\\000\\002\\203\\002\\200\\000\\000\\000\\000\\000\\000\\001\\245\\001\\231\\000\\000\\000\\000\\000\\000\\000\\000\\001\\235\\000\\000\\001\\230\\000\\000\\001\\248\\002\\209\\000\\000\\000\\000\\000\\000\\000\\000\\001\\133\\000\\000\\000\\000\\001\\247\\002\\195\\000s\\000\\000\\000\\000\\000r\\000\\000\\002\\204\\002\\188\\000\\000\\001\\241\\000\\000\\000\\000\\002\\207\\000\\000\\002\\206\\002\\205\\000\\000\\001\\237\\000\\000\\000\\000\\001\\233\\001\\232\\001\\246\\001\\238\\000\\000\\000q\\000\\000\\002\\202\\002\\201\\000\\000\\002\\199\\000\\000\\002u\\002t\\000\\000\\000\\000\\002P\\002\\198\\000\\000\\000\\000\\000\\000\\000\\000\\001\\190\\0013\\0014\\002w\\000\\000\\002x\\002v\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\244\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\204\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001u\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003c\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0037\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001t\\000\\000\\000\\000\\000\\000\\001Q\\001{\\001P\\001x\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0026\\000\\000\\000\\000\\0027\\002*\\002)\\000\\000\\001s\\001r\\000\\000\\000\\205\\000\\000\\000\\000\\001d\\000\\000\\000\\000\\001h\\000\\000\\001\\210\\001\\209\\000\\000\\000\\000\\001\\208\\001\\207\\001g\\001e\\000\\000\\001i\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\151\\001V\\002\\156\\002\\154\\000\\000\\000\\000\\000\\000\\002\\167\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\185\\000\\000\\002\\184\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\242\\002\\003\\000\\243\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0031\\000\\000\\000\\000\\0030\\000\\000\\000\\000\\000\\000\\000\\000\\000\\237\\000\\236\\000\\000\\000\\238\\000\\000\\000\\000\\000\\000\\002\\164\\000\\000\\000\\000\\000\\000\\002\\133\\002|\\000\\000\\000\\000\\000\\000\\000\\000\\003M\\002\\166\\002\\153\\002\\152\\000\\000\\000\\000\\000\\169\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\183\\000\\000\\000\\000\\000\\000\\000\\168\\000\\000\\000\\000\\000\\000\\002W\\002V\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\246\\000\\000\\003\\007\\000\\000\\000\\000\\000\\195\\000\\194\\000\\247\\000\\000\\003\\b\\003\\t\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\253\\000\\000\\000\\000\\0020\\000\\000\\000\\000\\000\\000\\000\\252\\000\\000\\000\\000\\000\\251\\000\\250\\000\\000\\000\\000\\000\\000\\000\\000\\000\\255\\000\\000\\000\\000\\000\\254\\000\\000\\001\\244\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\002\\002\\000\\000\\000\\000\\001\\254\\001\\253\\001\\251\\001\\252\\000\\000\\000\\000\\000\\000\\000\\248\\000\\000\\000\\000\\001\\030\\000\\020\\001\\001\\000\\000\\000\\000\\000\\000\\002\\135\\002~\\000\\000\\000\\000\\002\\134\\002}\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\002\\128\\000\\000\\000\\000\\002J\\000\\000\\000\\000\\002\\141\\002\\132\\000\\000\\000\\000\\002\\139\\002\\130\\002\\160\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\136\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\140\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\138\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002+\\000\\167\\000\\000\\002\\127\\000\\000\\000\\000\\002\\131\\000\\000\\000\\000\\002\\129\\000\\000\\000|\\000}\\000\\000\\000\\000\\000\\000\\000\\000\\000\\140\\000\\196\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\197\\000\\000\\000\\198\\000\\199\\000\\133\\000\\000\\000\\132\\000\\000\\000\\000\\0016\\000\\000\\0017\\0015\\0022\\000\\000\\000\\000\\0023\\0021\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\t\\000\\000\\000\\000\\001\\n\\000\\000\\000\\000\\000\\170\\000\\000\\001\\012\\001\\011\\000\\000\\000\\000\\002\\168\\002\\161\\000\\000\\002\\177\\000\\000\\002\\178\\002\\176\\000\\000\\002\\182\\000\\000\\002\\183\\002\\181\\000\\000\\000\\000\\002\\163\\002\\162\\000\\000\\000\\000\\000\\000\\002\\026\\000\\000\\001\\204\\000\\000\\000\\000\\000\\000\\002S\\002\\025\\000\\000\\002\\172\\002\\171\\000\\000\\000\\000\\000\\000\\001W\\000\\000\\002\\143\\000\\000\\002\\144\\002\\142\\000\\000\\002\\170\\002\\169\\000\\000\\000\\000\\000\\000\\002M\\002\\159\\000\\000\\002\\158\\002\\157\\000\\000\\002\\180\\002\\179\\000\\130\\000\\000\\000\\000\\000\\000\\000\\000\\000\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\127\\000\\000\\001^\\000\\000\\000\\000\\000\\000\\000m\\000\\000\\000\\000\\000n\\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\\227\\000\\000\\000\\000\\000w\\000\\000\\000\\230\\000\\228\\000\\000\\000\\000\\000\\000\\000\\207\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000o\\000\\000\\000\\000\\002\\024\\000\\000\\000\\000\\001\\000\\001\\202\\000\\000\\000\\240\\000\\241\\001\\007\\000\\000\\002\\175\\000\\000\\002\\174\\002\\173\\002\\155\\000\\000\\000\\000\\000\\000\\000\\000\\002\\146\\000\\000\\002\\148\\000\\000\\002\\147\\000\\000\\002z\\002y\\000\\000\\002{\\000\\000\\000\\000\\000\\000\\000\\000\\001\\217\\001\\211\\000\\000\\001\\216\\000\\000\\001\\214\\000\\000\\001\\215\\000\\000\\001\\212\\000\\000\\000\\000\\001\\213\\000\\000\\001\\151\\000\\000\\000\\000\\000\\000\\001\\150\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001y\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\020\\003\\022\\000\\000\\000\\000\\003\\021\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\t\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\027\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\135\\000\\000\\002\\015\\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\\006\\000\\000\\000\\000\\002X\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\153\\000\\000\\000\\000\\000\\000\\001\\152\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001z\\000\\000\\000\\000\\000\\000\\000\\000\\001m\\000\\000\\001l\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\022\\002f\\000\\000\\000\\000\\000\\000\\002d\\000\\000\\000\\000\\000\\000\\002c\\000\\000\\001`\\000\\000\\000\\000\\000\\000\\000\\000\\002j\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003U\\000\\000\\000\\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000G\\000\\000\\000\\000\\000\\000\\000\\000\\001\\130\\000\\000\\001\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000J\\000\\000\\000\\000\\000\\000\\002\\022\\000\\000\\002\\021\\000\\000\\000\\000\\000\\000\\000\\000\\000K\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000P\\000\\000\\000\\000\\000\\000\\000Q\\000O\\000\\000\\000T\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000I\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000L\\000\\000\\000S\\000R\\000\\000\\000M\\000N\\000\\000\\001'\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\018\\000c\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000`\\000\\000\\000b\\000a\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\016\\002k\\002\\\\\\000\\000\\002b\\002]\\002i\\002h\\002g\\002e\\001!\\000\\000\\002Z\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002'\\000\\000\\000\\000\\001\\026\\002^\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\146\\001\\142\\000\\000\\000\\000\\000\\000\\000\\212\\000\\000\\000\\000\\002\\029\\002'\\000\\000\\000\\000\\001\\028\\002\\027\\002\\028\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\149\\001\\145\\001\\141\\000\\000\\000\\000\\000\\213\\000\\000\\000\\000\\001\\148\\001\\144\\001\\140\\001\\138\\002_\\002[\\002l\\001 \\002\\006\\002Y\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003P\\000\\000\\000\\000\\003R\\000\\000\\0008\\000\\000\\000\\000\\003X\\000\\000\\003W\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003O\\000\\000\\000\\000\\003Q\\000\\000\\000\\000\\000\\000\\002\\017\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001E\\000\\000\\000\\000\\001C\\001A\\000\\000\\0009\\000\\000\\000\\000\\003[\\000\\000\\003Z\\000\\000\\000\\000\\000\\000\\001?\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001D\\000\\000\\000\\000\\001B\\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\\001\\003\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000Z\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0005\\000\\000\\000\\000\\000Y\\000\\000\\0003\\001\\004\\000\\000\\000B\\000/\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\002\\000\\000\\000X\\000W\\000\\000\\000\\000\\000]\\000\\\\\\000\\000\\000\\000\\001\\192\\000\\000\\0007\\000\\000\\000\\000\\000\\000\\0006\\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\\000\\001\\014\\003\\025\\003\\016\\000\\000\\000\\000\\003\\020\\003\\005\\003\\015\\003\\024\\003\\023\\001%\\000\\000\\000\\000\\003\\r\\000\\000\\003\\017\\003\\014\\003\\026\\002\\005\\000\\000\\000\\000\\003\\011\\000\\000\\000\\191\\003\\n\\000\\000\\000\\000\\000\\224\\000\\000\\000\\000\\001$\\001#\\000\\000\\001b\\001a\\000\\000\\000\\000\\002\\208\\002\\191\\000\\000\\000D\\000\\000\\000\\000\\000E\\000\\000\\000\\000\\002\\150\\002\\149\\000\\000\\000\\000\\000\\136\\000\\000\\000\\000\\002\\014\\000\\217\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\189\\000\\000\\003\\019\\002\\\"\\002#\\002\\030\\002 \\002\\031\\002!\\000\\000\\000\\000\\000\\000\\000\\190\\000\\000\\000\\000\\002'\\000\\000\\000\\216\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\000\\000\\000\\187\\000\\000\\000\\000\\000\\000\\000\\000\\001>\\0018\\000\\000\\000\\000\\0019\\000\\031\\000\\000\\000\\030\\000\\000\\000\\000\\000\\202\\000\\000\\000\\000\\000\\000\\000\\\"\\000\\029\\000\\000\\000\\000\\000\\000\\000\\023\\000\\000\\000\\000\\000\\000\\000\\000\\001\\147\\001\\143\\000\\000\\001\\139\\0033\\000\\000\\002'\\000\\000\\000\\215\\000\\000\\000\\000\\000\\000\\000\\000\\002a\\002&\\002$\\002%\\000\\000\\000\\000\\000\\000\\002'\\000\\000\\000\\214\\000\\000\\000\\000\\000\\000\\000\\000\\002`\\000\\000\\001o\\001n\\000\\000\\000\\024\\000\\000\\003S\\000\\000\\000-\\000\\000\\000\\000\\000\\000\\000\\000\\000\\139\\000\\000\\000\\220\\000\\001\\000\\000\\000\\000\\000\\223\\000\\002\\000\\000\\000\\000\\000\\000\\001K\\001L\\000\\003\\000\\000\\000\\000\\000\\000\\000\\000\\001N\\001O\\001M\\000\\021\\001J\\000\\022\\000\\000\\001\\218\\000\\000\\000\\004\\000\\000\\001\\219\\000\\000\\000\\005\\000\\000\\001\\220\\000\\000\\000\\000\\001\\221\\000\\006\\000\\000\\000\\007\\000\\000\\001\\222\\000\\000\\000\\b\\000\\000\\001\\223\\000\\000\\000\\t\\000\\000\\001\\224\\000\\000\\000\\n\\000\\000\\001\\225\\000\\000\\000\\011\\000\\000\\001\\226\\000\\000\\000\\000\\001\\227\\000\\012\\000\\000\\000\\000\\001\\228\\000\\r\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003&\\003!\\003\\\"\\003%\\003#\\000\\000\\003*\\000\\014\\000\\000\\003)\\000\\000\\001+\\000\\000\\000\\000\\003'\\000\\000\\003(\\000\\000\\000\\000\\000\\000\\000\\000\\001/\\0010\\000\\000\\000\\000\\001.\\001-\\000\\015\\000\\000\\000\\000\\000\\000\\003F\\000\\000\\003E\")\n \n and error =\n (124, \"'\\225 \\197\\138\\173\\2433\\208\\020\\015\\228\\000\\003\\142\\0026\\016\\004\\\\(\\223\\018}\\000@\\248\\000\\000\\024\\224}\\246D\\b/\\227P\\000L\\028\\030\\227\\139\\002\\131@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\175\\235f\\245\\155\\175\\2437\\252\\149\\031\\226\\017\\007\\158\\007\\223d@\\130\\2545\\000\\004\\193\\193\\2388\\176(4\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241'\\208\\004\\015\\128\\000\\001\\142\\007\\223d@\\130\\2545\\000\\004\\193\\193\\2388\\176(4'\\225\\\"\\213\\138\\173\\2433\\208\\020\\015\\224\\000\\007\\142\\000\\000\\000\\000\\004\\000\\012\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\192\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\128\\007\\224,$\\000\\003\\226 \\016@\\016(\\176\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000(\\000\\000\\000\\000\\000\\000\\000\\000\\000\\024\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\b\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\018\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\b\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\017\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\b\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\133\\128\\179\\160\\b2R\\028\\012\\025 v\\017\\\"\\017@\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\002\\012\\\\ \\000\\016\\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\\001\\000@@@ \\193\\004\\000\\000\\016\\000\\000\\000\\000\\000\\016\\004\\004\\000\\002\\012\\016@\\000\\001\\000\\000\\000\\000\\000\\001\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\012H\\002\\168\\000\\131\\t!\\192\\001\\016\\007a\\003 \\004\\132\\128 \\128\\b \\002\\020\\000\\016\\000b\\000\\002\\000\\bH\\002\\b\\000\\130\\000!\\000\\001\\000\\006 \\000 \\000\\003\\000\\000$\\193\\004\\192\\004\\000\\128\\000\\000\\000\\000\\b\\0000\\000\\002H\\016L\\000@\\b\\000\\000\\000\\000\\000\\128\\003\\000\\000$\\129\\004\\192\\000\\000\\128\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000$\\128\\004\\192\\000\\000\\128\\000\\000\\000\\000\\b\\000 \\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\002H\\000@\\000\\000\\b\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\002\\b\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000$\\128\\004\\000\\000\\000\\128\\000\\000\\000\\000\\b\\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\\bH\\002( \\130\\000!\\128\\001\\000\\007`\\017 \\004\\003 \\000x\\016\\000\\197\\194\\128\\001\\000\\128 \\000\\016\\bH\\002(\\000\\194\\t!\\192\\001\\016\\006a\\016a\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0002\\000\\007\\001\\000\\012\\\\(\\000\\016\\b\\002\\000\\001\\000\\003\\000\\bp\\016 \\197\\194\\000\\001\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\197\\128\\187\\128\\b2R\\028\\012\\017 v\\001f\\017`0\\000\\006\\000\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\006\\000\\000\\012\\\\ \\000\\018\\000\\002\\000\\000\\000\\001\\000\\016\\000\\000\\000@\\000\\000\\001 \\000\\000\\004\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000}\\246D\\b/\\227P\\000L\\028\\030\\227\\139\\002\\131B~\\018-X\\170\\2233=\\001@\\254\\000\\000x\\224\\000\\000\\000\\000\\000\\000\\000\\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$\\193\\004\\192\\004\\000\\128\\000\\000\\000\\000\\b\\0000\\000\\002H\\016L\\000@\\b\\000\\000\\000\\000\\000\\128\\003\\000\\000$\\129\\004\\192\\000\\000\\128\\000\\000\\000\\000\\b\\0000\\000\\002H\\000L\\000\\000\\b\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002( \\130\\001!\\128\\001\\016\\007`\\016 \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\128\\001\\016\\006`\\016 \\004}\\246D\\b/\\227P\\000L\\028\\030\\227\\139\\002\\131B~\\018-X\\170\\2233=\\001@\\254\\000\\000x\\224#a\\000E\\194\\141\\241'\\208\\004\\015\\128\\000\\001\\142\\0026\\016\\004X(\\223\\018}\\000@\\248\\000\\000\\024\\224#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001!\\000D\\002\\128\\193#\\144\\000\\001\\128\\000\\001\\140\\b@\\000\\b\\004\\000(!@\\192\\000\\000 \\016\\000\\000\\132\\000\\000\\128\\000\\002\\130\\020\\012\\000\\000\\002\\001\\000\\000\\b@\\000\\b\\000\\000(!\\000\\192\\000\\000 \\016\\000\\000\\003!\\000@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\131!\\136G\\224,\\229\\\"\\211\\227!\\176@\\025,\\184\\000\\000\\128\\000\\000\\000\\000\\001\\000\\000\\016\\000\\000\\000\\000\\131\\000\\000\\000@\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\0000\\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\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\004\\004\\000\\002\\012\\016\\000\\000\\001\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\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\\002\\000@\\000\\000\\129\\004\\000\\000\\016\\000\\000\\000\\000\\000\\016 \\004\\000\\000\\b\\016\\000\\000\\001\\000\\000\\000\\000\\000\\167\\225 \\197\\138\\173\\2437\\208\\020\\015\\226\\000\\003\\142\\n~\\018\\012X\\170\\2233=\\001@\\254 \\0008\\224\\167\\225\\\"\\197\\138\\173\\2433\\208\\020\\015\\230\\000\\003\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\002\\000@@\\000\\129\\004\\000\\000\\016\\000\\000\\000\\b\\000\\016 \\004\\004\\000\\b\\016@\\000\\001\\000\\000\\000\\000\\000\\001\\002\\000@\\000\\000\\129\\004\\000\\000\\016\\000\\000\\000\\000\\000\\016 \\004\\000\\000\\b\\016\\000\\000\\001\\000\\000\\000\\000\\000\\005\\002\\000@\\000\\000\\129\\000\\000\\000\\016\\000\\000\\000\\000\\0026\\016\\004X(\\223\\018}\\000@\\248\\000\\000\\024\\224#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\016\\000\\000\\004\\000\\004\\000@\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\000\\000@\\004\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\175\\235w\\253\\155\\239\\247\\255\\252\\157?\\230!\\003\\158@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000#a\\000E\\194\\141\\241'\\208\\004\\015\\128\\000\\001\\142\\0026\\016\\004X(\\223\\018}\\000@\\248\\000\\000\\024\\224#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\n6\\024\\132~*\\223R=>b\\249\\004\\001\\154\\235\\129!\\bD\\002\\128\\193#\\144\\000\\001\\128\\000\\001\\140\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\028\\224\\197\\189\\187\\215\\250\\190\\223?\\191\\251a\\247\\219\\127\\252\\2426\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\003!\\000@\\128\\004\\193\\\"\\208\\001\\001\\128\\000\\001\\004\\0002\\016\\004\\b\\000L\\018-\\000\\016\\026\\000\\000\\020@\\003!\\002@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\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\\128\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000@\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\001@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000@\\003\\000\\002p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\020\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\004\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\001@\\001\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\001\\000\\000\\000\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\128\\000\\000\\000\\000\\000\\016\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012H\\003\\184\\000\\131!!\\192\\193\\018\\007`\\022!\\022\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\012H\\011\\184\\000\\131!!\\192\\193\\018\\007`\\022!\\022\\003\\000\\000`\\000\\000\\197\\194\\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\\000\\000\\000\\000\\000\\012X\\011\\184\\000\\131%!\\192\\193\\018\\007`\\022!\\022\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\006\\000\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012X\\011\\184\\000\\131%!\\192\\193\\018\\007`\\022!\\022\\003\\000\\000`\\000\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\012X\\011\\184\\000\\131%!\\192\\193\\018\\007`\\022!\\022\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000@\\000\\000@\\000\\002\\000\\000\\000\\001\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000@\\000\\002\\000\\000\\000\\001\\002\\003\\000\\000p\\016\\000\\197\\194\\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\\002\\000\\000\\000\\000\\004\\000\\000 \\000\\000\\000\\017 \\000\\000\\002\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000@\\000\\002\\000\\000\\000\\001\\018\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000@\\000\\002\\000\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012H\\003\\184\\000\\131!!\\192\\193\\018\\007`\\022!\\020\\000\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000@\\000\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\001\\016\\000\\000\\000\\000@\\000\\000\\001\\000\\000\\000\\000\\128\\000\\017\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\0002\\016\\004\\b\\000L\\018-\\000\\016\\026\\000\\000\\016@\\003!\\000@\\192\\004\\193&\\144\\001\\001\\128\\000\\001\\004\\0002\\016\\004\\b\\000L\\018i\\000\\016\\024\\000\\000\\016@\\003!\\000@\\128\\004\\193\\\"\\144\\001\\001\\128\\000\\001\\004\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\147)\\027P\\144\\020\\193&\\176\\001\\001\\148 mU\\000\\000\\016\\000\\b\\000@\\000\\001\\000\\000\\016\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t2\\145\\181\\t\\001L\\018o\\000\\016\\027A\\006\\213P\\001\\000\\000\\000\\000\\000\\128\\\"\\128\\000\\000\\000\\000\\000\\000\\b2\\016\\132\\b\\000L\\018-\\000\\016\\026\\000\\000\\144@\\000\\000\\000\\000\\000\\000\\000\\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@\\192\\004\\193&\\208\\001\\001\\160\\000\\001\\004\\0002\\016\\004\\b\\000L\\018m\\000\\016\\026\\000\\000\\016@\\003!\\000@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\000\\001\\176\\000\\001\\000\\000@\\000\\000\\001@\\004\\197\\016\\003!\\000@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\t\\000\\001\\176\\000\\001\\000\\000@\\000\\000\\001@\\004\\197\\016\\131!\\000@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\144\\000\\027\\000\\000\\016\\000\\004\\000\\000\\000\\020\\000LQ\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\147!\\027@\\128\\020\\193&\\208\\001\\001\\180\\000MU\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t2\\017\\180\\b\\001L\\018m\\000\\016\\027@\\004\\213P\\131\\161\\136G\\224,\\229\\\"\\211\\227!\\176@\\025,\\176\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000@\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0002\\016\\004\\b\\000L\\018)\\000\\016\\024\\000\\000\\016@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\128\\000\\000\\000\\000\\001\\000\\000\\016\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\b\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000L\\017\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b2\\016\\004\\b\\000L\\018-\\000\\016\\026\\000\\000\\016@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\000\\001\\176\\000\\001\\000\\000@\\000\\000\\001@\\004\\197\\016\\131\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\b\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b2\\016\\004\\b\\000L\\018-\\000\\016\\026\\000\\000\\016@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\000\\001\\176\\000\\001\\000\\000@\\000\\000\\001@\\004\\197\\016\\128\\000\\000\\000\\000\\000\\192\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\128\\000\\000\\000\\000@\\000\\000\\000\\000\\004\\129\\016\\000\\000\\000\\000\\000\\000\\000\\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!\\002@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\001 \\000\\000\\000\\000@\\000\\000\\000\\000\\004\\133\\016\\131!\\002@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001D\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\001\\016\\000\\000\\000\\000@\\000\\000\\000\\000\\004\\129\\016\\128\\000\\017\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b0\\000\\016\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\017\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\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)\\000P\\144\\004\\193&\\176\\t\\001\\144\\000M\\021\\128\\000\\000\\000\\000\\000\\012\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000@\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000@\\000\\000\\001\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\0002\\016D\\012\\130L\\018m\\000\\016\\026\\000\\000\\016@\\001\\002\\000@@\\000\\129\\004\\000\\000\\016\\000\\000\\000\\b\\000\\016 \\004\\004\\000\\b\\016@\\000\\001\\000\\000\\000\\000\\000\\001\\002\\000@\\000\\000\\129\\004\\000\\000\\016\\000\\000\\000\\000\\000\\016 \\004\\000\\000\\b\\016\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\016\\004\\004\\000\\002\\012\\016\\000\\000\\001\\000\\000\\000\\000\\000\\001\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\196\\128*\\128\\b0\\018\\028\\000\\017\\000v\\000\\\"\\000@\\b\\000\\000\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000$\\128\\004\\192\\000\\000\\128\\000\\000\\000\\000\\b\\000\\016\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\016\\000\\0000\\000\\007\\129\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\196\\128*\\128\\b0\\018\\028\\000\\017\\000v\\000\\\"\\001@0\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\196\\128*\\128\\b0\\018\\028\\000\\017\\000v\\001\\\"\\001LH\\002\\168\\000\\131\\001!\\192\\001\\016\\007`\\018 \\004\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\001\\000\\000\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\012H\\002\\168\\000\\131\\001!\\192\\001\\016\\007`\\018 \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\024\\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\\001\\000\\001\\000\\000\\001\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\012H\\002\\168\\000\\131\\001!\\192\\001\\016\\007`\\002 \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\001\\000\\000\\000\\001\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\012H\\002\\168\\000\\131\\t!\\192\\001\\016\\007a\\003 \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\012H\\002\\168\\000\\131\\001!\\192\\001\\016\\007`\\002 \\004\\001\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\012H\\002\\168\\000\\131\\001!\\192\\001\\016\\007`\\002 \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\016\\016\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\196\\128*\\128\\b0\\146\\028\\000\\017\\000v\\016\\\"\\000@\\016\\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\\012H\\002\\168\\000\\131\\t!\\192\\001\\016\\007a\\002 \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012H\\002\\168\\000\\131\\001!\\192\\001\\016\\007`\\002 \\004\\000\\128\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\192\\000\\b\\000\\000\\016\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\128\\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\\001\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\002\\000@\\000\\000\\129\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\196\\128*\\128\\b0\\146\\028\\000\\025\\000v\\000&\\000@P \\132\\000\\000\\b\\016\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\128\\000\\000\\b\\000@\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\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 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\012\\000\\000\\128\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\196\\128*\\128\\b0\\146\\028\\000\\025\\000v\\016&\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\004\\000\\b\\000\\000\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224#a\\002E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\004\\000\\000\\000\\000\\000\\128\\000\\016\\000\\000\\000\\000\\000\\000\\000@\\016\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\001!\\000D\\002\\128\\193#\\144\\000\\001\\128\\000\\001\\140\\012\\000\\001\\016\\000\\000\\000\\000\\000\\0000\\001\\005\\002@\\000#a\\000E\\194\\141\\241'\\208\\004\\015\\130\\000\\001\\142\\0026\\016\\004X(\\223\\018}\\000@\\248 \\000\\024\\224#a\\000E\\130\\141\\241#\\208\\004\\015\\130\\000\\001\\142\\000\\018\\016\\004D(\\012\\018y\\000\\000\\024\\000\\000\\024\\192\\001!\\000D\\002\\128\\193'\\144\\000\\001\\128\\000\\001\\140\\000\\018\\016\\004@(\\012\\0189\\000\\000\\024\\000\\000\\024\\192\\001!\\000D\\002\\128\\193#\\144\\000\\001\\128\\000\\001\\140\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012[\\219\\189\\127\\171\\237s\\251\\255\\182\\031}\\183\\255\\223\\001\\000\\000\\000\\000\\000\\192#\\128\\000\\000\\000\\000\\000\\000\\n6\\024\\132~*\\223R=>b\\249\\004\\001\\154\\235\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n6\\016\\132X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\163a\\bE\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b\\016 \\004\\004\\000\\b\\016@\\000\\001\\000\\000\\000\\000\\000\\001\\002\\000@\\000\\000\\129\\004\\000\\000\\016\\000\\000\\000\\000\\000\\016 \\004\\000\\000\\b\\016\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\004\\000\\000\\000\\000\\000\\004\\000\\b\\016\\004\\004\\000\\002\\012\\016\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\128\\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\\n6\\016\\132X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\163a\\bE\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b2\\016\\132\\b\\000L\\018-\\000\\016\\024\\000\\000\\016@\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\016\\000L\\017\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\016\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224#a\\000E\\194\\141\\241'\\208\\004\\015\\128\\000\\001\\142\\0026\\016\\004X(\\223\\018}\\000@\\248\\000\\000\\024\\224#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\0002\\016\\004\\012\\000L\\018m\\000\\016\\026\\000\\000\\017@\\003!\\000@\\128\\004\\193&\\208\\001\\001\\160\\000\\001\\020\\0002\\016\\004\\b\\000L\\018-\\000\\016\\026\\000\\000\\017@\\003!\\000@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\001\\000\\000\\000\\000\\001\\000\\000@\\000\\000\\000\\000\\004\\129\\016#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\0002\\144\\005\\r\\000L\\018k\\000\\016\\024\\000\\000\\016@\\003)\\000P\\144\\004\\193&\\176\\001\\001\\128\\000\\001\\004\\0002\\144\\005\\t\\000L\\018+\\000\\016\\024\\000\\000\\016@\\002\\000\\000\\000\\000\\000\\192\\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@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\000\\000\\000\\128\\000\\000\\000\\000@\\000\\000\\001\\000\\004\\193\\016\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000@\\000\\000\\001\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b:\\024\\132~\\002\\206R->2\\027\\004\\001\\146\\203\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003)\\000P\\144\\020\\193\\\"\\176\\001\\001\\128\\000\\005\\004\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\003!\\000@\\192\\004\\193&\\208\\001\\001\\160\\000\\001\\004\\0002\\016\\004\\b\\000L\\018m\\000\\016\\026\\000\\000\\016@\\003!\\000@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\001\\000\\004\\129\\016#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\018\\016\\004D(\\012\\018y\\000\\000\\024\\000\\000\\024\\192\\001!\\000D\\002\\128\\193'\\144\\000\\001\\128\\000\\001\\140\\000\\018\\016\\004@(\\012\\0189\\000\\000\\024\\000\\000\\024\\192\\196\\148\\187\\131\\232>\\022\\028\\015\\251`w\\219~p\\240\\018\\016\\004@(\\012\\0189\\000\\000\\024\\000\\000\\024\\192\\197\\189\\187\\215\\250\\190\\215?\\191\\251a\\247\\219\\127\\253\\240\\000\\000\\000\\000\\000\\b\\000(\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\197\\189\\187\\215\\250\\190\\215?\\191\\251a\\247\\219\\127\\252\\240\\000\\000\\000\\000\\000\\012\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002@\\000\\131\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\025\\000\\000\\000\\000\\004\\000\\000\\000\\016\\000\\000\\000\\b0\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\001\\144\\000\\000\\000\\000@\\000\\000\\001\\000\\002\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\b\\000\\001\\144\\000\\000\\000\\000@\\000\\000\\001\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\018\\016\\004@(\\012\\0189\\000\\000\\024\\000\\000\\024\\192\\197\\189\\187\\215\\250\\190\\215?\\191\\251a\\247\\219\\127\\253\\240\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\012\\000(\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\196\\148\\187\\131\\232>\\022\\028\\015\\249`w\\139~p\\2426\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\197\\189\\187\\215\\250\\190\\215?\\191\\251a\\247\\219\\127\\252\\252IK\\184>\\131\\225a\\192\\255\\182\\007}\\183\\231\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000B6\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012[\\219\\189\\127\\171\\237s\\251\\255\\182\\031}\\183\\255\\207\\196\\148\\187\\131\\232>\\022\\028\\015\\251`w\\219~p\\2426\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\014\\127[\\188~\\171\\255s\\253\\255\\214\\255x\\183\\255\\239}\\246D\\b/\\227P\\000L\\028\\030\\227\\139\\002\\131B6\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015\\003!\\000@\\128\\004\\193&\\208\\001\\001\\128\\000\\001\\004\\0002\\016\\004\\b\\000L\\018-\\000\\016\\024\\000\\000\\016@\\135\\169\\\"\\208\\152$\\211>\\176\\025\\001\\246\\000o\\021H:\\024\\132~\\002\\206R->2\\027\\004\\001\\146\\203\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003)\\000P\\144\\004\\193\\\"\\176\\001\\001\\144\\000%\\004\\0002\\016\\004\\b\\000L\\018)\\000\\016\\024\\000\\000\\016@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\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#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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)\\000P\\144\\004\\193\\\"\\176\\001\\001\\144\\000%\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b8\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\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\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\001\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\016\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\016\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\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#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\004\\193\\016\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\001\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\016\\000H\\017\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b2\\016\\004\\b\\000L\\018-\\000\\016\\026\\000\\000\\016@\\000\\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\\004\\129\\016\\131!\\000@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\016\\000H\\017\\b2\\016\\004\\b\\000L\\018-\\000\\016\\026\\000\\000\\016@\\000\\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\\004\\129\\016\\128\\000\\000\\000\\000\\000\\192\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\004\\129\\016\\003!\\000@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\001\\000\\004\\129\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\128\\001\\144\\006`\\000 \\004\\132\\128\\\"\\128\\b\\\"\\018\\024\\012\\025\\000f\\001\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\196\\148\\187\\131\\232>\\022\\028\\015\\249`w\\139~p\\2426\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\128\\000\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\128\\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\\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\\128\\002\\128\\000\\000\\000\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\128\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\t\\176>\\000\\192@@>\\002\\001\\000\\005\\134\\003\\163a\\011E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\206\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\018\\016\\004@(\\012\\0189\\000\\000\\024\\000\\000\\024\\192\\197\\189\\187\\215\\250\\190\\215?\\191\\251a\\247\\219\\127\\253\\240\\000\\000\\000\\000\\000\\b\\000(\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012[\\219\\189\\127\\171\\237\\243\\251\\255\\182\\031}\\183\\255\\207#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012[\\219\\189\\127\\171\\237\\243\\251\\255\\182\\031}\\183\\255\\207#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012[\\219\\189\\127\\171\\237\\243\\251\\255\\182\\031}\\183\\255\\207#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015\\001\\000\\000\\000\\000\\000\\192\\002\\128\\000\\000\\000\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\128\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012[\\219\\189\\127\\171\\237\\243\\251\\255\\182\\031}\\183\\255\\207#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\197\\189\\187\\215\\250\\190\\223?\\191\\251a\\247\\219\\127\\252\\2426\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\196\\148\\187\\131\\232>\\022\\028\\015\\249`w\\139~p\\2426\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\128\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012[\\219\\189\\127\\171\\237\\243\\251\\255\\182\\031}\\183\\255\\207#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000P\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000(\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\197\\189\\187\\215\\250\\190\\223?\\191\\251a\\247\\219\\127\\252\\2426\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\196\\148\\187\\131\\232>\\022\\028\\015\\249`w\\139~p\\2426\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\128\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012[\\219\\189\\127\\171\\237\\243\\251\\255\\182\\031}\\183\\255\\207#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\197\\189\\187\\215\\250\\190\\223?\\191\\251a\\247\\219\\127\\252\\2426\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\196\\148\\187\\131\\232>\\022\\028\\015\\249`w\\139~p\\252[\\219\\189\\127\\171\\237\\243\\251\\255\\182\\031}\\183\\255\\207#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015\\197\\189\\187\\215\\250\\190\\215?\\191\\251a\\247\\219\\127\\253\\252[\\219\\189\\127\\171\\237s\\251\\255\\150\\031x\\183\\255\\207\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\128\\000\\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#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b\\000\\000\\016\\000\\000\\000\\000\\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\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\131\\161\\136G\\224,\\229\\\"\\211\\227!\\176@\\025,\\176\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0002\\144\\005\\t\\001L\\018+\\000\\016\\024\\000\\000P@\\003\\000\\000`\\000\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\001\\004\\000\\000\\000\\016\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003)\\000P\\144\\020\\193\\\"\\176\\001\\001\\128\\000\\005\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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)\\000P\\144\\020\\193\\\"\\176\\001\\001\\128\\000\\005\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\001\\000\\024\\224\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015\\003!\\000@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015\\000\\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\\004\\129\\016#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\1306\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0002\\016\\004\\b\\000L\\018-\\000\\016\\024\\000\\000\\016@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\129!\\bD\\002\\128\\193#\\144\\000\\001\\128\\000\\001\\140\\b\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\206\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0026\\016$X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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!\\000D\\002\\128\\193#\\144\\000\\001\\128\\000\\001\\140\\004\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\005\\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\\128\\000\\017\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000$\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\017\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\b\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\129\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000P\\000\\000\\000\\016\\000\\000\\000\\000\\012\\0028\\000\\000\\000\\000\\000\\000\\000\\192\\000\\017\\000\\000\\000\\000\\000\\000\\003\\000\\016P$\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\196\\148\\187\\131\\232>\\022\\028\\015\\251`w\\219~p\\240\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000\\000\\000\\b\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\145\\003\\224\\012\\004\\004\\003\\224`\\016\\000X 8\\000\\001\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000@\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\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\\000\\000\\000\\000\\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\\002\\000@\\000\\000\\129\\004\\000\\000\\016\\000\\000\\000\\000\\000\\016 \\004\\000\\000\\b\\016\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\004\\000\\b\\000\\000\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\000\\004\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\016\\000\\004\\000\\000\\016 \\004\\000\\000\\b\\016\\000\\000\\001\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\146\\028\\000\\025\\000f\\000\\002\\000@\\016\\004\\004\\000\\002\\012\\016\\000\\000\\001\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\016\\000\\004\\000\\000\\000\\016\\000\\000\\000\\000\\016 \\004\\000\\000\\b\\016\\000\\000\\001\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\146\\028\\000\\025\\000f\\000\\002\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\016\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001 \\000\\000@\\000\\128\\006\\000\\000\\000\\128\\000\\000\\000\\000\\018\\000\\000\\000\\000\\b\\000`\\000\\000\\b\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\004\\000\\b\\000\\000\\000\\004\\000\\0000\\000\\006\\000\\000\\012\\\\(\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000@\\000\\002\\000\\000\\000\\000\\016\\000\\000\\017\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000@@\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\017\\000\\000\\000\\000\\004\\000\\000 \\000\\000\\000\\001\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\004\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\006\\000\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\133\\128\\162\\128\\b0R\\028\\000\\025\\000f\\001\\002\\016@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\133\\128\\162\\128\\b R\\028\\000\\025\\000f\\001\\002\\016@0\\000\\006\\000\\000\\012\\\\(\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\0000\\000\\006\\000\\000\\012\\\\(\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\006\\000\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\133\\128\\\"\\128\\b R\\028\\000\\025\\000f\\001\\002\\016HX\\n(\\000\\131\\005!\\192\\001\\144\\006`\\016!\\004\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\006\\000\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\133\\128\\\"\\128\\b R\\028\\000\\025\\000f\\001\\002\\016HX\\n(\\000\\131\\005!\\192\\001\\144\\006`\\016!\\004\\000\\000\\000\\000\\000\\000\\000\\004\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0002\\016D\\b\\000L\\018m\\000\\016\\024\\000\\000\\016@\\003!\\004@\\128\\004\\193\\\"\\208\\001\\001\\128\\000\\001\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003!\\000@\\128\\004\\193\\\"\\208\\001\\001\\128\\000\\001\\004\\bH\\002(\\000\\130\\001!\\128\\001\\144\\006`\\000 \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\196\\148\\187\\131\\232>\\022\\028\\015\\249`w\\139~p\\240\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\129\\002\\000@@\\000\\129\\004\\000\\000\\016\\000\\000\\000\\000\\000\\016 \\004\\000\\000\\b\\016@\\000\\001\\000\\000\\000\\000\\000\\001\\002\\000@\\000\\000\\129\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\b\\000@\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\016\\004\\004\\000\\002\\012\\016\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\128\\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\\b\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0002\\016\\004\\b\\000L\\018-\\000\\016\\026\\000\\000\\017@\\196\\148\\187\\131\\232>\\022\\028\\015\\249`w\\139~p\\248\\000\\b\\128>\\000\\192@@>\\002\\001\\000\\007\\194\\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\\129\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\b\\000\\000\\016\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\129\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\b\\000\\000\\016\\000\\004\\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 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\004\\000\\000\\128\\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\\bH\\002(\\000\\130\\t!\\192\\001\\016\\006`\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016 \\004\\000\\000\\b\\016@\\000\\001\\000\\000\\000\\000\\000\\001\\002\\000@\\000\\000\\129\\000\\000\\000\\016\\000\\000\\000\\000\\bH\\002(\\000\\130\\t!\\192\\001\\016\\006`\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0008\\000@\\004\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000@\\000@\\004\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\004\\000@\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\128\\001\\016\\007`\\000 \\000\\001\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\012H\\002(\\000\\131\\001!\\192\\001\\016\\006`\\000 \\000\\132\\128\\\"\\128\\b \\018\\024\\000\\017\\000f\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\004\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\0000\\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\\b\\000\\000\\000\\000\\001\\000\\000@\\000\\132\\128\\\"\\128\\b \\018\\024\\000\\017\\000f\\000\\002\\000HH\\002(\\000\\130\\001!\\000\\001\\016\\006`\\000 \\004\\003\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\016\\000\\004\\000\\bH\\002(\\000\\130\\001!\\128\\001\\016\\006`\\000 \\004\\132\\128\\\"\\128\\b \\018\\016\\000\\017\\000f\\000\\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\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\001\\000\\000@\\000\\132\\128\\\"\\128\\b \\018\\024\\000\\017\\000f\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000}\\246D\\b/\\227P\\000L\\028\\030\\227\\139\\002\\131B~\\018-X\\170\\2233=\\001@\\254\\000\\000x\\224\\003!\\000@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\001\\000\\000 \\000\\000\\000\\000@\\000\\000\\000\\000\\004\\129\\016#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000}\\246D\\b/\\227P\\000L\\028\\030\\227\\139\\002\\131B~\\018-X\\170\\2233=\\001@\\254\\000\\000x\\224\\001\\002\\000@@\\000\\129\\004\\000\\000\\016\\000\\000\\000\\000\\000\\016 \\004\\000\\000\\b\\016@\\000\\001\\000\\000\\000\\000\\000\\001\\002\\000@\\000\\000\\129\\000\\000\\000\\016\\000\\000\\000\\000\\bH\\002(\\000\\130\\t!\\192\\001\\016\\006`\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\012\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\192\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b\\\"\\018\\028\\012\\017\\000v\\001\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\018(\\000\\130\\001!\\128\\001\\016\\006`\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\128\\001\\016\\006`\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130!!\\192\\193\\016\\007`\\016 \\000\\001 \\000\\000@\\000\\128\\006\\000\\000\\000\\128\\000\\000\\000\\000\\018\\000\\000\\000\\000\\b\\000`\\000\\000\\b\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\000\\bH\\002(\\000\\194\\001!\\192\\001\\016\\007`\\000`\\000\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\132\\128\\\"\\128\\b \\018\\028\\000\\017\\000f\\016\\002\\016\\000\\016\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\bH\\002(\\000\\130\\001!\\192\\001\\016\\006`\\000 \\000\\132\\128\\\"\\128\\b \\018\\024\\000\\017\\000f\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\018\\028\\000\\017\\000f\\000\\002\\000\\bH\\002(\\000\\130\\001!\\128\\001\\016\\006`\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000x\\002/\\001\\130\\012} \\001\\016\\006\\000\\000 \\000\\132\\128\\\"\\128\\b \\002\\016\\000\\016\\000f\\000\\002\\000\\000\\016\\000\\000\\004\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000@\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\016\\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\\bH\\002(\\000\\130\\b!\\128\\001\\000\\006a\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\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\\bH\\002(\\000\\130\\b!\\128\\001\\000\\006a\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0008\\000@\\004\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000@\\000@\\004\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\004\\000@\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\000!\\128\\001\\000\\007`\\001 \\000\\001\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\012H\\002(\\000\\131\\000!\\192\\001\\000\\006`\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000@\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\003\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\001\\000\\001@\\000\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\130\\024\\000\\016\\000f\\016\\002\\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\\001\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\012H\\002(\\000\\131\\000!\\192\\001\\000\\006`\\000 \\004\\132\\128\\\"\\128\\b \\002\\016\\000\\016\\000f\\000\\002\\000@0\\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\\001\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\012H\\002(\\000\\131\\000!\\192\\001\\000\\006`\\000 \\004\\132\\128\\\"\\128\\b \\002\\016\\000\\016\\000f\\000\\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\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\001\\000\\000@\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\000!\\128\\001\\000\\006a\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\004\\004\\000\\002\\012\\016\\000\\000\\001\\000\\000\\000\\000\\000\\196\\128\\\"\\128\\b0\\002\\028\\000\\016\\000f\\000\\002\\000\\bH\\002(\\000\\130\\000!\\128\\001\\000\\006`\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\004\\004\\004\\002\\012\\016@\\000\\001\\000\\000\\000\\000\\000\\001\\000@@\\000 \\193\\004\\000\\000\\016\\000\\000\\000\\000\\000\\016\\004\\004\\000\\002\\012\\016\\000\\000\\001\\000\\000\\000\\000\\000\\196\\128\\\"\\128\\b0\\002\\028\\000\\016\\000f\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001 \\000\\000@\\000\\128\\006\\000\\000\\000\\128\\000\\000\\000\\000\\018\\000\\000\\000\\000\\b\\000`\\000\\000\\b\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\000\\bH\\002(\\000\\194\\000!\\192\\001\\000\\006`\\000`\\000\\b\\128\\000\\000@\\000@\\006\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\004\\000\\004\\000`\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000@\\006\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\004\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000 \\000\\000\\000\\000\\000\\000\\000\\002\\000\\000$\\128\\004\\000\\000\\000\\128\\000\\000\\000\\000\\b\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\016\\000\\004\\000 \\005\\016 \\000\\000\\000\\000\\000\\000\\000\\132\\000\\000\\128\\000\\002\\130\\020\\004\\000\\000\\002\\001\\000\\000\\b@\\000\\b\\000\\000(!\\000@\\000\\000 \\016\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b@\\000\\b\\000\\000 !\\000@\\000\\000 \\016\\000\\000\\b\\000\\000\\000\\000@@\\004\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\004\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\b@\\000\\b\\000\\000 !\\192@\\000\\000 \\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\128\\000\\004\\000@\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\b\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\132\\000\\000\\128\\000\\002\\002\\024\\004\\000\\000\\002\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000@\\002\\000Q\\006\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\004\\000 \\005\\016 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\128\\001\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\016\\000\\000\\000\\016\\000\\004\\000 \\005\\016 \\000\\000\\000\\000\\000\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\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\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000@\\000\\000\\000\\000\\004\\000\\000\\000\\000\\002\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002\\168\\000\\130!!\\192A\\016\\007`\\016 \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\016\\000\\000\\000\\016\\000\\004\\000 \\005\\016 \\000\\000\\000\\000\\000\\000\\000\\132\\128*\\128\\b\\\"\\018\\028\\004\\017\\000v\\001\\002\\000H@\\000\\b\\000\\000 !\\192@\\000\\000 \\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\`\\000\\016\\000\\000\\000\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\001\\000\\000\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\b@\\000\\b\\000\\000 !\\192\\192\\000\\000 \\016\\000\\000\\132\\000\\000\\128\\000\\002\\002\\024\\004\\000\\000\\002\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000\\000\\000\\b@\\000\\b\\000\\000 !\\128@\\000\\000 \\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\000\\000\\128\\000\\002\\002\\016\\004\\000\\000\\002\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\018\\028\\000\\017\\000f\\000\\002\\000HH\\002(\\000\\130\\001!\\000\\001\\016\\006`\\000 \\004\\b\\000\\000\\000\\000\\000@\\006\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\004\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\016\\000\\004\\000 \\005\\016 \\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\018\\028\\000\\017\\000f\\000\\002\\000HH\\002(\\000\\130\\001!\\000\\001\\016\\006`\\000 \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000@\\006\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\004\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\0000\\000\\007\\001 \\r\\\\ \\000\\016\\000\\000\\000\\000\\000\\133\\128\\170\\128\\b0B\\028\\000\\017\\000v\\000\\006\\000@0\\000\\006\\000\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001 \\r\\\\ \\000\\016\\000\\000\\000\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\020\\000\\000\\000 \\000\\000\\000\\000@\\000\\000\\000\\000\\004\\001\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001 \\r\\\\ \\000\\016\\000\\000\\000\\000\\000\\003\\000\\000`\\000\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000p\\018\\000\\213\\194\\000\\001\\000\\000\\000\\000\\000\\bX\\n\\168\\000\\131\\004!\\192\\001\\016\\007`\\000 \\004\\133\\128\\170\\128\\b0B\\028\\000\\017\\000v\\000\\002\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128*\\128\\b \\002\\028\\000\\016\\000v\\000\\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\\bH\\002(\\000\\130\\000!\\128\\001\\000\\006`\\000 \\004\\132\\128\\\"\\128\\b \\002\\016\\000\\016\\000f\\000\\002\\000@\\128\\000\\000\\000\\000\\004\\000`\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000@\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000p\\018\\000\\213\\194\\000\\001\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\000!\\128\\001\\000\\006`\\000 \\004\\132\\128\\\"\\128\\b \\002\\016\\000\\016\\000f\\000\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\002\\016\\000\\016\\000f\\000\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\002\\024\\000\\016\\000f\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\002\\016\\000\\016\\000f\\000\\002\\000@ \\000\\002H\\000L\\000@\\b\\000\\000\\000\\000\\000\\128\\002\\000\\000$\\128\\004\\192\\000\\000\\128\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\018\\024\\000\\017\\000v\\001\\002\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\018\\024\\000\\017\\000f\\001\\002\\000HH\\002(\\000\\130\\001!\\000\\001\\016\\006`\\000 \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\002\\016\\000\\016\\000f\\000\\002\\000@ \\000\\002H\\000L\\000@\\b\\000\\000\\000\\000\\000\\128\\002\\000\\000$\\128\\004\\192\\000\\000\\128\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\0002\\000\\007\\129\\000\\012\\\\(\\000\\016\\b\\002\\000\\001\\000\\003\\000\\002p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\020\\000\\000\\000\\000\\000\\004\\004\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bZ\\002(\\000\\130\\t!\\160\\001\\016\\014`\\016 \\004\\132\\128\\\"\\128\\012 \\018\\028\\000\\017\\000f\\001\\006\\016HH\\002(\\000\\130\\001!\\192\\001\\016\\006`\\016!\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\128\\001\\016\\006`\\016!\\004\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\000!\\128\\001\\000\\006`\\016 \\004\\132\\128\\\"\\128\\b \\002\\016\\000\\016\\000f\\000\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\018\\028\\000\\017\\000v\\001\\002\\000@\\018\\000\\000\\128\\000\\b\\000(\\000\\000\\b\\002\\000\\001\\000\\001 \\000\\000\\000\\000\\128\\002\\128\\000\\000\\128 \\000\\016\\000\\000\\000\\000\\000\\004\\004\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\012 \\018\\028\\000\\017\\000f\\001\\006\\016HH\\002(\\000\\130\\001!\\192\\001\\016\\006`\\016!\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\004\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\b\\128\\000\\000@\\000@\\006\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\004\\000`\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000@\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\0002\\144\\005\\t\\000L\\018+\\000\\016\\025\\000\\000P@\\001\\000\\000@\\002\\000\\209\\002\\000\\000\\004\\000\\000\\000\\000\\b@\\000\\b\\000\\000(!@\\192\\000\\000 \\016\\000\\000\\132\\000\\000\\128\\000\\002\\130\\016\\012\\000\\000\\002\\001\\000\\000\\b@\\000\\b\\000\\000 !\\000\\192\\000\\000 \\016\\000\\000\\b\\000\\000\\000\\000@@\\004\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\004\\004\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000$\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\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#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\000\\000\\128\\000\\002\\002\\024\\012\\000\\000\\002\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000@@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\132\\000\\000\\128\\000\\002\\002\\028\\012\\000\\000\\002\\001\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000$\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\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#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\b\\000\\000@\\004\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\128\\000\\004\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\0002\\144\\005\\t\\000L\\018+\\000\\016\\025\\000\\000P@\\003\\128\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\016\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\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#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b@\\000\\b\\000\\000 !\\128\\192\\000\\000 \\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\128\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000p\\016\\000\\197\\194\\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\\000\\000\\000\\000\\0002\\144\\005\\t\\000L\\018+\\000\\016\\025\\000\\000P@\\003\\128\\000p\\016\\000\\197\\194\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\016\\000\\000\\000\\0026\\016\\004X(\\223\\018=\\000@\\248\\000\\000\\024\\224\\000\\000\\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#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0026\\016\\004X(\\223\\018}\\000@\\248\\000\\000\\024\\224#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\b@\\000\\b\\000\\000 !\\128\\192\\000\\000 \\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\004\\000 \\r\\016`\\000\\000@\\000\\000\\000\\128\\001\\000\\000@\\002\\000\\209\\006\\000\\000\\004\\000\\000\\000\\000\\000\\016\\000\\004\\000 \\r\\016 \\000\\000@\\000\\000\\000\\000\\001\\000\\000@\\002\\000\\209\\002\\000\\000\\004\\000\\000\\000\\000\\0002\\016D\\012\\128L\\018m\\000\\016\\024\\000\\000\\016@}\\246D\\b/\\227P\\000L\\028\\030\\227\\139\\002\\131@2\\016D\\b\\000L\\018m\\000\\016\\024\\000\\000\\016@\\003!\\004@\\128\\004\\193\\\"\\208\\001\\001\\128\\000\\001\\004\\0002\\016\\004\\b\\000L\\018-\\000\\016\\024\\000\\000\\016@\\000\\000\\000\\000\\000\\000\\000\\b\\000\\b\\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\\004\\000\\000\\000\\000\\000\\000\\b\\000\\016\\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\\128\\000\\001\\000\\000\\000\\001\\000\\000@\\002\\000\\209\\002\\000\\000\\004\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\016\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0002\\144\\005\\t\\000L\\018k\\000\\016\\024\\000\\000\\016@\\003)\\000P\\144\\004\\193\\\"\\176\\001\\001\\128\\000\\001\\004\\0002\\144\\005\\t\\001L\\018+\\000\\016\\024\\000\\000\\016@\\001\\000\\000@\\002\\000\\209\\002\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\004\\001\\000\\000@\\002\\000\\209\\002\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\133\\169*\\212\\026\\162\\211?\\188\\017\\001\\230\\001\\007\\141HZ\\146\\173A\\170-3\\251\\193\\016\\030`\\016x\\212\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002\\168\\000\\130!!\\192\\193\\016\\006`\\016`\\020\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128*\\128\\b\\\"\\018\\028\\012\\017\\000f\\001\\006\\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\\bH\\002\\168\\000\\130!!\\192\\193\\016\\006`\\016`\\020\\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\\128\\000\\001\\000\\000\\000\\001\\000\\000@\\002\\000\\209\\002\\000\\000\\004\\000\\000\\000\\000\\bH\\002\\168\\000\\130!!\\192\\193\\016\\006`\\016`\\020\\003!\\004@\\128\\004\\193\\\"\\208\\001\\001\\128\\000\\001\\004\\0002\\016\\004\\b\\000L\\018-\\000\\016\\024\\000\\000\\016@\\000\\000\\000\\000\\000\\000\\000\\b\\000\\b\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\b\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001 \\r\\\\ \\000\\016\\000\\000\\000\\000\\000\\128\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b@\\000\\b\\000\\000 !\\192\\192\\000\\000 \\016\\000\\016\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\000\\000\\128\\000\\002\\002\\024\\012\\000\\000\\002\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000@\\002\\000\\209\\002\\000\\000\\004\\000\\000\\000\\000\\b@\\000\\b\\000\\000 !\\192\\192\\000\\000 \\016\\000\\016\\132\\000\\000\\128\\000\\002\\002\\024\\012\\000\\000\\002\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000p\\016\\000\\197\\198\\000\\001\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\132\\000\\000\\128\\000\\002\\002\\024\\012\\000\\000\\002\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000\\000\\000\\b@\\000\\b\\000\\000 !\\128\\192\\000\\000 \\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\000\\000\\128\\000\\002\\002\\016\\012\\000\\000\\002\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\018\\028\\000\\017\\000f\\000\\002\\000@0\\000\\007\\001 \\r\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\016\\000\\004\\000 \\r\\016 \\000\\000@\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\018\\028\\000\\017\\000f\\000\\002\\000@2\\144\\005\\t\\000L\\018+\\000\\016\\025\\000\\000P@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\128\\001\\016\\006`\\000 \\004\\132\\128\\\"\\128\\b \\018\\016\\000\\017\\000f\\000\\002\\000@\\128\\000\\000\\000\\000\\004\\000`\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000@\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\0002\\144\\005\\t\\000L\\018+\\000\\016\\025\\000\\000P@\\132\\128\\\"\\128\\b \\018\\024\\000\\017\\000f\\000\\002\\000HH\\002(\\000\\130\\001!\\000\\001\\016\\006`\\000 \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\000\\001\\000\\006`\\000 \\000\\003!\\004@\\192\\004\\193&\\208\\001\\001\\128\\000\\001\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\000\\001\\016\\006`\\000 \\004\\132\\128\\\"\\128\\b \\018\\024\\000\\017\\000f\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\018\\016\\000\\017\\000f\\000\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\128\\001\\000\\006`\\000 \\000\\132\\128\\\"\\128\\b \\018\\016\\000\\016\\000f\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\000\\001\\144\\006`\\000 \\004\\000\\000\\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\\132\\128\\\"\\128\\b \\018\\024\\000\\016\\000f\\000\\002\\000\\bH\\002(\\000\\130\\001!\\000\\001\\000\\006`\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000\\000\\000\\012H\\002\\168\\000\\131\\t!\\192\\001\\016\\007`\\002 \\004\\192\\000\\b\\000\\000\\016\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000@\\000\\000\\000\\000\\004\\193\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\000\\000\\128\\000\\002\\002\\016\\012\\000\\000\\002\\001\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b2\\016\\004\\b\\000L\\018-\\000\\016\\026\\000\\000\\017@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012IK\\184>\\131\\225a\\192\\255\\150\\007x\\183\\231\\015\\000\\000\\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\\000\\000\\000\\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\\b\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\016\\000\\018\\000\\000\\000\\000\\b\\000 \\000\\000\\b\\000\\000\\001\\000\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\000\\bH\\002(\\000\\194\\001!\\192\\001\\016\\007`\\000a\\000\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\000\\bH\\002(\\000\\130\\001!\\192\\001\\016\\006`\\000!\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\128\\001\\016\\006`\\000!\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\194\\001!\\192\\001\\016\\007`\\000a\\000\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\000\\bH\\002(\\000\\130\\001!\\192\\001\\016\\006`\\000!\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\130\\b \\018\\024\\000\\017\\000v\\001\\002\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\018\\024\\000\\017\\000f\\001\\002\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\018\\000\\000\\128\\000\\b\\000 \\000\\000\\b\\000\\000\\001\\000\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\016\\bH\\002(\\000\\130\\001!\\128\\001\\016\\006`\\000!\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\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\\002\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\0000\\000\\006\\000\\000\\012\\\\`\\000\\018\\000\\002\\000\\000\\000\\003\\000\\000`\\000\\000\\197\\194\\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\\000\\000\\000\\000\\016\\001\\000\\000\\000\\004\\000\\000\\000\\018\\000\\000\\000\\000\\000\\003\\000\\000`\\000\\000\\197\\194\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\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\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\016\\000\\000\\000\\000\\004\\000\\000\\000\\016\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\128\\000\\000\\000\\000@\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0000\\000\\007\\001\\000\\012\\\\ \\000\\016\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\004\\004\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\bH\\002(\\000\\130\\001!\\192\\001\\016\\006`\\016 \\004\\000\\000\\000\\000\\000\\000\\000\\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 \\000x\\016\\000\\197\\194\\128\\001\\000\\128 \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\002\\024\\000\\016\\000f\\001\\002\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\018\\000\\000\\128\\000\\b\\000 \\000\\000\\b\\000\\000\\001\\000\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\016\\bH\\002(\\000\\130\\000!\\128\\001\\000\\006`\\000!\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\bH\\002( \\130\\000!\\128\\001\\000\\007`\\017 \\004\\003 \\000x\\016\\000\\197\\194\\128\\001\\000\\128 \\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\002\\024\\000\\016\\000f\\001\\002\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\018\\000\\000\\128\\000\\b\\000 \\000\\000\\b\\000\\000\\001\\000\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\016\\bH\\002(\\000\\130\\000!\\128\\001\\000\\006`\\000!\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\b\\000\\000\\016\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\128\\\"\\128\\b \\018\\024\\000\\017\\000f\\000\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\128 \\128\\b \\002\\016\\000\\016\\000d\\000\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\192\\002\\000\\000\\000\\128\\000\\000\\000\\b\\000\\b\\128~\\002\\194@\\000>\\\"\\001\\004\\001\\130\\139\\000\\000\\b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\016\\000\\000\\000\\016\\000\\000\\000\\000\\012\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\000\\128\\007\\224,$\\000\\003\\226 \\016@\\024(\\176\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\128\\002\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\000\\000p\\016\\000\\197\\194\\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\\004\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000#a\\000E\\130\\141\\241#\\208\\004\\015\\128\\000\\001\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\000\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\004\\016\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\002\\000@\\000\\000\\129\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\128\\004\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000@@\\000 \\193\\000\\000\\000\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\016\\000\\004\\000\\000\\000\\004\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003!\\000@\\128\\004\\193\\\"\\208\\001\\001\\160\\000\\001\\004\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000@\\004\\129\\016\\000\\000\\000\\000\\000\\000\\000\\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\\192\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000@\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\016\\000\\000\\000\\016\\000\\000\\000\\000\\012\\000\\000\\000\\000\\000\\000\\000\\000\\000'\\225 \\197\\138\\173\\2433\\208\\021\\015\\228\\000\\003\\142\\000\\016\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\161 \\128\\b \\210\\016\\016\\017\\000\\228\\000\\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\128 \\128\\b \\018\\016\\000\\017\\000d\\016\\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\\000\\000\\000\\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\\000H\\002\\b\\000\\130\\001!\\000\\001\\000\\006\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\000\\000\\000\\000\\000\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000'\\225 \\197\\138\\173\\2433\\208\\021\\015\\228\\000\\003\\142\\002~\\018\\012X\\170\\2233=\\001P\\254@\\0008\\224\\004\\128 \\128\\b \\018\\016\\000\\017\\000d\\000\\002\\000\\000H\\002\\b\\000\\130\\001!\\000\\001\\016\\006@\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\128 \\128\\b \\018\\024\\000\\017\\000d\\000\\002\\000\\000H\\002\\b\\000\\130\\001!\\000\\001\\016\\006@\\000 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000H\\002\\b\\000\\130\\001!\\128\\001\\016\\006@\\000 \\000\\004\\128 \\128\\b \\018\\016\\000\\017\\000d\\000\\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\\000\\000\\000\\000\\000\\000\\000\\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 \n and start =\n 15\n \n and action =\n ((16, \"C\\170R\\004Ff\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\021HFf\\000\\000\\000\\000\\020XFfC\\170\\020\\182\\000-\\000[]\\188\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\132\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\021\\238\\001\\208\\001d\\000\\000\\002t\\001\\188\\000\\000\\003\\214\\003$\\007\\140\\000\\000\\005\\244\\003\\132\\b\\132\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\220\\000\\000\\000\\000\\000\\000\\003\\190l*\\000\\000\\000\\000\\000\\000\\005.\\000\\000\\000\\000R\\232\\004\\196\\006&\\000\\000\\000\\000V&\\005.\\000\\000J\\014\\020X\\021\\178^T\\020Xh:R\\004\\020XN`\\000\\000\\005\\144\\000\\000Dp\\006\\136\\000\\000C\\146\\000\\000\\027\\158\\000\\000\\000\\000\\003\\224\\000\\000\\005.\\000\\000\\000\\000\\000\\000\\005\\\\\\000\\000C\\146\\000\\000\\006&|4`\\020f\\150\\000\\000\\1340\\136\\022\\000\\000Mra\\190\\000\\000Zr\\026\\206l*FfC\\170\\000\\000\\000\\000R\\004\\020XTBDp\\006\\214x\\\"\\000\\000\\130\\142FfC\\170R\\004\\020X\\000\\000\\000\\000\\016xQ\\254\\020XG\\030Y\\222\\000\\000\\001\\026\\000\\000\\000\\000\\004\\250\\000\\000\\000\\000I\\182\\001\\026\\024\\138\\005\\200\\tR\\000\\000\\000\\000\\002\\026\\000\\000\\021\\178\\007X\\007\\136\\020X\\028\\254\\020XC\\170C\\170\\000\\000\\000\\000\\000\\000R\\012Q\\182\\020X\\028\\254A\\248\\020X\\000\\000\\023\\022\\bZ\\007\\012\\000\\000\\000\\220\\007\\030\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\020X\\000\\000\\000\\000\\000\\000R\\004\\020X\\000\\000A\\206x\\168C\\170\\000\\248\\000\\000Y\\222{\\230|\\206\\000\\000\\007\\012\\000\\000\\005J\\000\\000\\000\\000C,V&\\136b\\000\\000jb\\136b\\000\\000jbjb\\000b\\006\\n\\0008\\000\\000\\020\\190\\000\\000\\b\\004\\000\\000\\000\\000\\b\\004\\000\\000\\000\\000\\000\\000jb\\005.\\000\\000\\000\\000X\\244V&V\\154a\\190\\000\\000\\000\\000OL\\000b\\000\\000\\000\\000a\\190\\n\\236V&\\000\\000PBa\\190Q8\\000\\000\\000\\000\\000\\000\\003b\\000\\000jb\\000\\000\\001\\000m\\\"\\000\\000V&\\005\\216V&\\000\\000\\022\\\\\\011p\\005.\\000\\000\\000\\000\\023\\224\\000\\000\\006\\208\\000\\000[\\150\\006\\230\\000\\000\\n\\204jb\\007\\222\\000\\000\\t\\206\\000\\000\\t\\184\\000\\000\\000\\000\\006\\168\\000\\000\\000\\000\\000\\000\\021 4Y\\222Q\\240\\020XY\\222\\000\\000\\000b\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000N\\\\\\027v\\000\\000\\000\\000\\000\\000\\001\\244&\\174u\\242\\000\\000\\000\\000Q\\240\\020XY\\222\\000\\000\\000\\000\\138(Y\\222\\138p|\\206\\000\\000\\138\\202\\000\\000Y\\222\\000\\000\\000\\000Z\\202I\\182\\001\\154\\001\\154\\000\\000\\012tY\\222\\000\\000\\000\\000\\000\\000\\004\\250\\014\\014\\000\\000A\\012\\000\\000\\000\\000}\\022\\000\\000\\139\\012jb\\000\\000\\004R\\000\\000\\000\\000}\\162\\000\\000\\139f\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\014\\152\\000\\000\\022\\168\\000\\000\\000\\000}\\162\\000\\000\\005\\220\\000\\000\\000\\000DHv~\\000\\000\\000\\000Bn\\023|\\019\\252\\023\\174\\000\\000\\000\\000\\000\\000\\000\\000\\002>\\000\\000\\000\\000\\\\`\\t\\192\\014x\\000\\017V&\\000\\226\\014\\196\\000\\000\\000\\000\\n\\184\\014x\\003x\\000\\000R\\004R\\144Q\\182\\020X\\028\\254\\000-\\000\\018\\011\\154\\000\\000\\014x\\021\\178\\021\\178\\000-\\000\\018\\000\\018\\021\\178\\000\\000k`\\nXDp\\007\\012\\011\\020\\139\\156\\000\\000V&g6V&`\\244g\\214V&\\003\\202V&hp\\000\\000\\012\\002\\b\\022\\0124\\021\\178l\\000\\000\\000\\b*\\bL^v\\000\\000\\000\\000\\000\\000\\000\\000\\021\\178lX\\021\\178l\\248\\020d\\0008a\\148\\007\\030\\0008a\\236\\000\\000mP\\nX\\000\\000\\000\\000\\000\\000\\002\\152\\000\\000\\000\\000\\006x\\000\\000\\tb\\028\\254\\000\\000_4A\\248\\000\\000\\031\\138\\000\\000\\000\\000\\021\\178\\003\\144\\000\\000\\000\\000\\000\\000\\000\\000]\\024\\000\\000\\001\\248\\000\\000Wf\\n\\024\\0032\\000\\000\\0226R\\144R\\004\\020XH(\\158\\000\\000\\011\\172\\b\\184\\000\\00056\\000\\000\\n\\202\\t\\176\\000\\0006.\\000\\000\\014\\164\\n\\168\\000\\0007&\\004J\\025\\016\\000\\000\\012\\164\\011\\160\\000\\0008\\030\\000\\000\\n\\224\\012\\152\\000\\0009\\022\\000\\000\\014\\250\\r\\144\\000\\000:\\014\\014\\136\\000\\000;\\006\\015\\128\\019`\\000\\000\\000\\000\\000\\000\\r\\156\\000\\000\\000\\000\\012\\186\\000\\000\\000\\000\\015X\\000\\000\\n:\\000\\000\\000\\000\\000\\000\\016\\016\\000\\000\\0162\\000\\000\\000\\000Lz\\001\\154\\016\\246r\\028a\\190\\000b\\000\\000\\000\\000r\\028\\000\\000\\000\\000\\000\\000r\\028\\000\\000\\016\\236\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000;\\254Y\\222\\000\\000\\000\\000\\017.\\000\\000<\\246\\000\\000=\\238\\000\\000#\\250\\000\\000\\000\\000\\005\\134\\000\\000\\000\\000Y\\222\\000\\000\\000\\000y\\164\\015L\\000\\000\\000\\000H\\240\\000\\000\\007\\248\\000\\000\\000\\000X*\\000\\000\\r\\178\\000\\000\\000\\000\\005@\\011\\254\\000\\000\\000\\000\\0226\\022\\028\\007\\012\\000\\000A\\214\\000\\000!,\\023\\176\\021\\220\\000\\000\\000\\000\\015\\156\\000\\000\\000\\000\\001\\238\\025\\030X\\192\\000\\000\\025\\030\\000\\000\\011\\238\\000\\000\\000\\000\\015\\242\\000\\000\\000\\000i\\018\\t\\002\\005@\\000\\000\\000\\000\\012\\246\\000\\000\\000\\000\\r\\200\\000\\000\\000\\000\\000\\000\\020X\\028\\254\\003\\202\\000\\000\\000\\000\\023&\\005\\200\\tR\\004\\128\\028\\254z2\\021\\178\\020X\\028\\254z\\138\\016\\206\\000\\000\\000\\000\\004\\128\\000\\000I\\248\\019\\248\\021\\204\\000\\000\\t*\\017P\\000\\000\\017P\\000Va\\190\\000\\244\\000\\000\\017*\\016\\184l*\\011\\164V&\\030\\128\\020F\\r\\018\\003\\b\\000\\000\\031x\\017l\\000\\000\\000\\244\\000\\000\\000\\000\\017\\136a\\190b\\140\\000\\000idg$\\r\\028a\\190\\017da\\190n\\156c,\\017ha\\190o\\026c\\204\\001\\024\\017*\\000\\000\\000\\000\\000\\000\\020X\\130\\216\\000\\000Y\\222rj\\000\\000\\000\\000\\017\\166\\000\\000\\000\\000\\000\\000>\\230\\000\\000\\014\\170\\000\\000\\000\\000\\000\\000Up\\020X\\028\\254\\003\\202\\000\\000F\\138\\000\\000\\bh\\000\\000\\000*\\000\\000\\000\\000\\017\\172\\000\\000\\017\\214{\\230?\\222j\\016\\000\\000\\000\\000IZ\\000\\000\\t`\\000\\000N\\150\\000\\000\\020X\\000\\000\\021\\178\\nX\\000\\000\\130\\142\\000\\000\\020X\\028\\254\\130\\142\\000\\000\\025D\\023\\022\\bZ\\005.\\132\\202\\021\\178\\127\\144rj\\000\\000\\005\\200\\tR\\tR\\004\\128rj\\134\\164\\005\\200\\tR\\004\\128rj\\134\\164\\000\\000\\000\\000\\004\\128rj\\000\\000FfC\\170Y\\222\\027B\\000\\000\\000\\000FfC\\170Q\\182\\020X\\028\\254\\130\\142\\000\\000\\020\\182\\000-\\000[\\017\\bl*\\r(V&s\\004\\017<\\017\\236\\133H\\000\\000rj\\000\\000s\\128I\\248\\019\\248\\021\\204{\\b\\023\\228\\tZ\\128\\012\\014:\\0178\\020Xrj\\000\\000\\020Xrj\\000\\000jbh:\\019\\134\\003\\214\\005\\200\\0008P\\012\\000\\000\\005\\200\\0008P\\012\\000\\000\\0274\\023\\022\\bZ\\005.Q\\002\\021\\178\\130b\\000\\000\\005\\200\\nJ\\0212\\005\\236\\000\\000P\\012\\000\\000\\tR\\017<\\021\\178\\131\\030\\136\\216\\005\\200\\tR\\017>\\021\\178\\131\\030\\136\\216\\000\\000\\000\\000\\b`\\000\\000\\135\\158\\000\\000\\021\\178\\133\\160P\\012\\000\\000\\b`\\000\\000J\\014\\020X\\021\\178\\130b\\000\\000I\\248\\019\\248\\021\\204s\\252B\\138\\026\\222\\019\\170\\002\\142\\000\\000\\014ZC\\146\\000\\017\\000\\000\\017\\184\\017f\\024\\196\\020XV\\206V&\\015\\n\\000\\000Y\\172\\n\\254\\007\\188\\011\\246\\000\\000\\011\\234\\000\\000\\017\\198\\017ZV&PJ\\000\\000\\0032\\002\\228\\014\\192\\000\\000\\r\\000\\000\\000\\017\\216\\017fl*PJ\\000\\000\\020X\\024\\196\\018\\020\\011\\028\\005\\200\\000\\000\\015\\184\\024\\196V&\\012\\208\\000b\\000\\000V&\\004\\018\\004\\176\\000\\000\\000\\000ot\\000\\000\\000\\000\\015\\212\\024\\196o\\242PJ\\000\\000\\020XV&\\r\\218V&MzPJ\\000\\000\\0154\\000\\000\\000\\000PJ\\000\\000\\000\\000Y\\172\\000\\000rj\\134\\178\\019\\170\\002\\142\\014Z\\017\\252\\017\\182\\024\\196rj\\134\\178\\000\\000\\000\\000\\019\\170\\002\\142\\014Z\\018\\012\\017\\150O\\030Mha\\190\\018\\030O\\030jb\\020\\184\\018$O\\030a\\190\\018.O\\030p\\146q\\018\\000\\000\\131\\156\\000\\000\\000\\000rj\\136\\230\\019\\170\\002\\142\\014Z\\018(\\017\\184O\\030rj\\136\\230\\000\\000\\000\\000\\000\\000h:\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000P\\012\\000\\000\\135D\\020XDp\\018:x\\\"\\000\\000\\130\\142\\135D\\000\\000\\000\\000\\1372\\020XDp\\018>\\017\\220`\\020\\137\\170\\000\\244\\018\\136\\000\\000\\000\\000q\\144s\\252\\020X\\000\\000\\128d\\021\\204\\000\\000\\000\\000\\130\\142\\1372\\000\\000\\000\\000\\000\\000{`D\\228F\\134\\000\\244\\018\\140\\000\\000\\000\\000\\000\\000s\\252\\020X\\000\\000\\000\\244\\018\\152\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\011\\028B\\138\\019\\170\\002\\142\\014Z\\018jtl\\023\\204\\020XG\\030\\\\.\\020(\\003\\b\\000\\244\\018n\\n\\152\\000\\000\\000\\000\\018\\\"\\000\\000\\000\\000b\\186\\000\\000\\t\\172\\014\\222\\000\\000\\r\\248\\000\\000\\018x\\018\\016V&Xr\\018\\160\\011l\\000\\000\\000\\000\\018R\\000\\000\\000\\000\\020F\\0032\\015|\\000\\000\\018\\172t\\238\\140B\\001\\154\\018JV&\\015\\024\\000\\000\\000\\000\\018\\\\\\000\\000\\000\\000\\000\\000b\\186\\000\\000\\0068\\015\\202\\000\\000\\015&\\000\\000\\018\\178\\018Fl*\\000\\000\\018\\202up\\140t\\001\\154\\018lV&\\015\\202\\000\\000\\000\\000\\018\\130\\000\\000\\000\\000\\000\\000\\020X\\000\\000b\\186\\000\\000\\020z\\020X\\023\\204\\023\\204v\\198Ff\\020X\\130\\216Y\\222\\021\\162\\000\\000\\012V\\005\\200\\000\\000\\015\\252\\023\\204V&\\015\\184\\007\\012\\000\\000\\020XY\\222tl\\023\\204\\015\\146\\023\\204\\000\\000D\\142Et\\000\\000d&\\000\\000\\000\\000d\\194\\000\\000\\000\\000e^\\000\\000\\016R\\023\\204e\\250\\130\\216Y\\222\\021\\162\\000\\000\\000\\\"\\000\\000\\000\\000O\\030\\015\\170\\000\\000\\000\\000Wf\\018\\242\\000\\000b\\186\\000\\000\\023\\204Wfb\\186\\000\\000\\020XV&b\\186\\000\\000\\016\\026\\000\\000\\000\\000b\\186\\000\\000\\000\\000\\\\.\\000\\000\\131\\244O\\030\\018\\160\\023\\204\\132rtl\\000\\000rj\\135R\\019\\170\\002\\142\\014Z\\019\\002tlrj\\135R\\000\\000\\000\\000\\000\\000\\137\\242Q\\240\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\133\\218rj\\000\\000\\135D\\000\\000\\000\\000\\000\\000\\000\\000rj\\137\\242\\000\\000\\019:\\000\\000\\000\\000\\133\\218\\019<\\000\\000rj\\137\\242\\000\\000\\000\\000\\016\\198\\000\\000\\000\\000k\\b\\004\\136\\000\\000\\000\\000B\\158\\000\\000V&\\016\\234\\000\\000\\\\.\\016\\232\\000\\000\\000\\000\\019j{\\230\\000\\000@\\214\\019F\\000\\000\\000\\000\\019@\\026R\\028B\\021\\204wN\\023\\228\\020X\\000\\000rj\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000wb\\023\\228\\020X\\000\\000\\014*x\\\"\\000\\000\\130\\142\\000\\000\\019F\\026R\\028Brj\\000\\000\\019^\\000\\000\\004\\206\\t\\166\\020X\\140\\146\\000\\000\\000\\000\\028\\190\\140\\234\\000\\000\\000\\000\\018\\244\\000\\000\\019TV&\\000\\000\\016\\162\\007\\206\\000b\\000\\000\\000\\000V&\\r@\\014\\020\\000\\000V&\\0148\\000\\244\\019\\128\\000\\000\\000\\000\\128\\254\\000\\000\\000\\000`\\020\\000\\000\\130\\142\\000\\000\\019\\130\\026R\\029:P\\012\\000\\000\\000\\000\\000\\000\\000\\000\\016\\026\\129\\152`\\020\\000\\000\\130\\142\\000\\000\\019\\136\\026R\\029:P\\012\\000\\000\\017$\\000\\000\\000\\000\\012H\\000\\000rj\\000\\000\\019\\164\\000\\000\\000\\000\\019\\006\\000\\000\\019\\026\\000\\000\\019@\\000\\000\\000\\000R\\214\\019^\\000\\000\\000\\000%\\182]\\188\\019\\250\\000\\000\\000\\000\\000\\000\\012T\\012,`\\\\\\020$\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\019\\190\\000\\000\\023\\228\\000\\000\\019\\218\\000\\000V&\\000\\000\\016f\\000\\000\\000\\000\\019\\224\\000\\000\\000\\000\\0008\\000\\000\\b\\170\\000\\000\\000\\000\\000\\000\\016v\\000\\000\\028\\254\\000\\000\\r\\218\\000\\000\\021\\178\\000\\000\\0040\\000\\000\\b\\022\\000\\000\\019\\226\\000\\000Y\\222\\022\\168\\000\\000\\000\\000\\r$\\0200\\000\\000\\000\\000\\020&\\014\\028H<\\005.\\130\\022\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000[b\\000\\000\\000\\000\\020\\214\\000\\000n\\004\\000\\000\\016\\254\\020\\254\\000\\000\\021\\004\\000\\000H\\240H\\240]R]R\\000\\000\\000\\000rj]R\\000\\000\\000\\000\\000\\000rj]R\\020\\130\\000\\000\\020\\164\\000\\000\"), (16, \"\\tQ\\tQ\\000\\006\\001\\002\\001\\190\\tQ\\002\\186\\002\\190\\tQ\\002\\234\\002\\138\\tQ\\003\\153\\tQ\\019j\\002\\246\\tQ\\024^\\tQ\\tQ\\tQ\\016\\226\\tQ\\tQ\\tQ\\001\\210\\004Y\\004Y\\004F\\002\\250\\tQ\\003r\\003v\\nz\\tQ\\001\\206\\tQ\\024b\\002\\254\\000\\238\\003\\150\\016\\230\\tQ\\tQ\\003\\202\\003\\206\\tQ\\003\\210\\003\\222\\003\\234\\003\\242\\007\\030\\007Z\\tQ\\tQ\\002\\178\\001\\206\\007:\\003\\230\\tQ\\tQ\\tQ\\bz\\b~\\b\\138\\b\\158\\001*\\005v\\tQ\\tQ\\tQ\\tQ\\tQ\\tQ\\tQ\\tQ\\tQ\\t\\018\\000\\238\\tQ\\015\\214\\tQ\\tQ\\003\\153\\t\\030\\t6\\t\\130\\005\\130\\005\\134\\tQ\\tQ\\tQ\\r\\250\\tQ\\tQ\\tQ\\tQ\\002r\\002\\162\\014*\\tQ\\006\\250\\tQ\\tQ\\0035\\tQ\\tQ\\tQ\\tQ\\tQ\\tQ\\005\\138\\b\\146\\tQ\\tQ\\tQ\\b\\170\\004r\\t\\150\\0035\\tQ\\tQ\\tQ\\tQ\\r)\\r)\\024f\\t\\202\\004\\154\\r)\\t\\214\\r)\\r)\\003\\157\\r)\\r)\\r)\\r)\\tF\\r)\\r)\\006\\165\\r)\\r)\\r)\\003\\145\\r)\\r)\\r)\\r)\\004Y\\r)\\0166\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\006\\165\\r)\\015\\222\\r)\\004\\226\\r)\\r)\\r)\\r)\\r)\\005\\237\\r)\\r)\\000\\238\\r)\\003\\238\\r)\\r)\\r)\\tJ\\tf\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\000\\238\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\000\\238\\r)\\r)\\003\\157\\r)\\r)\\012b\\003\\022\\003\\170\\004Y\\r)\\r)\\r)\\r)\\r)\\004Y\\r)\\r)\\r)\\r)\\r)\\006q\\r)\\r)\\006\\r\\r)\\r)\\003\\026\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\r)\\006q\\004Y\\r)\\r)\\r)\\r)\\001\\189\\001\\189\\001\\189\\001f\\003q\\001\\189\\006\\018\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001v\\001\\189\\001j\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\006\\226\\001\\189\\003J\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\b>\\001\\189\\001\\189\\001\\189\\006\\r\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\000\\238\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\bv\\001\\189\\001\\189\\019Z\\b\\030\\007f\\001r\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\015\\006\\b\\194\\001\\189\\005\\186\\001\\189\\001\\189\\b\\\"\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\001\\182\\001\\189\\001\\189\\001\\189\\001\\189\\001\\189\\n\\145\\n\\145\\019\\198\\007\\226\\rM\\n\\145\\003N\\n\\145\\n\\145\\004\\021\\n\\145\\n\\145\\n\\145\\n\\145\\001\\186\\n\\145\\n\\145\\rM\\n\\145\\n\\145\\n\\145\\000\\238\\n\\145\\n\\145\\n\\145\\n\\145\\019\\206\\n\\145\\006\\230\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\007\\t\\n\\145\\004Y\\n\\145\\004Y\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\bE\\n\\145\\n\\145\\000\\238\\n\\145\\001\\130\\n\\145\\n\\145\\n\\145\\007\\t\\004Y\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\004Y\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\000\\238\\n\\145\\n\\145\\004\\021\\n\\145\\n\\145\\004\\210\\bZ\\007f\\004Y\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\007!\\n\\145\\n\\145\\n\\145\\n\\145\\t\\174\\000\\238\\n\\014\\n\\145\\001\\146\\n\\145\\n\\145\\b^\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\007\\t\\n\\145\\n\\145\\n\\145\\n\\145\\n\\145\\003\\185\\003\\185\\002\\225\\007\\226\\b\\134\\003\\185\\002V\\003\\185\\003\\185\\016\\202\\003\\185\\003\\185\\003\\185\\003\\185\\001f\\003\\185\\003\\185\\003q\\003\\185\\003\\185\\003\\185\\000\\238\\003\\185\\003\\185\\003\\185\\003\\185\\002Z\\003\\185\\000\\n\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\b>\\003\\185\\007\\026\\003\\185\\007f\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\b\\233\\003\\185\\003\\185\\000\\238\\003\\185\\004\\214\\003\\185\\003\\185\\003\\185\\002\\225\\006^\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\015n\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\006b\\t\\166\\n\\006\\007\\154\\003\\185\\003\\185\\007\\226\\025\\158\\007f\\000\\238\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\001\\198\\003\\185\\003\\185\\003\\185\\003\\185\\t\\174\\016\\206\\n\\014\\003\\185\\000\\238\\003\\185\\003\\185\\025\\162\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\000\\238\\003\\185\\003\\185\\003\\185\\003\\185\\003\\185\\003\\169\\003\\169\\b\\229\\007\\226\\007:\\003\\169\\b\\233\\003\\169\\003\\169\\028O\\003\\169\\003\\169\\003\\169\\003\\169\\004Y\\003\\169\\003\\169\\006\\177\\003\\169\\003\\169\\003\\169\\000\\238\\003\\169\\003\\169\\003\\169\\003\\169\\r>\\003\\169\\003\\170\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\006\\177\\003\\169\\001\\234\\003\\169\\000\\238\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\015\\134\\003\\169\\003\\169\\001\\218\\003\\169\\t-\\003\\169\\003\\169\\003\\169\\000\\238\\004\\014\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\015\\142\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\004Y\\t\\166\\n\\006\\004\\018\\003\\169\\003\\169\\nF\\003\\\"\\b\\229\\002n\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\001\\222\\003\\169\\003\\169\\003\\169\\003\\169\\t\\174\\012\\237\\n\\014\\003\\169\\b\\130\\003\\169\\003\\169\\003&\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\012\\237\\003\\169\\003\\169\\003\\169\\003\\169\\003\\169\\t\\249\\t\\249\\004Y\\004Y\\011*\\t\\249\\006\\166\\t\\249\\t\\249\\t-\\t\\249\\t\\249\\t\\249\\t\\249\\018\\190\\t\\249\\t\\249\\004Y\\t\\249\\t\\249\\t\\249\\001\\206\\t\\249\\t\\249\\t\\249\\t\\249\\004Y\\t\\249\\006\\170\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\001f\\t\\249\\014n\\t\\249\\003q\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\002r\\t\\249\\t\\249\\001\\206\\t\\249\\012\\194\\t\\249\\t\\249\\t\\249\\023B\\000\\238\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\000\\238\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\004B\\t\\249\\t\\249\\023J\\t\\249\\t\\249\\014v\\002.\\007f\\004Y\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\002~\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\012\\241\\t\\249\\t\\249\\b=\\t\\249\\t\\249\\b*\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\t\\249\\012\\241\\004Y\\t\\249\\t\\249\\t\\249\\t\\249\\n\\t\\n\\t\\004\\242\\007\\226\\004^\\n\\t\\005R\\n\\t\\n\\t\\000\\238\\n\\t\\n\\t\\n\\t\\n\\t\\001\\206\\n\\t\\n\\t\\000\\238\\n\\t\\n\\t\\n\\t\\000\\238\\n\\t\\n\\t\\n\\t\\n\\t\\t\\025\\n\\t\\001\\238\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\005&\\n\\t\\t\\014\\n\\t\\002\\190\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\011\\138\\n\\t\\n\\t\\003\\174\\n\\t\\012\\218\\n\\t\\n\\t\\n\\t\\002\\214\\n\\026\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\000\\238\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\030\\n\\t\\n\\t\\003V\\n\\t\\n\\t\\003\\162\\002:\\007f\\t\\025\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\003\\178\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\006y\\n\\t\\n\\t\\004r\\n\\t\\n\\t\\b\\242\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\n\\t\\006y\\t\\025\\n\\t\\n\\t\\n\\t\\n\\t\\n\\001\\n\\001\\019\\154\\007\\226\\b>\\n\\001\\t\\021\\n\\001\\n\\001\\003Z\\n\\001\\n\\001\\n\\001\\n\\001\\001\\206\\n\\001\\n\\001\\000\\238\\n\\001\\n\\001\\n\\001\\000\\238\\n\\001\\n\\001\\n\\001\\n\\001\\001\\134\\n\\001\\014\\158\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\0056\\n\\001\\019\\162\\n\\001\\004V\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\005\\245\\n\\001\\n\\001\\002\\014\\n\\001\\012\\242\\n\\001\\n\\001\\n\\001\\002\\162\\012V\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\b\\230\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\007\\198\\n\\001\\n\\001\\012Z\\n\\001\\n\\001\\004b\\004Y\\007f\\026\\170\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\001\\222\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\006\\129\\n\\001\\n\\001\\004B\\n\\001\\n\\001\\016\\218\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\n\\001\\006\\129\\001\\222\\n\\001\\n\\001\\n\\001\\n\\001\\t\\237\\t\\237\\004Y\\007\\226\\007:\\t\\237\\004\\214\\t\\237\\t\\237\\000\\238\\t\\237\\t\\237\\t\\237\\t\\237\\000\\238\\t\\237\\t\\237\\014\\162\\t\\237\\t\\237\\t\\237\\000\\238\\t\\237\\t\\237\\t\\237\\t\\237\\001\\150\\t\\237\\007\\194\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t)\\t\\237\\011\\166\\t\\237\\004B\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\019\\002\\t\\237\\t\\237\\000\\238\\t\\237\\r\\n\\t\\237\\t\\237\\t\\237\\015:\\011\\150\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\019\\014\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\002\\150\\t\\237\\t\\237\\011\\202\\t\\237\\t\\237\\003>\\003B\\007f\\028\\031\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\004R\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\017z\\t\\237\\t\\237\\002\\150\\t\\237\\t\\237\\017\\022\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t\\237\\t)\\012F\\t\\237\\t\\237\\t\\237\\t\\237\\t\\245\\t\\245\\022\\182\\007\\226\\b2\\t\\245\\011\\158\\t\\245\\t\\245\\007:\\t\\245\\t\\245\\t\\245\\t\\245\\026n\\t\\245\\t\\245\\012J\\t\\245\\t\\245\\t\\245\\000\\238\\t\\245\\t\\245\\t\\245\\t\\245\\005F\\t\\245\\012\\138\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\005>\\t\\245\\022\\190\\t\\245\\015\\198\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\005\\237\\t\\245\\t\\245\\012\\142\\t\\245\\r\\030\\t\\245\\t\\245\\t\\245\\006\\242\\007\\n\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\0062\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\004\\237\\t\\245\\t\\245\\r\\194\\t\\245\\t\\245\\003>\\018\\182\\007f\\005J\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\007j\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\018\\202\\t\\245\\t\\245\\b\\130\\t\\245\\t\\245\\0172\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\t\\245\\012n\\004\\214\\t\\245\\t\\245\\t\\245\\t\\245\\t\\241\\t\\241\\007\\166\\007\\226\\012\\210\\t\\241\\004\\214\\t\\241\\t\\241\\015B\\t\\241\\t\\241\\t\\241\\t\\241\\012r\\t\\241\\t\\241\\012F\\t\\241\\t\\241\\t\\241\\000\\238\\t\\241\\t\\241\\t\\241\\t\\241\\012\\214\\t\\241\\012\\138\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\006v\\t\\241\\r\\026\\t\\241\\r\\198\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\004Y\\t\\241\\t\\241\\r^\\t\\241\\r2\\t\\241\\t\\241\\t\\241\\007\\018\\016\\154\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\004Y\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\004\\174\\t\\241\\t\\241\\b\\025\\t\\241\\t\\241\\022\\150\\004Y\\001\\002\\001\\190\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\004Y\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\202\\t\\241\\t\\241\\t\\214\\t\\241\\t\\241\\000\\238\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\t\\241\\012\\186\\000\\238\\t\\241\\t\\241\\t\\241\\t\\241\\t\\253\\t\\253\\005\\002\\003>\\003B\\t\\253\\n\\026\\t\\253\\t\\253\\005.\\t\\253\\t\\253\\t\\253\\t\\253\\012\\190\\t\\253\\t\\253\\007>\\t\\253\\t\\253\\t\\253\\007v\\t\\253\\t\\253\\t\\253\\t\\253\\r\\006\\t\\253\\011\\150\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\007~\\t\\253\\015\\030\\t\\253\\019\\166\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\014\\194\\t\\253\\t\\253\\019\\250\\t\\253\\rN\\t\\253\\t\\253\\t\\253\\002\\190\\007\\170\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\022\\222\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\007\\198\\t\\253\\t\\253\\t\\202\\t\\253\\t\\253\\t\\214\\019\\158\\007f\\005\\249\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\005\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\004Y\\t\\253\\t\\253\\015\\242\\t\\253\\t\\253\\027V\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\t\\253\\027\\186\\001\\222\\t\\253\\t\\253\\t\\253\\t\\253\\n\\r\\n\\r\\006\\030\\007\\226\\014\\198\\n\\r\\012n\\n\\r\\n\\r\\015\\\"\\n\\r\\n\\r\\n\\r\\n\\r\\004B\\n\\r\\n\\r\\012\\210\\n\\r\\n\\r\\n\\r\\000\\238\\n\\r\\n\\r\\n\\r\\n\\r\\rJ\\n\\r\\000\\238\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\012\\006\\n\\r\\r\\174\\n\\r\\007\\178\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\015J\\n\\r\\n\\r\\020\\018\\n\\r\\rb\\n\\r\\n\\r\\n\\r\\019\\210\\007\\218\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\027\\182\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\002\\190\\n\\r\\n\\r\\016\\002\\n\\r\\n\\r\\023\\214\\003\\133\\001\\002\\001\\190\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\011\\150\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\011\\150\\n\\r\\n\\r\\bI\\n\\r\\n\\r\\b\\253\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n\\r\\001\\002\\001\\190\\n\\r\\n\\r\\n\\r\\n\\r\\n\\005\\n\\005\\t\\194\\t\\242\\015N\\n\\005\\012\\186\\n\\005\\n\\005\\020\\026\\n\\005\\n\\005\\n\\005\\n\\005\\012\\154\\n\\005\\n\\005\\014\\178\\n\\005\\n\\005\\n\\005\\000\\238\\n\\005\\n\\005\\n\\005\\n\\005\\r\\162\\n\\005\\015V\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\012\\158\\n\\005\\014\\182\\n\\005\\016>\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\017\\254\\n\\005\\n\\005\\015Z\\n\\005\\rv\\n\\005\\n\\005\\n\\005\\022\\194\\012\\234\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\b\\253\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\003\\174\\n\\005\\n\\005\\012\\238\\n\\005\\n\\005\\0066\\001\\206\\b>\\026\\194\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\003\\174\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\000\\238\\n\\005\\n\\005\\005\\241\\n\\005\\n\\005\\t\\001\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\n\\005\\001\\002\\001\\190\\n\\005\\n\\005\\n\\005\\n\\005\\n}\\n}\\026:\\000\\238\\020Z\\n}\\028?\\n}\\n}\\018B\\n}\\n}\\n}\\n}\\012V\\n}\\n}\\016\\174\\n}\\n}\\n}\\000\\238\\n}\\n}\\n}\\n}\\002\\253\\n}\\006\\138\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\r.\\n}\\019b\\n}\\006\\246\\n}\\n}\\n}\\n}\\n}\\026\\198\\n}\\n}\\007\\006\\n}\\r\\130\\n}\\n}\\n}\\019\\202\\012\\154\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\t\\001\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\bM\\n}\\n}\\rr\\n}\\n}\\023N\\022\\186\\019\\138\\020n\\n}\\n}\\n}\\n}\\n}\\rU\\n}\\n}\\n}\\n}\\n}\\014\\138\\n}\\n}\\007F\\n}\\n}\\012\\234\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\n}\\014\\142\\tb\\n}\\n}\\n}\\n}\\003\\165\\003\\165\\000\\238\\r\\186\\bA\\003\\165\\016\\178\\003\\165\\003\\165\\000\\238\\003\\165\\003\\165\\003\\165\\003\\165\\014\\250\\003\\165\\003\\165\\tz\\003\\165\\003\\165\\003\\165\\024n\\003\\165\\003\\165\\003\\165\\003\\165\\022\\254\\003\\165\\t\\198\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\014\\254\\003\\165\\023\\030\\003\\165\\024r\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\b=\\003\\165\\003\\165\\023\\238\\003\\165\\t\\238\\003\\165\\003\\165\\003\\165\\020r\\015*\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\023F\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\024\\174\\t\\166\\n\\006\\015.\\003\\165\\003\\165\\t\\250\\001\\206\\024\\n\\ra\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\n\\n\\003\\165\\003\\165\\003\\165\\003\\165\\t\\174\\000\\238\\n\\014\\003\\165\\011B\\003\\165\\003\\165\\020\\006\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\020>\\003\\165\\003\\165\\003\\165\\003\\165\\003\\165\\001\\245\\001\\245\\027\\030\\007\\246\\023~\\001\\245\\011*\\002\\190\\001\\245\\020\\026\\002\\138\\001\\245\\t\\190\\001\\245\\023\\226\\002\\246\\001\\245\\007\\246\\001\\245\\001\\245\\001\\245\\011Z\\001\\245\\001\\245\\001\\245\\001\\210\\011\\130\\t\\246\\011\\178\\002\\250\\001\\245\\001\\245\\001\\245\\001\\245\\001\\245\\t\\254\\001\\245\\007\\246\\002\\254\\025\\142\\003\\150\\026\\166\\001\\245\\001\\245\\001\\245\\001\\245\\001\\245\\024\\178\\003\\222\\001\\190\\r\\210\\001\\245\\000\\238\\001\\245\\001\\245\\002\\178\\025\\194\\024B\\003\\230\\001\\245\\001\\245\\001\\245\\bz\\b~\\b\\138\\r\\218\\012\\166\\005v\\001\\245\\001\\245\\001\\245\\001\\245\\001\\245\\001\\245\\001\\245\\001\\245\\001\\245\\025\\182\\t\\166\\n\\006\\007\\246\\001\\245\\001\\245\\r\\238\\027\\255\\004q\\027J\\005\\130\\005\\134\\001\\245\\001\\245\\001\\245\\028/\\001\\245\\001\\245\\001\\245\\001\\245\\012\\174\\007\\246\\012\\250\\001\\245\\014\\030\\001\\245\\001\\245\\014J\\001\\245\\001\\245\\001\\245\\001\\245\\001\\245\\001\\245\\005\\138\\b\\146\\001\\245\\001\\245\\001\\245\\b\\170\\004r\\000\\238\\015\\162\\001\\245\\001\\245\\001\\245\\001\\245\\ne\\ne\\026\\182\\002\\226\\015\\202\\ne\\003\\254\\002\\190\\ne\\025\\146\\002\\138\\ne\\ne\\ne\\015\\230\\002\\246\\ne\\015\\234\\ne\\ne\\ne\\016\\018\\ne\\ne\\ne\\001\\210\\025\\198\\ne\\016&\\002\\250\\ne\\ne\\ne\\ne\\ne\\ne\\ne\\016F\\002\\254\\016V\\003\\150\\016j\\ne\\ne\\ne\\ne\\ne\\016\\150\\003\\222\\001\\190\\016\\238\\ne\\016\\246\\ne\\ne\\002\\178\\027N\\017\\246\\003\\230\\ne\\ne\\ne\\bz\\b~\\b\\138\\018\\n\\ne\\005v\\ne\\ne\\ne\\ne\\ne\\ne\\ne\\ne\\ne\\018\\014\\ne\\ne\\006\\134\\ne\\ne\\018\\210\\018\\234\\019r\\019v\\005\\130\\005\\134\\ne\\ne\\ne\\019\\174\\ne\\ne\\ne\\ne\\ne\\019\\178\\ne\\ne\\019\\218\\ne\\ne\\019\\222\\ne\\ne\\ne\\ne\\ne\\ne\\005\\138\\b\\146\\ne\\ne\\ne\\b\\170\\004r\\019\\246\\020\\162\\ne\\ne\\ne\\ne\\na\\na\\020\\166\\020\\202\\020\\206\\na\\020\\222\\002\\190\\na\\020\\238\\002\\138\\na\\na\\na\\020\\250\\002\\246\\na\\021.\\na\\na\\na\\0212\\na\\na\\na\\001\\210\\021\\130\\na\\021\\170\\002\\250\\na\\na\\na\\na\\na\\na\\na\\021\\174\\002\\254\\021\\190\\003\\150\\022\\014\\na\\na\\na\\na\\na\\022.\\003\\222\\001\\190\\022n\\na\\022\\146\\na\\na\\002\\178\\022\\162\\022\\202\\003\\230\\na\\na\\na\\bz\\b~\\b\\138\\022\\206\\na\\005v\\na\\na\\na\\na\\na\\na\\na\\na\\na\\022\\218\\na\\na\\022\\234\\na\\na\\023\\006\\023\\022\\023*\\023V\\005\\130\\005\\134\\na\\na\\na\\023Z\\na\\na\\na\\na\\na\\023f\\na\\na\\023v\\na\\na\\023\\138\\na\\na\\na\\na\\na\\na\\005\\138\\b\\146\\na\\na\\na\\b\\170\\004r\\024~\\024\\214\\na\\na\\na\\na\\0029\\0029\\024\\254\\025f\\025v\\0029\\025\\206\\002\\190\\0029\\025\\222\\002\\138\\0029\\t\\190\\0029\\025\\234\\002\\246\\0029\\026N\\0029\\0029\\0029\\026b\\0029\\0029\\0029\\001\\210\\002\\225\\t\\246\\026\\146\\002\\250\\0029\\0029\\0029\\0029\\0029\\t\\254\\0029\\026\\154\\002\\254\\026\\214\\003\\150\\004Y\\0029\\0029\\0029\\0029\\0029\\026\\254\\003\\222\\001\\190\\0276\\0029\\000\\n\\0029\\0029\\002\\178\\027f\\027r\\003\\230\\0029\\0029\\0029\\bz\\b~\\b\\138\\027z\\012\\166\\005v\\0029\\0029\\0029\\0029\\0029\\0029\\0029\\0029\\0029\\027\\131\\004\\197\\0029\\002\\225\\0029\\0029\\004Y\\006\\202\\002\\190\\004Y\\005\\130\\005\\134\\0029\\0029\\0029\\027\\147\\0029\\0029\\0029\\0029\\027\\166\\000\\238\\004Y\\0029\\004\\197\\0029\\0029\\004Y\\0029\\0029\\0029\\0029\\0029\\0029\\005\\138\\b\\146\\0029\\0029\\0029\\b\\170\\004r\\027\\194\\004Y\\0029\\0029\\0029\\0029\\004Y\\007f\\004Y\\003\\162\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\018j\\004Y\\000\\238\\004Y\\004Y\\027\\223\\004Y\\004Y\\004Y\\017&\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\027\\239\\004Y\\004Y\\028\\011\\028_\\004Y\\004Y\\000\\238\\004Y\\004Y\\004Y\\004Y\\004Y\\007\\226\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\000\\238\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\000\\238\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\b\\229\\004N\\004Y\\028{\\028\\134\\004Y\\004Y\\004Y\\000\\238\\004Y\\000\\n\\028\\187\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\004Y\\015\\150\\022\\134\\004Y\\004Y\\002\\225\\002\\225\\007\\238\\004Y\\004B\\007\\005\\028\\207\\004Y\\004Y\\028\\215\\007\\246\\017*\\022\\246\\002\\225\\000\\238\\004Y\\004Y\\004Y\\007\\250\\029\\019\\004Y\\004Y\\004Y\\004Y\\007\\005\\000\\169\\004Y\\000\\169\\007\\005\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\029\\027\\000\\169\\023\\170\\000\\169\\000\\169\\000\\000\\000\\169\\000\\169\\000\\000\\000\\000\\000\\169\\000\\169\\000\\000\\000\\169\\000\\169\\000\\169\\000\\169\\000\\000\\000\\169\\004R\\000\\169\\000\\169\\b\\229\\000\\000\\000\\169\\000\\169\\005\\165\\000\\169\\000\\169\\000\\169\\000\\238\\000\\169\\t\\025\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\000\\b\\234\\000\\169\\000\\169\\000\\000\\000\\000\\000\\169\\000\\169\\002\\014\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\002\\018\\007\\005\\000\\169\\015\\190\\tE\\000\\169\\002\\138\\000\\169\\001\\210\\000\\169\\005\\165\\002\\190\\000\\000\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\169\\000\\000\\000\\000\\000\\000\\000\\169\\003R\\018\\186\\tE\\005\\165\\000\\222\\000\\000\\007J\\001\\222\\000\\169\\000\\000\\002\\226\\000\\000\\014\\210\\002\\178\\000\\169\\000\\169\\000\\169\\000\\169\\000\\000\\015\\194\\000\\169\\000\\169\\000\\169\\000\\169\\0021\\0021\\004q\\000\\000\\003\\162\\0021\\000\\000\\002\\190\\0021\\015\\206\\002\\138\\0021\\001b\\0021\\000\\000\\002\\246\\0021\\007N\\0021\\0021\\0021\\000\\000\\0021\\0021\\0021\\001\\210\\001z\\000\\000\\001\\138\\002\\250\\0021\\0021\\0021\\0021\\0021\\005\\134\\0021\\000\\000\\002\\254\\000\\000\\003\\150\\b\\209\\0021\\0021\\0021\\0021\\0021\\004q\\003\\222\\b\\142\\000\\000\\0021\\000\\000\\0021\\0021\\002\\178\\000\\000\\006\\146\\003\\230\\0021\\0021\\0021\\bz\\b~\\b\\138\\t\\166\\n\\006\\005v\\0021\\0021\\0021\\0021\\0021\\0021\\0021\\0021\\0021\\006\\150\\t\\166\\n\\006\\b\\209\\0021\\0021\\000\\000\\t\\174\\000\\000\\n\\014\\005\\130\\005\\134\\0021\\0021\\0021\\000\\000\\0021\\0021\\0021\\0021\\t\\174\\000\\000\\n\\014\\0021\\b\\209\\0021\\0021\\000\\000\\0021\\0021\\0021\\0021\\0021\\0021\\005\\138\\b\\146\\0021\\0021\\0021\\b\\170\\004r\\000\\238\\002\\225\\0021\\0021\\0021\\0021\\002E\\002E\\002\\225\\002\\225\\000\\000\\002E\\000\\000\\000\\000\\002E\\000\\000\\b\\209\\002E\\000\\000\\002E\\004\\254\\000\\000\\002E\\b\\209\\002E\\002E\\002E\\000\\n\\002E\\002E\\002E\\000\\000\\028k\\000\\000\\000\\000\\000\\n\\002E\\002E\\002E\\002E\\002E\\000\\000\\002E\\002\\225\\006F\\004\\193\\000\\000\\005\\234\\002E\\002E\\002E\\002E\\002E\\000\\000\\006f\\002\\225\\000\\000\\002E\\006r\\002E\\002E\\000\\000\\000\\000\\002\\225\\006\\198\\002E\\002E\\002E\\004\\193\\000\\000\\006\\241\\tA\\000\\000\\000\\000\\002E\\002E\\002E\\002E\\002E\\002E\\002E\\002E\\002E\\000\\000\\t\\166\\n\\006\\000\\000\\002E\\002E\\006\\206\\014\\234\\000\\000\\002\\190\\006\\241\\tA\\002E\\002E\\002E\\000\\000\\002E\\002E\\002E\\002E\\t\\174\\002\\190\\n\\014\\002E\\002\\138\\002E\\002E\\001\\210\\002E\\002E\\002E\\002E\\002E\\002E\\b\\205\\000\\000\\002E\\002E\\002E\\000\\000\\022v\\000\\000\\000\\000\\002E\\002E\\002E\\002E\\002A\\002A\\000\\000\\023\\178\\003\\162\\002A\\023\\182\\003\\174\\002A\\000\\000\\002\\178\\002A\\000\\000\\002A\\000\\000\\0186\\002A\\023\\230\\002A\\002A\\002A\\t\\178\\002A\\002A\\002A\\012f\\b\\205\\000\\000\\000\\000\\015\\206\\002A\\002A\\002A\\002A\\002A\\r\\166\\002A\\r\\178\\000\\000\\012\\130\\023\\246\\012\\146\\002A\\002A\\002A\\002A\\002A\\b\\205\\b\\198\\001\\190\\001*\\002A\\000\\000\\002A\\002A\\005\\134\\002\\225\\002\\225\\014\\146\\002A\\002A\\002A\\014\\166\\014\\186\\014\\202\\000\\000\\000\\000\\000\\000\\002A\\002A\\002A\\002A\\002A\\002A\\002A\\002A\\002A\\000\\000\\t\\166\\n\\006\\b\\205\\002A\\002A\\000\\n\\004\\254\\000\\000\\001\\206\\b\\205\\000\\000\\002A\\002A\\002A\\000\\000\\002A\\002A\\002A\\002A\\t\\174\\000\\000\\n\\014\\002A\\000\\000\\002A\\002A\\001\\210\\002A\\002A\\002A\\002A\\002A\\002A\\002\\225\\000\\000\\002A\\002A\\002A\\000\\000\\019z\\000\\000\\000\\000\\002A\\002A\\002A\\002A\\0025\\0025\\000\\000\\000\\000\\002\\162\\0025\\019\\242\\003\\174\\0025\\000\\000\\002\\178\\0025\\000\\000\\0025\\000\\000\\000\\000\\0025\\020\\n\\0025\\0025\\0025\\012\\178\\0025\\0025\\0025\\002\\225\\002\\225\\017R\\000\\000\\000\\000\\0025\\0025\\0025\\0025\\0025\\012\\202\\0025\\012\\226\\000\\000\\000\\000\\002\\225\\rB\\0025\\0025\\0025\\0025\\0025\\000\\000\\b\\198\\015\\n\\000\\000\\0025\\000\\n\\0025\\0025\\rV\\000\\000\\rj\\014\\146\\0025\\0025\\0025\\014\\166\\014\\186\\014\\202\\000\\000\\000\\000\\000\\000\\0025\\0025\\0025\\0025\\0025\\0025\\0025\\0025\\0025\\000\\000\\t\\166\\n\\006\\002\\225\\0025\\0025\\000\\000\\000\\000\\000\\000\\000\\000\\000\\238\\000\\000\\0025\\0025\\0025\\000\\000\\0025\\0025\\0025\\0025\\t\\174\\000\\000\\n\\014\\0025\\000\\000\\0025\\0025\\000\\000\\0025\\0025\\0025\\0025\\0025\\0025\\000\\000\\000\\000\\0025\\0025\\0025\\000\\000\\t\\146\\000\\000\\000\\000\\0025\\0025\\0025\\0025\\002=\\002=\\000\\000\\000\\000\\000\\000\\002=\\012\\177\\006F\\002=\\000\\000\\005\\234\\002=\\000\\000\\002=\\000\\000\\000\\000\\002=\\006f\\002=\\002=\\002=\\006r\\002=\\002=\\002=\\012\\177\\012\\177\\000\\000\\000\\000\\012\\177\\002=\\002=\\002=\\002=\\002=\\000\\000\\002=\\b=\\000\\000\\000\\000\\b=\\000\\000\\002=\\002=\\002=\\002=\\002=\\000\\000\\000\\000\\000\\000\\000\\000\\002=\\000\\000\\002=\\002=\\000\\000\\000\\000\\000\\000\\022\\254\\002=\\002=\\002=\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\238\\002=\\002=\\002=\\002=\\002=\\002=\\002=\\002=\\002=\\000\\000\\b=\\002=\\000\\000\\002=\\002=\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002=\\002=\\002=\\b=\\002=\\002=\\002=\\002=\\012\\177\\000\\000\\005\\021\\002=\\000\\000\\002=\\002=\\002\\225\\n&\\002=\\002=\\002=\\002=\\002=\\005\\021\\t\\226\\002=\\002=\\002=\\000\\000\\000\\000\\b=\\000\\000\\002=\\002=\\002=\\002=\\tM\\tM\\000\\000\\000\\000\\000\\000\\tM\\000\\000\\000\\000\\tM\\000\\n\\000\\000\\tM\\000\\000\\tM\\000\\000\\000\\000\\nR\\005\\021\\tM\\nv\\tM\\b=\\tM\\tM\\tM\\002\\225\\002\\225\\018\\146\\000\\000\\017\\194\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\tM\\002\\225\\002\\225\\000\\000\\002\\225\\000\\000\\tM\\tM\\n\\186\\n\\194\\tM\\005\\021\\b\\029\\000\\000\\005\\021\\tM\\000\\n\\n\\202\\tM\\000\\000\\000\\000\\000\\000\\000\\000\\tM\\tM\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\246\\tM\\tM\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\tM\\tM\\002\\174\\012\\245\\tM\\002\\225\\tM\\n\\242\\000\\000\\003\\018\\000\\000\\000\\000\\000\\238\\000\\000\\tM\\tM\\n\\250\\000\\000\\tM\\tM\\tM\\tM\\003\\030\\012\\245\\000\\000\\tM\\000\\000\\tM\\tM\\002J\\011\\026\\tM\\011\\\"\\n\\226\\tM\\tM\\000\\000\\000\\000\\tM\\011\\002\\tM\\000\\000\\002N\\000\\000\\005v\\tM\\tM\\011\\n\\011\\018\\002q\\002q\\000\\000\\000\\000\\000\\000\\002q\\012\\185\\006F\\002q\\000\\000\\005\\234\\002q\\000\\000\\002q\\000\\000\\005\\130\\002q\\006f\\002q\\002q\\002q\\006r\\002q\\002q\\002q\\012\\185\\012\\185\\000\\000\\000\\000\\012\\185\\002q\\002q\\002q\\002q\\002q\\000\\000\\002q\\015\\190\\000\\000\\005\\138\\002\\138\\000\\000\\002q\\002q\\002q\\002q\\002q\\000\\000\\000\\000\\000\\000\\000\\000\\002q\\000\\000\\002q\\002q\\000\\000\\000\\000\\000\\000\\000\\000\\002q\\002q\\002q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\238\\002q\\002q\\nZ\\002q\\002q\\002q\\002q\\002q\\002q\\000\\000\\015\\194\\002q\\000\\000\\002q\\002q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002q\\002q\\002q\\015\\206\\002q\\002q\\002q\\002q\\012\\185\\000\\000\\001\\206\\002q\\000\\000\\002q\\002q\\000\\000\\002q\\002q\\002q\\002q\\002q\\002q\\026\\130\\000\\000\\002q\\002q\\002q\\000\\000\\000\\000\\005\\134\\000\\000\\002q\\002q\\002q\\002q\\002Y\\002Y\\000\\000\\000\\000\\000\\000\\002Y\\000\\000\\002\\190\\002Y\\000\\000\\000\\000\\002Y\\000\\000\\002Y\\003b\\000\\000\\002Y\\002\\162\\002Y\\002Y\\002Y\\025\\242\\002Y\\002Y\\002Y\\001\\210\\000\\000\\000\\000\\000\\000\\000\\000\\002Y\\002Y\\002Y\\002Y\\002Y\\000\\000\\002Y\\015\\190\\000\\000\\000\\000\\002\\138\\000\\000\\002Y\\002Y\\002Y\\002Y\\002Y\\004\\154\\003\\138\\000\\000\\004\\241\\002Y\\000\\000\\002Y\\002Y\\002\\178\\000\\000\\000\\000\\000\\000\\002Y\\002Y\\002Y\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002Y\\002Y\\nZ\\002Y\\002Y\\002Y\\002Y\\002Y\\002Y\\000\\000\\015\\194\\002Y\\000\\000\\002Y\\002Y\\0072\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002Y\\002Y\\002Y\\015\\206\\002Y\\002Y\\002Y\\002Y\\000\\000\\000\\000\\000\\000\\002Y\\000\\000\\002Y\\002Y\\000\\000\\002Y\\002Y\\002Y\\002Y\\002Y\\002Y\\012\\181\\000\\000\\002Y\\002Y\\002Y\\000\\000\\000\\000\\005\\134\\000\\000\\002Y\\002Y\\002Y\\002Y\\002e\\002e\\000\\000\\000\\000\\000\\000\\002e\\012\\181\\012\\181\\002e\\000\\000\\012\\181\\002e\\000\\000\\002e\\000\\000\\000\\000\\nR\\000\\000\\002e\\002e\\002e\\021\\218\\002e\\002e\\002e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002e\\002e\\002e\\n\\146\\002e\\000\\000\\002e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002e\\002e\\002e\\002e\\002e\\000\\000\\000\\238\\000\\000\\000\\000\\002e\\000\\000\\002e\\002e\\000\\000\\000\\000\\000\\000\\000\\000\\002e\\002e\\002e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002e\\002e\\nZ\\n\\154\\002e\\002e\\002e\\002e\\002e\\000\\000\\012\\181\\002e\\000\\000\\002e\\002e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\238\\b1\\002e\\002e\\002e\\b1\\002e\\002e\\002e\\002e\\000\\000\\000\\000\\000\\000\\002e\\000\\000\\002e\\002e\\000\\000\\002e\\002e\\002e\\002e\\002e\\002e\\000\\000\\000\\000\\002e\\002e\\002e\\000\\000\\011\\214\\000\\000\\000\\000\\002e\\002e\\002e\\002e\\002u\\002u\\000\\000\\000\\000\\000\\000\\002u\\b1\\011\\222\\002u\\000\\000\\011\\234\\002u\\000\\000\\002u\\000\\000\\000\\000\\002u\\011\\246\\002u\\002u\\002u\\012\\002\\002u\\002u\\002u\\000\\000\\000\\000\\b1\\000\\000\\000\\000\\002u\\002u\\002u\\002u\\002u\\000\\000\\002u\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002u\\002u\\002u\\002u\\002u\\000\\000\\000\\000\\000\\000\\000\\000\\002u\\000\\000\\002u\\002u\\000\\000\\000\\000\\000\\000\\000\\000\\002u\\002u\\002u\\000\\000\\000\\000\\004\\254\\000\\000\\000\\000\\000\\000\\002u\\002u\\nZ\\002u\\002u\\002u\\002u\\002u\\002u\\000\\000\\bJ\\002u\\000\\000\\002u\\002u\\000\\000\\000\\000\\000\\000\\000\\000\\000\\238\\b-\\002u\\002u\\002u\\b-\\002u\\002u\\002u\\002u\\000\\000\\bN\\000\\000\\002u\\000\\000\\002u\\002u\\000\\000\\002u\\002u\\002u\\002u\\002u\\002u\\000\\000\\000\\000\\002u\\002u\\002u\\000\\000\\007\\201\\000\\000\\000\\000\\002u\\002u\\002u\\002u\\002U\\002U\\b>\\000\\000\\000\\000\\002U\\b-\\007\\201\\002U\\000\\000\\005\\234\\002U\\000\\000\\002U\\000\\000\\000\\238\\002U\\007\\201\\002U\\002U\\002U\\007\\201\\002U\\002U\\002U\\000\\000\\000\\000\\b-\\000\\000\\000\\000\\002U\\002U\\002U\\002U\\002U\\000\\000\\002U\\000\\000\\000\\000\\007\\025\\000\\000\\000\\000\\002U\\002U\\002U\\002U\\002U\\000\\000\\000\\000\\000\\000\\000\\000\\002U\\000\\000\\002U\\002U\\000\\000\\000\\000\\000\\000\\007\\025\\002U\\002U\\002U\\007\\025\\bR\\004\\254\\000\\000\\000\\000\\000\\000\\002U\\002U\\nZ\\002U\\002U\\002U\\002U\\002U\\002U\\000\\000\\000\\000\\002U\\000\\000\\002U\\002U\\000\\000\\000\\000\\000\\000\\000\\000\\007\\229\\000\\000\\002U\\002U\\002U\\000\\000\\002U\\002U\\002U\\002U\\000\\000\\000\\000\\000\\000\\002U\\000\\000\\002U\\002U\\000\\000\\002U\\002U\\002U\\002U\\002U\\002U\\000\\000\\000\\000\\002U\\002U\\002U\\000\\000\\007\\229\\000\\000\\000\\000\\002U\\002U\\002U\\002U\\002a\\002a\\000\\000\\000\\000\\000\\000\\002a\\005f\\007\\229\\002a\\000\\000\\005\\234\\002a\\000\\000\\002a\\000\\000\\000\\000\\nR\\007\\229\\002a\\002a\\002a\\007\\229\\002a\\002a\\002a\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002a\\002a\\002a\\n\\146\\002a\\000\\000\\002a\\000\\000\\000\\000\\007\\t\\000\\000\\000\\000\\002a\\002a\\002a\\002a\\002a\\000\\000\\000\\000\\000\\000\\000\\000\\002a\\000\\000\\002a\\002a\\000\\000\\000\\000\\000\\000\\007\\t\\002a\\002a\\002a\\007\\t\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002a\\002a\\nZ\\n\\154\\002a\\002a\\002a\\002a\\002a\\000\\000\\000\\000\\002a\\000\\000\\002a\\002a\\000\\000\\000\\000\\000\\000\\000\\000\\000\\238\\000\\000\\002a\\002a\\002a\\000\\000\\002a\\002a\\002a\\002a\\000\\000\\000\\000\\000\\000\\002a\\000\\000\\002a\\002a\\000\\000\\002a\\002a\\002a\\002a\\002a\\002a\\000\\000\\000\\000\\002a\\002a\\002a\\000\\000\\b\\001\\000\\000\\000\\000\\002a\\002a\\002a\\002a\\002]\\002]\\000\\000\\000\\000\\000\\000\\002]\\b\\134\\006F\\002]\\000\\000\\005\\234\\002]\\000\\000\\002]\\000\\000\\000\\000\\nR\\b\\001\\002]\\002]\\002]\\b\\001\\002]\\002]\\002]\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002]\\002]\\002]\\n\\146\\002]\\000\\000\\002]\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002]\\002]\\002]\\002]\\002]\\000\\000\\000\\000\\000\\000\\000\\000\\002]\\000\\000\\002]\\002]\\000\\000\\000\\000\\000\\000\\000\\000\\002]\\002]\\002]\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002]\\002]\\nZ\\n\\154\\002]\\002]\\002]\\002]\\002]\\000\\000\\000\\000\\002]\\000\\000\\002]\\002]\\000\\000\\000\\000\\000\\000\\000\\000\\007\\249\\000\\000\\002]\\002]\\002]\\000\\000\\002]\\002]\\002]\\002]\\000\\000\\000\\000\\000\\000\\002]\\000\\000\\002]\\002]\\000\\000\\002]\\002]\\002]\\002]\\002]\\002]\\000\\000\\000\\000\\002]\\002]\\002]\\000\\000\\007\\249\\000\\000\\000\\000\\002]\\002]\\002]\\002]\\002\\133\\002\\133\\000\\000\\000\\000\\000\\000\\002\\133\\000\\000\\012\\026\\002\\133\\000\\000\\007\\249\\002\\133\\000\\000\\002\\133\\000\\000\\000\\000\\nR\\007\\249\\002\\133\\002\\133\\002\\133\\007\\249\\002\\133\\002\\133\\002\\133\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\133\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\133\\002\\133\\n\\186\\n\\194\\002\\133\\000\\000\\000\\000\\000\\000\\000\\000\\002\\133\\000\\000\\n\\202\\002\\133\\000\\000\\000\\000\\000\\000\\000\\000\\002\\133\\002\\133\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\133\\002\\133\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\133\\002\\133\\000\\000\\000\\000\\002\\133\\000\\000\\002\\133\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\238\\000\\000\\002\\133\\002\\133\\n\\250\\000\\000\\002\\133\\002\\133\\002\\133\\002\\133\\000\\000\\000\\000\\000\\000\\002\\133\\000\\000\\002\\133\\002\\133\\000\\000\\002\\133\\002\\133\\002\\133\\n\\226\\002\\133\\002\\133\\000\\000\\000\\000\\002\\133\\011\\002\\002\\133\\000\\000\\007\\197\\000\\000\\000\\000\\002\\133\\002\\133\\011\\n\\011\\018\\002m\\002m\\000\\000\\000\\000\\000\\000\\002m\\000\\000\\007\\197\\002m\\000\\000\\005\\234\\002m\\000\\000\\002m\\000\\000\\000\\000\\nR\\007\\197\\002m\\002m\\002m\\007\\197\\002m\\002m\\002m\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002m\\002m\\002m\\n\\146\\002m\\000\\000\\002m\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002m\\002m\\002m\\002m\\002m\\000\\000\\000\\000\\000\\000\\000\\000\\002m\\000\\000\\002m\\002m\\000\\000\\000\\000\\000\\000\\000\\000\\002m\\002m\\002m\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002m\\002m\\nZ\\n\\154\\002m\\002m\\002m\\002m\\002m\\000\\000\\000\\000\\002m\\000\\000\\002m\\002m\\000\\000\\000\\000\\000\\000\\000\\000\\000\\238\\000\\000\\002m\\002m\\002m\\000\\000\\002m\\002m\\002m\\002m\\000\\000\\000\\000\\000\\000\\002m\\000\\000\\002m\\002m\\000\\000\\002m\\002m\\002m\\002m\\002m\\002m\\000\\000\\000\\000\\002m\\002m\\002m\\000\\000\\014b\\000\\000\\000\\000\\002m\\002m\\002m\\002m\\002i\\002i\\000\\000\\000\\000\\000\\000\\002i\\000\\000\\011\\222\\002i\\000\\000\\011\\234\\002i\\000\\000\\002i\\000\\000\\000\\000\\nR\\011\\246\\002i\\002i\\002i\\012\\002\\002i\\002i\\002i\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002i\\002i\\002i\\n\\146\\002i\\000\\000\\002i\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002i\\002i\\002i\\002i\\002i\\000\\000\\000\\000\\000\\000\\000\\000\\002i\\000\\000\\002i\\002i\\000\\000\\000\\000\\000\\000\\000\\000\\002i\\002i\\002i\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002i\\002i\\nZ\\n\\154\\002i\\002i\\002i\\002i\\002i\\000\\000\\000\\000\\002i\\000\\000\\002i\\002i\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002i\\002i\\002i\\000\\000\\002i\\002i\\002i\\002i\\000\\000\\000\\000\\000\\000\\002i\\000\\000\\002i\\002i\\000\\000\\002i\\002i\\002i\\002i\\002i\\002i\\000\\000\\000\\000\\002i\\002i\\002i\\000\\000\\000\\000\\000\\000\\000\\000\\002i\\002i\\002i\\002i\\002}\\002}\\000\\000\\000\\000\\000\\000\\002}\\000\\000\\002\\014\\002}\\000\\000\\002\\138\\002}\\000\\000\\002}\\000\\000\\000\\000\\nR\\000\\000\\002}\\002}\\002}\\000\\000\\002}\\002}\\002}\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\002}\\000\\000\\002}\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002}\\002}\\n\\186\\n\\194\\002}\\000\\000\\027\\158\\001\\222\\000\\000\\002}\\000\\000\\002}\\002}\\000\\000\\000\\000\\000\\000\\000\\000\\002}\\002}\\000\\238\\015\\206\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002}\\002}\\nZ\\n\\154\\n\\210\\n\\218\\002}\\002}\\002}\\000\\000\\000\\000\\002}\\000\\000\\002}\\002}\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\134\\002}\\002}\\002}\\000\\000\\002}\\002}\\002}\\002}\\000\\000\\000\\000\\000\\000\\002}\\000\\000\\002}\\002}\\000\\000\\002}\\002}\\002}\\n\\226\\002}\\002}\\000\\000\\000\\000\\002}\\002}\\002}\\000\\000\\000\\000\\000\\000\\000\\000\\002}\\002}\\002}\\002}\\002Q\\002Q\\000\\000\\000\\000\\000\\000\\002Q\\000\\000\\003\\174\\002Q\\000\\000\\000\\000\\002Q\\000\\000\\002Q\\000\\000\\000\\000\\nR\\000\\000\\002Q\\002Q\\002Q\\000\\000\\002Q\\002Q\\002Q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002Q\\002Q\\002Q\\n\\146\\002Q\\000\\000\\002Q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002Q\\002Q\\002Q\\002Q\\002Q\\000\\000\\005\\190\\000\\000\\000\\000\\002Q\\000\\000\\002Q\\002Q\\000\\000\\000\\000\\000\\000\\003\\246\\002Q\\002Q\\002Q\\006\\154\\000\\000\\004\\002\\000\\000\\000\\000\\000\\000\\002Q\\002Q\\nZ\\n\\154\\002Q\\002Q\\002Q\\002Q\\002Q\\000\\000\\000\\000\\002Q\\000\\000\\002Q\\002Q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002Q\\002Q\\002Q\\000\\000\\002Q\\002Q\\002Q\\002Q\\000\\000\\000\\000\\000\\000\\002Q\\000\\000\\002Q\\002Q\\000\\000\\002Q\\002Q\\002Q\\002Q\\002Q\\002Q\\000\\000\\000\\000\\002Q\\002Q\\002Q\\000\\000\\000\\000\\000\\000\\000\\000\\002Q\\002Q\\002Q\\002Q\\002M\\002M\\000\\000\\000\\000\\000\\000\\002M\\000\\000\\002\\190\\002M\\000\\000\\000\\000\\002M\\000\\000\\002M\\000\\000\\000\\000\\nR\\000\\000\\002M\\002M\\002M\\000\\000\\002M\\002M\\002M\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\002M\\000\\000\\002M\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002M\\002M\\n\\186\\n\\194\\002M\\000\\000\\n\\018\\003\\162\\000\\000\\002M\\000\\000\\002M\\002M\\000\\000\\000\\000\\000\\000\\000\\000\\002M\\002M\\000\\238\\012>\\000\\000\\012N\\000\\000\\000\\000\\000\\000\\002M\\002M\\nZ\\n\\154\\n\\210\\n\\218\\002M\\002M\\002M\\000\\000\\000\\000\\002M\\000\\000\\002M\\002M\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002M\\002M\\002M\\000\\000\\002M\\002M\\002M\\002M\\000\\000\\000\\000\\000\\000\\002M\\000\\000\\002M\\002M\\000\\000\\002M\\002M\\002M\\n\\226\\002M\\002M\\000\\000\\000\\000\\002M\\002M\\002M\\000\\000\\000\\000\\000\\000\\000\\000\\002M\\002M\\002M\\002M\\002\\169\\002\\169\\000\\000\\000\\000\\000\\000\\002\\169\\000\\000\\002\\190\\002\\169\\000\\000\\000\\000\\002\\169\\000\\000\\002\\169\\000\\000\\000\\000\\nR\\000\\000\\002\\169\\002\\169\\002\\169\\000\\000\\002\\169\\002\\169\\002\\169\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\002\\169\\000\\000\\002\\169\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\169\\002\\169\\n\\186\\n\\194\\002\\169\\000\\000\\012\\254\\003\\162\\000\\000\\002\\169\\000\\000\\002\\169\\002\\169\\000\\000\\000\\000\\000\\000\\000\\000\\002\\169\\002\\169\\002\\169\\r\\018\\000\\000\\r&\\000\\000\\000\\000\\000\\000\\002\\169\\002\\169\\nZ\\n\\154\\n\\210\\002\\169\\002\\169\\002\\169\\002\\169\\000\\000\\000\\000\\002\\169\\000\\000\\002\\169\\002\\169\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\169\\002\\169\\002\\169\\000\\000\\002\\169\\002\\169\\002\\169\\002\\169\\000\\000\\000\\000\\000\\000\\002\\169\\000\\000\\002\\169\\002\\169\\000\\000\\002\\169\\002\\169\\002\\169\\n\\226\\002\\169\\002\\169\\000\\000\\000\\000\\002\\169\\002\\169\\002\\169\\000\\000\\000\\000\\000\\000\\000\\000\\002\\169\\002\\169\\002\\169\\002\\169\\002I\\002I\\000\\000\\000\\000\\000\\000\\002I\\000\\000\\000\\000\\002I\\000\\000\\000\\000\\002I\\000\\000\\002I\\000\\000\\000\\000\\nR\\000\\000\\002I\\002I\\002I\\000\\000\\002I\\002I\\002I\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\002I\\000\\000\\002I\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002I\\002I\\n\\186\\n\\194\\002I\\000\\000\\000\\000\\000\\000\\000\\000\\002I\\000\\000\\002I\\002I\\000\\000\\000\\000\\000\\000\\000\\000\\002I\\002I\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002I\\002I\\nZ\\n\\154\\n\\210\\n\\218\\002I\\002I\\002I\\000\\000\\000\\000\\002I\\000\\000\\002I\\002I\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002I\\002I\\002I\\000\\000\\002I\\002I\\002I\\002I\\000\\000\\000\\000\\000\\000\\002I\\000\\000\\002I\\002I\\000\\000\\002I\\002I\\002I\\n\\226\\002I\\002I\\000\\000\\000\\000\\002I\\002I\\002I\\000\\000\\000\\000\\000\\000\\000\\000\\002I\\002I\\002I\\002I\\002\\129\\002\\129\\000\\000\\000\\000\\000\\000\\002\\129\\000\\000\\000\\000\\002\\129\\000\\000\\000\\000\\002\\129\\000\\000\\002\\129\\000\\000\\000\\000\\nR\\000\\000\\002\\129\\002\\129\\002\\129\\000\\000\\002\\129\\002\\129\\002\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\002\\129\\000\\000\\002\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\129\\002\\129\\n\\186\\n\\194\\002\\129\\000\\000\\000\\000\\000\\000\\000\\000\\002\\129\\000\\000\\002\\129\\002\\129\\000\\000\\000\\000\\000\\000\\000\\000\\002\\129\\002\\129\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\129\\002\\129\\nZ\\n\\154\\n\\210\\n\\218\\002\\129\\002\\129\\002\\129\\000\\000\\000\\000\\002\\129\\000\\000\\002\\129\\002\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\129\\002\\129\\002\\129\\000\\000\\002\\129\\002\\129\\002\\129\\002\\129\\000\\000\\000\\000\\000\\000\\002\\129\\000\\000\\002\\129\\002\\129\\000\\000\\002\\129\\002\\129\\002\\129\\n\\226\\002\\129\\002\\129\\000\\000\\000\\000\\002\\129\\002\\129\\002\\129\\000\\000\\000\\000\\000\\000\\000\\000\\002\\129\\002\\129\\002\\129\\002\\129\\002y\\002y\\000\\000\\000\\000\\000\\000\\002y\\000\\000\\000\\000\\002y\\000\\000\\000\\000\\002y\\000\\000\\002y\\000\\000\\000\\000\\nR\\000\\000\\002y\\002y\\002y\\000\\000\\002y\\002y\\002y\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\002y\\000\\000\\002y\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002y\\002y\\n\\186\\n\\194\\002y\\000\\000\\000\\000\\000\\000\\000\\000\\002y\\000\\000\\002y\\002y\\000\\000\\000\\000\\000\\000\\000\\000\\002y\\002y\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002y\\002y\\nZ\\n\\154\\n\\210\\n\\218\\002y\\002y\\002y\\000\\000\\000\\000\\002y\\000\\000\\002y\\002y\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002y\\002y\\002y\\000\\000\\002y\\002y\\002y\\002y\\000\\000\\000\\000\\000\\000\\002y\\000\\000\\002y\\002y\\000\\000\\002y\\002y\\002y\\n\\226\\002y\\002y\\000\\000\\000\\000\\002y\\002y\\002y\\000\\000\\000\\000\\000\\000\\000\\000\\002y\\002y\\002y\\002y\\002\\137\\002\\137\\000\\000\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\002\\137\\000\\000\\002\\137\\000\\000\\000\\000\\nR\\000\\000\\002\\137\\002\\137\\002\\137\\000\\000\\002\\137\\002\\137\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\002\\137\\n\\186\\n\\194\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\000\\000\\n\\202\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\002\\137\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\002\\137\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\137\\002\\137\\000\\000\\000\\000\\002\\137\\000\\000\\002\\137\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\002\\137\\n\\250\\000\\000\\002\\137\\002\\137\\002\\137\\002\\137\\000\\000\\000\\000\\000\\000\\002\\137\\000\\000\\002\\137\\002\\137\\000\\000\\002\\137\\002\\137\\002\\137\\n\\226\\002\\137\\002\\137\\000\\000\\000\\000\\002\\137\\011\\002\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\002\\137\\011\\n\\011\\018\\002\\141\\002\\141\\000\\000\\000\\000\\000\\000\\002\\141\\000\\000\\000\\000\\002\\141\\000\\000\\000\\000\\002\\141\\000\\000\\002\\141\\000\\000\\000\\000\\nR\\000\\000\\002\\141\\002\\141\\002\\141\\000\\000\\002\\141\\002\\141\\002\\141\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\002\\141\\000\\000\\002\\141\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\141\\002\\141\\n\\186\\n\\194\\002\\141\\000\\000\\000\\000\\000\\000\\000\\000\\002\\141\\000\\000\\n\\202\\002\\141\\000\\000\\000\\000\\000\\000\\000\\000\\002\\141\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\141\\002\\141\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\141\\002\\141\\000\\000\\000\\000\\002\\141\\000\\000\\002\\141\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\141\\002\\141\\n\\250\\000\\000\\002\\141\\002\\141\\002\\141\\002\\141\\000\\000\\000\\000\\000\\000\\002\\141\\000\\000\\002\\141\\002\\141\\000\\000\\002\\141\\002\\141\\002\\141\\n\\226\\002\\141\\002\\141\\000\\000\\000\\000\\002\\141\\002\\141\\002\\141\\000\\000\\000\\000\\000\\000\\000\\000\\002\\141\\002\\141\\011\\n\\011\\018\\002\\145\\002\\145\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\002\\145\\000\\000\\002\\145\\000\\000\\000\\000\\nR\\000\\000\\002\\145\\002\\145\\002\\145\\000\\000\\002\\145\\002\\145\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\002\\145\\000\\000\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\002\\145\\n\\186\\n\\194\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\n\\202\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\002\\145\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\002\\145\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\145\\002\\145\\000\\000\\000\\000\\002\\145\\000\\000\\002\\145\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\002\\145\\n\\250\\000\\000\\002\\145\\002\\145\\002\\145\\002\\145\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\002\\145\\002\\145\\000\\000\\002\\145\\002\\145\\002\\145\\n\\226\\002\\145\\002\\145\\000\\000\\000\\000\\002\\145\\002\\145\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\002\\145\\011\\n\\011\\018\\t\\t\\t\\t\\000\\000\\000\\000\\000\\000\\t\\t\\000\\000\\000\\000\\t\\t\\000\\000\\000\\000\\t\\t\\000\\000\\t\\t\\000\\000\\000\\000\\nR\\000\\000\\t\\t\\t\\t\\t\\t\\000\\000\\t\\t\\t\\t\\t\\t\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\t\\t\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\t\\t\\t\\n\\186\\n\\194\\t\\t\\000\\000\\000\\000\\000\\000\\000\\000\\t\\t\\000\\000\\n\\202\\t\\t\\000\\000\\000\\000\\000\\000\\000\\000\\t\\t\\t\\t\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\t\\t\\t\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\t\\t\\t\\t\\000\\000\\000\\000\\t\\t\\000\\000\\t\\t\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\t\\t\\t\\n\\250\\000\\000\\t\\t\\t\\t\\t\\t\\t\\t\\000\\000\\000\\000\\000\\000\\t\\t\\000\\000\\t\\t\\t\\t\\000\\000\\t\\t\\t\\t\\t\\t\\n\\226\\t\\t\\t\\t\\000\\000\\000\\000\\t\\t\\011\\002\\t\\t\\000\\000\\000\\000\\000\\000\\000\\000\\t\\t\\t\\t\\011\\n\\011\\018\\002\\149\\002\\149\\000\\000\\000\\000\\000\\000\\002\\149\\000\\000\\000\\000\\002\\149\\000\\000\\000\\000\\002\\149\\000\\000\\002\\149\\000\\000\\000\\000\\nR\\000\\000\\002\\149\\002\\149\\002\\149\\000\\000\\002\\149\\002\\149\\002\\149\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\149\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\149\\002\\149\\n\\186\\n\\194\\002\\149\\000\\000\\000\\000\\000\\000\\000\\000\\002\\149\\000\\000\\n\\202\\002\\149\\000\\000\\000\\000\\000\\000\\000\\000\\002\\149\\002\\149\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\149\\002\\149\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\149\\002\\149\\000\\000\\000\\000\\002\\149\\000\\000\\002\\149\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\149\\002\\149\\n\\250\\000\\000\\002\\149\\002\\149\\002\\149\\002\\149\\000\\000\\000\\000\\000\\000\\002\\149\\000\\000\\002\\149\\002\\149\\000\\000\\011\\026\\002\\149\\011\\\"\\n\\226\\002\\149\\002\\149\\000\\000\\000\\000\\002\\149\\011\\002\\002\\149\\000\\000\\000\\000\\000\\000\\000\\000\\002\\149\\002\\149\\011\\n\\011\\018\\t\\005\\t\\005\\000\\000\\000\\000\\000\\000\\t\\005\\000\\000\\000\\000\\t\\005\\000\\000\\000\\000\\t\\005\\000\\000\\t\\005\\000\\000\\000\\000\\nR\\000\\000\\t\\005\\t\\005\\t\\005\\000\\000\\t\\005\\t\\005\\t\\005\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\t\\005\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\005\\t\\005\\n\\186\\n\\194\\t\\005\\000\\000\\000\\000\\000\\000\\000\\000\\t\\005\\000\\000\\n\\202\\t\\005\\000\\000\\000\\000\\000\\000\\000\\000\\t\\005\\t\\005\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\005\\t\\005\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\t\\005\\t\\005\\000\\000\\000\\000\\t\\005\\000\\000\\t\\005\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\005\\t\\005\\n\\250\\000\\000\\t\\005\\t\\005\\t\\005\\t\\005\\000\\000\\000\\000\\000\\000\\t\\005\\000\\000\\t\\005\\t\\005\\000\\000\\t\\005\\t\\005\\t\\005\\n\\226\\t\\005\\t\\005\\000\\000\\000\\000\\t\\005\\011\\002\\t\\005\\000\\000\\000\\000\\000\\000\\000\\000\\t\\005\\t\\005\\011\\n\\011\\018\\002\\193\\002\\193\\000\\000\\000\\000\\000\\000\\002\\193\\000\\000\\000\\000\\002\\193\\000\\000\\000\\000\\002\\193\\000\\000\\002\\193\\000\\000\\000\\000\\nR\\000\\000\\002\\193\\002\\193\\002\\193\\000\\000\\002\\193\\002\\193\\002\\193\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\193\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\193\\002\\193\\n\\186\\n\\194\\002\\193\\000\\000\\000\\000\\000\\000\\000\\000\\002\\193\\000\\000\\n\\202\\002\\193\\000\\000\\000\\000\\000\\000\\000\\000\\002\\193\\002\\193\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\193\\002\\193\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\193\\002\\193\\000\\000\\000\\000\\002\\193\\000\\000\\002\\193\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\193\\002\\193\\n\\250\\000\\000\\002\\193\\002\\193\\002\\193\\002\\193\\000\\000\\000\\000\\000\\000\\002\\193\\000\\000\\002\\193\\002\\193\\000\\000\\011\\026\\002\\193\\011\\\"\\n\\226\\002\\193\\002\\193\\000\\000\\000\\000\\002\\193\\011\\002\\002\\193\\000\\000\\000\\000\\000\\000\\000\\000\\002\\193\\002\\193\\011\\n\\011\\018\\002\\209\\002\\209\\000\\000\\000\\000\\000\\000\\002\\209\\000\\000\\000\\000\\002\\209\\000\\000\\000\\000\\002\\209\\000\\000\\002\\209\\000\\000\\000\\000\\nR\\000\\000\\002\\209\\002\\209\\002\\209\\000\\000\\002\\209\\002\\209\\002\\209\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\209\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\209\\002\\209\\n\\186\\n\\194\\002\\209\\000\\000\\000\\000\\000\\000\\000\\000\\002\\209\\000\\000\\n\\202\\002\\209\\000\\000\\000\\000\\000\\000\\000\\000\\002\\209\\002\\209\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\209\\002\\209\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\209\\002\\209\\000\\000\\000\\000\\002\\209\\000\\000\\002\\209\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\209\\002\\209\\n\\250\\000\\000\\002\\209\\002\\209\\002\\209\\002\\209\\000\\000\\000\\000\\000\\000\\002\\209\\000\\000\\002\\209\\002\\209\\000\\000\\011\\026\\002\\209\\011\\\"\\n\\226\\002\\209\\002\\209\\000\\000\\000\\000\\002\\209\\011\\002\\002\\209\\000\\000\\000\\000\\000\\000\\000\\000\\002\\209\\002\\209\\011\\n\\011\\018\\002\\201\\002\\201\\000\\000\\000\\000\\000\\000\\002\\201\\000\\000\\000\\000\\002\\201\\000\\000\\000\\000\\002\\201\\000\\000\\002\\201\\000\\000\\000\\000\\nR\\000\\000\\002\\201\\002\\201\\002\\201\\000\\000\\002\\201\\002\\201\\002\\201\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\201\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\201\\002\\201\\n\\186\\n\\194\\002\\201\\000\\000\\000\\000\\000\\000\\000\\000\\002\\201\\000\\000\\n\\202\\002\\201\\000\\000\\000\\000\\000\\000\\000\\000\\002\\201\\002\\201\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\201\\002\\201\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\201\\002\\201\\000\\000\\000\\000\\002\\201\\000\\000\\002\\201\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\201\\002\\201\\n\\250\\000\\000\\002\\201\\002\\201\\002\\201\\002\\201\\000\\000\\000\\000\\000\\000\\002\\201\\000\\000\\002\\201\\002\\201\\000\\000\\011\\026\\002\\201\\011\\\"\\n\\226\\002\\201\\002\\201\\000\\000\\000\\000\\002\\201\\011\\002\\002\\201\\000\\000\\000\\000\\000\\000\\000\\000\\002\\201\\002\\201\\011\\n\\011\\018\\002\\181\\002\\181\\000\\000\\000\\000\\000\\000\\002\\181\\000\\000\\000\\000\\002\\181\\000\\000\\000\\000\\002\\181\\000\\000\\002\\181\\000\\000\\000\\000\\nR\\000\\000\\002\\181\\002\\181\\002\\181\\000\\000\\002\\181\\002\\181\\002\\181\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\181\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\181\\002\\181\\n\\186\\n\\194\\002\\181\\000\\000\\000\\000\\000\\000\\000\\000\\002\\181\\000\\000\\n\\202\\002\\181\\000\\000\\000\\000\\000\\000\\000\\000\\002\\181\\002\\181\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\181\\002\\181\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\181\\002\\181\\000\\000\\000\\000\\002\\181\\000\\000\\002\\181\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\181\\002\\181\\n\\250\\000\\000\\002\\181\\002\\181\\002\\181\\002\\181\\000\\000\\000\\000\\000\\000\\002\\181\\000\\000\\002\\181\\002\\181\\000\\000\\011\\026\\002\\181\\011\\\"\\n\\226\\002\\181\\002\\181\\000\\000\\000\\000\\002\\181\\011\\002\\002\\181\\000\\000\\000\\000\\000\\000\\000\\000\\002\\181\\002\\181\\011\\n\\011\\018\\002\\189\\002\\189\\000\\000\\000\\000\\000\\000\\002\\189\\000\\000\\000\\000\\002\\189\\000\\000\\000\\000\\002\\189\\000\\000\\002\\189\\000\\000\\000\\000\\nR\\000\\000\\002\\189\\002\\189\\002\\189\\000\\000\\002\\189\\002\\189\\002\\189\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\189\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\189\\002\\189\\n\\186\\n\\194\\002\\189\\000\\000\\000\\000\\000\\000\\000\\000\\002\\189\\000\\000\\n\\202\\002\\189\\000\\000\\000\\000\\000\\000\\000\\000\\002\\189\\002\\189\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\189\\002\\189\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\189\\002\\189\\000\\000\\000\\000\\002\\189\\000\\000\\002\\189\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\189\\002\\189\\n\\250\\000\\000\\002\\189\\002\\189\\002\\189\\002\\189\\000\\000\\000\\000\\000\\000\\002\\189\\000\\000\\002\\189\\002\\189\\000\\000\\011\\026\\002\\189\\011\\\"\\n\\226\\002\\189\\002\\189\\000\\000\\000\\000\\002\\189\\011\\002\\002\\189\\000\\000\\000\\000\\000\\000\\000\\000\\002\\189\\002\\189\\011\\n\\011\\018\\002\\185\\002\\185\\000\\000\\000\\000\\000\\000\\002\\185\\000\\000\\000\\000\\002\\185\\000\\000\\000\\000\\002\\185\\000\\000\\002\\185\\000\\000\\000\\000\\nR\\000\\000\\002\\185\\002\\185\\002\\185\\000\\000\\002\\185\\002\\185\\002\\185\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\185\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\185\\002\\185\\n\\186\\n\\194\\002\\185\\000\\000\\000\\000\\000\\000\\000\\000\\002\\185\\000\\000\\n\\202\\002\\185\\000\\000\\000\\000\\000\\000\\000\\000\\002\\185\\002\\185\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\185\\002\\185\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\185\\002\\185\\000\\000\\000\\000\\002\\185\\000\\000\\002\\185\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\185\\002\\185\\n\\250\\000\\000\\002\\185\\002\\185\\002\\185\\002\\185\\000\\000\\000\\000\\000\\000\\002\\185\\000\\000\\002\\185\\002\\185\\000\\000\\011\\026\\002\\185\\011\\\"\\n\\226\\002\\185\\002\\185\\000\\000\\000\\000\\002\\185\\011\\002\\002\\185\\000\\000\\000\\000\\000\\000\\000\\000\\002\\185\\002\\185\\011\\n\\011\\018\\002\\197\\002\\197\\000\\000\\000\\000\\000\\000\\002\\197\\000\\000\\000\\000\\002\\197\\000\\000\\000\\000\\002\\197\\000\\000\\002\\197\\000\\000\\000\\000\\nR\\000\\000\\002\\197\\002\\197\\002\\197\\000\\000\\002\\197\\002\\197\\002\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\197\\002\\197\\n\\186\\n\\194\\002\\197\\000\\000\\000\\000\\000\\000\\000\\000\\002\\197\\000\\000\\n\\202\\002\\197\\000\\000\\000\\000\\000\\000\\000\\000\\002\\197\\002\\197\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\197\\002\\197\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\197\\002\\197\\000\\000\\000\\000\\002\\197\\000\\000\\002\\197\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\197\\002\\197\\n\\250\\000\\000\\002\\197\\002\\197\\002\\197\\002\\197\\000\\000\\000\\000\\000\\000\\002\\197\\000\\000\\002\\197\\002\\197\\000\\000\\011\\026\\002\\197\\011\\\"\\n\\226\\002\\197\\002\\197\\000\\000\\000\\000\\002\\197\\011\\002\\002\\197\\000\\000\\000\\000\\000\\000\\000\\000\\002\\197\\002\\197\\011\\n\\011\\018\\002\\213\\002\\213\\000\\000\\000\\000\\000\\000\\002\\213\\000\\000\\000\\000\\002\\213\\000\\000\\000\\000\\002\\213\\000\\000\\002\\213\\000\\000\\000\\000\\nR\\000\\000\\002\\213\\002\\213\\002\\213\\000\\000\\002\\213\\002\\213\\002\\213\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\213\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\213\\002\\213\\n\\186\\n\\194\\002\\213\\000\\000\\000\\000\\000\\000\\000\\000\\002\\213\\000\\000\\n\\202\\002\\213\\000\\000\\000\\000\\000\\000\\000\\000\\002\\213\\002\\213\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\213\\002\\213\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\213\\002\\213\\000\\000\\000\\000\\002\\213\\000\\000\\002\\213\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\213\\002\\213\\n\\250\\000\\000\\002\\213\\002\\213\\002\\213\\002\\213\\000\\000\\000\\000\\000\\000\\002\\213\\000\\000\\002\\213\\002\\213\\000\\000\\011\\026\\002\\213\\011\\\"\\n\\226\\002\\213\\002\\213\\000\\000\\000\\000\\002\\213\\011\\002\\002\\213\\000\\000\\000\\000\\000\\000\\000\\000\\002\\213\\002\\213\\011\\n\\011\\018\\002\\205\\002\\205\\000\\000\\000\\000\\000\\000\\002\\205\\000\\000\\000\\000\\002\\205\\000\\000\\000\\000\\002\\205\\000\\000\\002\\205\\000\\000\\000\\000\\nR\\000\\000\\002\\205\\002\\205\\002\\205\\000\\000\\002\\205\\002\\205\\002\\205\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\205\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\205\\002\\205\\n\\186\\n\\194\\002\\205\\000\\000\\000\\000\\000\\000\\000\\000\\002\\205\\000\\000\\n\\202\\002\\205\\000\\000\\000\\000\\000\\000\\000\\000\\002\\205\\002\\205\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\205\\002\\205\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\205\\002\\205\\000\\000\\000\\000\\002\\205\\000\\000\\002\\205\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\205\\002\\205\\n\\250\\000\\000\\002\\205\\002\\205\\002\\205\\002\\205\\000\\000\\000\\000\\000\\000\\002\\205\\000\\000\\002\\205\\002\\205\\000\\000\\011\\026\\002\\205\\011\\\"\\n\\226\\002\\205\\002\\205\\000\\000\\000\\000\\002\\205\\011\\002\\002\\205\\000\\000\\000\\000\\000\\000\\000\\000\\002\\205\\002\\205\\011\\n\\011\\018\\002\\177\\002\\177\\000\\000\\000\\000\\000\\000\\002\\177\\000\\000\\000\\000\\002\\177\\000\\000\\000\\000\\002\\177\\000\\000\\002\\177\\000\\000\\000\\000\\nR\\000\\000\\002\\177\\002\\177\\002\\177\\000\\000\\002\\177\\002\\177\\002\\177\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\177\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\177\\002\\177\\n\\186\\n\\194\\002\\177\\000\\000\\000\\000\\000\\000\\000\\000\\002\\177\\000\\000\\n\\202\\002\\177\\000\\000\\000\\000\\000\\000\\000\\000\\002\\177\\002\\177\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\177\\002\\177\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\177\\002\\177\\000\\000\\000\\000\\002\\177\\000\\000\\002\\177\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\177\\002\\177\\n\\250\\000\\000\\002\\177\\002\\177\\002\\177\\002\\177\\000\\000\\000\\000\\000\\000\\002\\177\\000\\000\\002\\177\\002\\177\\000\\000\\011\\026\\002\\177\\011\\\"\\n\\226\\002\\177\\002\\177\\000\\000\\000\\000\\002\\177\\011\\002\\002\\177\\000\\000\\000\\000\\000\\000\\000\\000\\002\\177\\002\\177\\011\\n\\011\\018\\002\\t\\002\\t\\000\\000\\000\\000\\000\\000\\002\\t\\000\\000\\000\\000\\002\\t\\000\\000\\000\\000\\002\\t\\000\\000\\002\\t\\000\\000\\000\\000\\002\\t\\000\\000\\002\\t\\002\\t\\002\\t\\000\\000\\002\\t\\002\\t\\002\\t\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\t\\002\\t\\002\\t\\002\\t\\002\\t\\000\\000\\002\\t\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\t\\002\\t\\002\\t\\002\\t\\002\\t\\000\\000\\000\\000\\000\\000\\000\\000\\002\\t\\000\\000\\002\\t\\002\\t\\000\\000\\000\\000\\000\\000\\000\\000\\002\\t\\002\\t\\002\\t\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\t\\002\\t\\002\\t\\002\\t\\002\\t\\002\\t\\002\\t\\002\\t\\002\\t\\000\\000\\000\\000\\002\\t\\000\\000\\002\\t\\002\\t\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\t\\002\\t\\002\\t\\000\\000\\002\\t\\002\\t\\002\\t\\002\\t\\000\\000\\000\\000\\000\\000\\002\\t\\000\\000\\002\\t\\002\\t\\000\\000\\002\\t\\002\\t\\002\\t\\002\\t\\002\\t\\002\\t\\000\\000\\000\\000\\002\\t\\002\\t\\014:\\000\\000\\000\\000\\000\\000\\000\\000\\002\\t\\002\\t\\002\\t\\002\\t\\002%\\002%\\000\\000\\000\\000\\000\\000\\002%\\000\\000\\000\\000\\002%\\000\\000\\000\\000\\002%\\000\\000\\002%\\000\\000\\000\\000\\nR\\000\\000\\002%\\002%\\002%\\000\\000\\002%\\002%\\002%\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002%\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002%\\002%\\n\\186\\n\\194\\002%\\000\\000\\000\\000\\000\\000\\000\\000\\002%\\000\\000\\n\\202\\002%\\000\\000\\000\\000\\000\\000\\000\\000\\002%\\002%\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002%\\002%\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002%\\002%\\000\\000\\000\\000\\002%\\000\\000\\002%\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002%\\002%\\n\\250\\000\\000\\002%\\002%\\014R\\002%\\000\\000\\000\\000\\000\\000\\002%\\000\\000\\002%\\002%\\000\\000\\011\\026\\002%\\011\\\"\\n\\226\\002%\\002%\\000\\000\\000\\000\\002%\\011\\002\\002%\\000\\000\\000\\000\\000\\000\\000\\000\\002%\\002%\\011\\n\\011\\018\\002!\\002!\\000\\000\\000\\000\\000\\000\\002!\\000\\000\\000\\000\\002!\\000\\000\\000\\000\\002!\\000\\000\\002!\\000\\000\\000\\000\\nR\\000\\000\\002!\\002!\\002!\\000\\000\\002!\\002!\\002!\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002!\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002!\\002!\\n\\186\\n\\194\\002!\\000\\000\\000\\000\\000\\000\\000\\000\\002!\\000\\000\\n\\202\\002!\\000\\000\\000\\000\\000\\000\\000\\000\\002!\\002!\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002!\\002!\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002!\\002!\\000\\000\\000\\000\\002!\\000\\000\\002!\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002!\\002!\\n\\250\\000\\000\\002!\\002!\\002!\\002!\\000\\000\\000\\000\\000\\000\\002!\\000\\000\\002!\\002!\\000\\000\\011\\026\\002!\\011\\\"\\n\\226\\002!\\002!\\000\\000\\000\\000\\002!\\011\\002\\002!\\000\\000\\000\\000\\000\\000\\000\\000\\002!\\002!\\011\\n\\011\\018\\002\\173\\002\\173\\000\\000\\000\\000\\000\\000\\002\\173\\000\\000\\000\\000\\002\\173\\000\\000\\000\\000\\002\\173\\000\\000\\002\\173\\000\\000\\000\\000\\nR\\000\\000\\002\\173\\002\\173\\002\\173\\000\\000\\002\\173\\002\\173\\002\\173\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\002\\173\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\173\\002\\173\\n\\186\\n\\194\\002\\173\\000\\000\\000\\000\\000\\000\\000\\000\\002\\173\\000\\000\\n\\202\\002\\173\\000\\000\\000\\000\\000\\000\\000\\000\\002\\173\\002\\173\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\173\\002\\173\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\002\\173\\002\\173\\000\\000\\000\\000\\002\\173\\000\\000\\002\\173\\n\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\173\\002\\173\\n\\250\\000\\000\\002\\173\\002\\173\\002\\173\\002\\173\\000\\000\\000\\000\\000\\000\\002\\173\\000\\000\\002\\173\\002\\173\\000\\000\\011\\026\\002\\173\\011\\\"\\n\\226\\002\\173\\002\\173\\000\\000\\000\\000\\002\\173\\011\\002\\002\\173\\000\\000\\000\\000\\000\\000\\000\\000\\002\\173\\002\\173\\011\\n\\011\\018\\002\\021\\002\\021\\000\\000\\000\\000\\000\\000\\002\\021\\000\\000\\000\\000\\002\\021\\000\\000\\000\\000\\002\\021\\000\\000\\002\\021\\000\\000\\000\\000\\002\\021\\000\\000\\002\\021\\002\\021\\002\\021\\000\\000\\002\\021\\002\\021\\002\\021\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\021\\002\\021\\002\\021\\002\\021\\002\\021\\000\\000\\002\\021\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\021\\002\\021\\002\\021\\002\\021\\002\\021\\000\\000\\000\\000\\000\\000\\000\\000\\002\\021\\000\\000\\002\\021\\002\\021\\000\\000\\000\\000\\000\\000\\000\\000\\002\\021\\002\\021\\002\\021\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\021\\002\\021\\002\\021\\002\\021\\002\\021\\002\\021\\002\\021\\002\\021\\002\\021\\000\\000\\000\\000\\002\\021\\000\\000\\002\\021\\002\\021\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\021\\002\\021\\002\\021\\000\\000\\002\\021\\002\\021\\002\\021\\002\\021\\000\\000\\000\\000\\000\\000\\002\\021\\000\\000\\002\\021\\002\\021\\000\\000\\002\\021\\002\\021\\002\\021\\002\\021\\002\\021\\002\\021\\000\\000\\000\\000\\002\\021\\002\\021\\014:\\000\\000\\000\\000\\000\\000\\000\\000\\002\\021\\002\\021\\002\\021\\002\\021\\002\\025\\002\\025\\000\\000\\000\\000\\000\\000\\002\\025\\000\\000\\000\\000\\002\\025\\000\\000\\000\\000\\002\\025\\000\\000\\002\\025\\000\\000\\000\\000\\002\\025\\000\\000\\002\\025\\002\\025\\002\\025\\000\\000\\002\\025\\002\\025\\002\\025\\000\\000\\000\\000\\006>\\000\\000\\000\\000\\002\\025\\002\\025\\002\\025\\002\\025\\002\\025\\000\\000\\002\\025\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\025\\002\\025\\002\\025\\002\\025\\002\\025\\006B\\000\\000\\000\\000\\000\\000\\002\\025\\000\\000\\002\\025\\002\\025\\000\\000\\000\\000\\000\\000\\000\\000\\002\\025\\002\\025\\002\\025\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\025\\002\\025\\002\\025\\002\\025\\002\\025\\002\\025\\002\\025\\002\\025\\002\\025\\000\\000\\000\\000\\002\\025\\000\\000\\002\\025\\002\\025\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\238\\002\\025\\002\\025\\002\\025\\000\\000\\002\\025\\002\\025\\002\\025\\002\\025\\000\\000\\000\\000\\000\\000\\002\\025\\000\\000\\002\\025\\002\\025\\000\\000\\002\\025\\002\\025\\002\\025\\002\\025\\002\\025\\002\\025\\000\\000\\000\\000\\002\\025\\002\\025\\014:\\000\\000\\000\\000\\000\\000\\000\\000\\002\\025\\002\\025\\002\\025\\002\\025\\001\\006\\000\\000\\000\\006\\000\\000\\007)\\000\\000\\002\\186\\002\\190\\006F\\002\\234\\002\\138\\005\\234\\006R\\000\\000\\000\\000\\002\\246\\001\\n\\000\\000\\006f\\000\\000\\002\\150\\000\\000\\006r\\007)\\000\\000\\001\\210\\003\\142\\007)\\002\\190\\003\\226\\001\\018\\b\\206\\b\\210\\001\\030\\001\\\"\\003b\\000\\000\\000\\000\\002\\254\\000\\000\\003\\150\\bB\\016\\186\\000\\000\\b\\246\\b\\250\\001\\210\\003\\210\\003\\222\\003\\234\\b\\254\\007\\030\\000\\000\\001:\\000\\000\\002\\178\\000\\000\\000\\000\\003\\230\\000\\000\\000\\000\\000\\000\\bz\\b~\\b\\138\\b\\158\\000\\000\\005v\\000\\000\\003\\138\\001>\\001B\\001F\\001J\\001N\\000\\000\\002\\178\\t\\018\\001R\\000\\000\\007\\029\\000\\000\\001V\\000\\000\\t\\030\\t6\\t\\130\\005\\130\\005\\134\\000\\000\\000\\000\\001Z\\000\\000\\000\\000\\000\\000\\007)\\000\\000\\001^\\002\\225\\007\\029\\000\\000\\000\\000\\019N\\007\\029\\0072\\000\\000\\000\\000\\001\\154\\0062\\000\\000\\t\\202\\005\\138\\b\\146\\t\\214\\001\\158\\000\\000\\014\\130\\004r\\t\\150\\001\\006\\001\\166\\000\\006\\001\\170\\001\\174\\025\\170\\002\\186\\002\\190\\000\\n\\002\\234\\002\\138\\000\\000\\000\\000\\000\\000\\000\\000\\002\\246\\001\\n\\000\\000\\000\\000\\000\\000\\b\\202\\000\\000\\000\\238\\000\\000\\002\\225\\001\\210\\000\\000\\000\\000\\000\\000\\003\\226\\001\\018\\b\\206\\b\\210\\001\\030\\001\\\"\\000\\000\\002\\225\\002\\225\\002\\254\\000\\000\\003\\150\\000\\000\\b\\214\\000\\000\\b\\246\\b\\250\\000\\238\\003\\210\\003\\222\\003\\234\\b\\254\\007\\030\\000\\000\\001:\\000\\000\\002\\178\\007\\001\\000\\000\\003\\230\\000\\000\\000\\000\\000\\000\\bz\\b~\\b\\138\\b\\158\\006F\\005v\\000\\000\\005\\234\\001>\\001B\\001F\\001J\\001N\\007\\001\\006f\\t\\018\\001R\\007\\001\\006r\\000\\000\\001V\\000\\000\\t\\030\\t6\\t\\130\\005\\130\\005\\134\\000\\000\\006F\\001Z\\000\\000\\005\\234\\025\\174\\000\\000\\000\\000\\001^\\000\\000\\000\\000\\006f\\000\\000\\000\\000\\000\\000\\006r\\000\\000\\000\\000\\001\\154\\006\\134\\000\\000\\000\\000\\005\\138\\b\\146\\012\\233\\001\\158\\000\\000\\014\\130\\004r\\t\\150\\004\\133\\001\\166\\000\\006\\001\\170\\001\\174\\000\\246\\002\\186\\002\\190\\002\\194\\002\\234\\002\\138\\000\\000\\000\\000\\000\\000\\012\\233\\002\\246\\000\\000\\002&\\003j\\000\\000\\002*\\000\\000\\004\\133\\000\\000\\003n\\001\\210\\000\\000\\017\\186\\007\\001\\002\\250\\000\\000\\003r\\003v\\0026\\000\\000\\000\\000\\003z\\000\\000\\002\\254\\000\\000\\003\\150\\000\\000\\017N\\000\\000\\003\\202\\003\\206\\004\\026\\003\\210\\003\\222\\003\\234\\003\\242\\007\\030\\000\\000\\000\\000\\017\\178\\002\\178\\000\\000\\000\\000\\003\\230\\017\\202\\002B\\000\\000\\bz\\b~\\b\\138\\b\\158\\000\\000\\005v\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\017\\210\\000\\000\\t\\018\\000\\000\\t5\\000\\000\\000\\000\\000\\000\\000\\000\\t\\030\\t6\\t\\130\\005\\130\\005\\134\\017\\230\\018\\\"\\000\\000\\000\\000\\004\\133\\004\\133\\000\\000\\000\\000\\000\\000\\006\\178\\004\\017\\000\\000\\t5\\000\\000\\000\\000\\002F\\012\\233\\012\\213\\000\\000\\000\\000\\018^\\022Z\\005\\138\\b\\146\\016\\166\\000\\181\\000\\000\\b\\170\\004r\\t\\150\\000\\181\\000\\000\\002\\190\\000\\181\\000\\000\\002\\138\\012\\233\\t\\190\\000\\000\\002&\\002\\246\\000\\000\\002*\\000\\181\\000\\000\\000\\181\\000\\000\\000\\181\\000\\000\\000\\181\\001\\210\\000\\238\\t\\246\\000\\000\\002\\250\\0026\\000\\000\\000\\000\\002>\\012\\213\\t\\254\\000\\181\\000\\000\\002\\254\\000\\000\\003\\150\\000\\000\\000\\181\\000\\000\\000\\000\\000\\000\\000\\181\\000\\000\\003\\222\\001\\190\\015\\190\\000\\181\\000\\000\\002\\138\\000\\181\\002\\178\\004\\017\\002B\\003\\230\\000\\181\\000\\181\\000\\181\\bz\\b~\\b\\138\\000\\000\\012\\166\\005v\\000\\181\\000\\181\\006F\\022\\002\\000\\000\\005\\234\\tR\\000\\181\\000\\000\\000\\000\\t5\\000\\181\\006f\\000\\000\\000\\000\\000\\000\\006r\\000\\000\\000\\000\\005\\130\\005\\134\\000\\181\\000\\181\\015\\194\\000\\000\\000\\181\\000\\181\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002F\\000\\000\\000\\181\\000\\000\\015\\206\\000\\000\\022&\\000\\000\\000\\181\\000\\181\\005\\138\\b\\146\\000\\000\\000\\000\\000\\205\\b\\170\\004r\\000\\000\\000\\181\\000\\205\\000\\181\\002\\190\\000\\205\\000\\000\\002\\138\\000\\000\\t\\190\\000\\000\\000\\000\\002\\246\\005\\134\\000\\000\\000\\205\\000\\000\\000\\205\\000\\000\\000\\205\\000\\000\\000\\205\\001\\210\\0222\\t\\246\\000\\000\\002\\250\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\254\\000\\205\\000\\000\\002\\254\\000\\000\\003\\150\\000\\000\\000\\205\\021\\198\\000\\000\\000\\000\\000\\205\\000\\000\\003\\222\\001\\190\\000\\000\\000\\205\\000\\000\\000\\000\\000\\205\\002\\178\\000\\000\\000\\000\\003\\230\\000\\205\\000\\205\\000\\205\\bz\\b~\\b\\138\\000\\000\\012\\166\\005v\\000\\205\\000\\205\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\205\\000\\000\\000\\000\\000\\000\\000\\205\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\130\\005\\134\\000\\205\\000\\205\\000\\000\\000\\000\\000\\205\\000\\205\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\205\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\205\\000\\205\\005\\138\\b\\146\\000\\000\\000\\000\\000\\000\\b\\170\\004r\\000\\000\\000\\205\\000\\000\\000\\205\\000\\014\\000\\018\\000\\022\\000\\026\\000\\030\\000\\000\\000\\\"\\000&\\000*\\000.\\0002\\000\\000\\0006\\000:\\000\\000\\000\\000\\000>\\016\\210\\000\\000\\000\\000\\000B\\000\\000\\015\\190\\000\\000\\002\\014\\002\\138\\000\\000\\000F\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000J\\002\\018\\000N\\000R\\000V\\000Z\\000^\\000b\\000f\\001\\210\\000\\000\\000\\000\\000j\\000n\\000\\000\\000r\\000\\000\\000v\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003R\\000\\000\\000\\000\\000\\000\\015\\194\\000z\\007J\\001\\222\\000~\\000\\130\\000\\000\\000\\000\\000\\000\\002\\178\\000\\000\\000\\134\\000\\138\\000\\142\\015\\206\\000\\000\\022\\006\\000\\000\\000\\000\\000\\146\\000\\150\\000\\154\\000\\158\\000\\000\\000\\162\\000\\166\\000\\170\\000\\000\\001\\021\\000\\000\\000\\174\\000\\178\\000\\182\\001\\021\\000\\000\\000\\000\\000\\186\\007N\\000\\190\\000\\194\\005\\134\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\198\\000\\000\\000\\202\\000\\000\\022\\018\\000\\000\\001\\021\\003\\225\\000\\206\\000\\210\\000\\000\\000\\214\\003\\225\\003\\014\\002\\190\\003\\225\\000\\000\\002\\138\\000\\000\\006\\238\\000\\000\\021\\198\\002\\246\\000\\000\\000\\000\\003\\225\\000\\000\\000\\000\\001\\021\\003\\225\\003\\n\\003\\225\\001\\210\\007\\209\\007\\014\\000\\000\\001\\021\\000\\000\\000\\000\\003\\018\\000\\000\\001\\021\\tB\\003\\225\\000\\000\\n\\233\\000\\000\\000\\000\\000\\000\\003\\225\\001\\021\\001\\021\\003\\030\\000\\000\\000\\000\\0116\\001\\190\\000\\000\\003\\225\\000\\000\\000\\000\\003\\225\\002\\178\\007\\209\\000\\000\\003\\246\\003\\225\\003\\225\\n\\229\\003\\250\\000\\000\\004\\002\\000\\000\\011F\\005v\\n\\233\\001\\021\\007\\209\\000\\000\\000\\000\\007\\209\\t\\006\\003\\225\\003\\225\\000\\000\\001\\021\\005z\\007\\209\\000\\000\\n\\233\\000\\000\\007\\209\\n\\233\\011\\194\\005\\130\\005\\134\\003\\225\\003\\225\\011N\\n\\233\\003\\225\\003\\225\\000\\000\\n\\233\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\229\\t\\202\\000\\000\\n\\229\\011v\\003\\225\\005\\138\\000\\000\\000\\000\\000\\000\\n\\229\\000\\000\\004r\\t!\\n\\229\\000\\006\\003\\225\\000\\000\\000\\246\\002\\186\\002\\190\\002\\194\\002\\234\\002\\138\\000\\000\\000\\000\\000\\000\\000\\000\\002\\246\\000\\000\\000\\000\\004\\165\\000\\000\\t!\\000\\000\\t!\\t!\\003n\\001\\210\\000\\000\\000\\000\\000\\000\\002\\250\\000\\000\\003r\\003v\\000\\000\\000\\000\\000\\000\\003z\\000\\000\\002\\254\\000\\000\\003\\150\\000\\000\\017N\\000\\000\\003\\202\\003\\206\\000\\000\\003\\210\\003\\222\\003\\234\\003\\242\\007\\030\\000\\000\\000\\000\\017\\178\\002\\178\\000\\000\\000\\000\\003\\230\\017\\202\\000\\000\\000\\000\\bz\\b~\\b\\138\\b\\158\\000\\000\\005v\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\017\\210\\000\\000\\t\\018\\000\\000\\028\\142\\000\\000\\000\\000\\000\\000\\000\\000\\t\\030\\t6\\t\\130\\005\\130\\005\\134\\017\\230\\018\\\"\\000\\000\\000\\006\\028\\175\\015\\022\\000\\246\\002\\186\\002\\190\\002\\194\\002\\234\\002\\138\\000\\000\\000\\000\\000\\000\\000\\000\\002\\246\\000\\000\\000\\000\\028\\222\\000\\000\\022Z\\005\\138\\b\\146\\t!\\003n\\001\\210\\b\\170\\004r\\t\\150\\002\\250\\000\\000\\003r\\003v\\000\\000\\000\\000\\000\\000\\003z\\000\\000\\002\\254\\000\\000\\003\\150\\000\\000\\017N\\000\\000\\003\\202\\003\\206\\000\\000\\003\\210\\003\\222\\003\\234\\003\\242\\007\\030\\000\\000\\017\\014\\017\\178\\002\\178\\000\\000\\000\\000\\003\\230\\017\\202\\002\\014\\000\\000\\bz\\b~\\b\\138\\b\\158\\000\\000\\005v\\000\\000\\000\\000\\002\\018\\000\\000\\000\\000\\000\\000\\000\\000\\017\\210\\000\\000\\t\\018\\001\\210\\028\\142\\000\\000\\000\\000\\000\\000\\000\\000\\t\\030\\t6\\t\\130\\005\\130\\005\\134\\017\\230\\018\\\"\\000\\000\\000\\000\\004\\173\\000\\000\\003R\\000\\000\\000\\000\\000\\000\\001\\006\\000\\000\\007J\\001\\222\\000\\000\\000\\000\\003\\014\\002\\190\\006\\014\\002\\178\\002\\138\\022Z\\005\\138\\b\\146\\014\\150\\002\\246\\001\\n\\b\\170\\004r\\t\\150\\002\\150\\000\\000\\000\\000\\000\\000\\000\\000\\001\\210\\000\\000\\000\\000\\000\\000\\001\\014\\001\\018\\001\\022\\003.\\001\\030\\001\\\"\\000\\000\\000\\000\\007N\\000\\000\\000\\000\\002\\225\\000\\000\\0032\\002\\225\\001.\\006.\\000\\000\\000\\000\\003*\\001\\190\\0016\\002\\225\\000\\000\\001:\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\002\\225\\003\\250\\000\\000\\004\\002\\005j\\000\\n\\005v\\000\\000\\002\\225\\001>\\001B\\001F\\001J\\001N\\000\\000\\000\\000\\000\\n\\001R\\005z\\000\\000\\002\\225\\001V\\000\\000\\000\\000\\000\\000\\002\\225\\005\\130\\005\\134\\000\\000\\005\\202\\001Z\\002\\225\\002\\225\\002\\225\\002\\225\\000\\000\\001^\\000\\000\\002\\225\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\225\\000\\000\\001\\154\\0062\\000\\000\\000\\000\\005\\138\\000\\000\\000\\000\\001\\158\\000\\000\\001\\162\\004r\\001\\006\\000\\000\\001\\166\\002\\225\\001\\170\\001\\174\\003\\014\\002\\190\\tr\\002\\225\\002\\138\\000\\000\\000\\000\\000\\000\\000\\000\\002\\246\\001\\n\\000\\000\\000\\000\\000\\000\\002\\150\\000\\000\\000\\000\\000\\000\\000\\000\\001\\210\\000\\000\\000\\000\\000\\000\\001\\014\\001\\018\\001\\022\\003.\\001\\030\\001\\\"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0032\\000\\000\\001.\\006.\\000\\000\\000\\000\\003*\\001\\190\\0016\\000\\000\\000\\000\\001:\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\000\\000\\000\\000\\001>\\001B\\001F\\001J\\001N\\000\\000\\000\\000\\000\\000\\001R\\005z\\000\\000\\000\\000\\001V\\000\\000\\000\\000\\000\\000\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\001Z\\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\\001\\154\\0062\\000\\000\\000\\000\\005\\138\\000\\000\\000\\000\\001\\158\\000\\000\\001\\162\\004r\\001\\006\\000\\000\\001\\166\\000\\000\\001\\170\\001\\174\\003\\014\\002\\190\\011:\\000\\000\\002\\138\\000\\000\\000\\000\\000\\000\\000\\000\\002\\246\\001\\n\\000\\000\\000\\000\\000\\000\\002\\150\\000\\000\\000\\000\\000\\000\\000\\000\\001\\210\\000\\000\\000\\000\\000\\000\\001\\014\\001\\018\\001\\022\\003.\\001\\030\\001\\\"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0032\\000\\000\\001.\\006.\\000\\000\\000\\000\\003*\\001\\190\\0016\\000\\000\\000\\000\\001:\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\000\\000\\000\\000\\001>\\001B\\001F\\001J\\001N\\000\\000\\000\\000\\000\\000\\001R\\005z\\000\\000\\000\\000\\001V\\000\\000\\000\\000\\000\\000\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\001Z\\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\\001\\154\\0062\\000\\000\\000\\000\\005\\138\\000\\000\\000\\000\\001\\158\\000\\000\\001\\162\\004r\\001\\006\\000\\000\\001\\166\\000\\000\\001\\170\\001\\174\\003\\014\\002\\190\\r\\230\\000\\000\\002\\138\\000\\000\\000\\000\\000\\000\\000\\000\\002\\246\\001\\n\\000\\000\\000\\000\\000\\000\\002\\150\\000\\000\\000\\000\\000\\000\\000\\000\\001\\210\\000\\000\\000\\000\\000\\000\\001\\014\\001\\018\\001\\022\\003.\\001\\030\\001\\\"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0032\\000\\000\\001.\\006.\\000\\000\\000\\000\\003*\\001\\190\\0016\\000\\000\\000\\000\\001:\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\000\\000\\000\\000\\001>\\001B\\001F\\001J\\001N\\000\\000\\000\\000\\000\\000\\001R\\005z\\000\\000\\000\\000\\001V\\000\\000\\000\\000\\000\\000\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\001Z\\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\\001\\154\\0062\\000\\000\\000\\000\\005\\138\\000\\000\\000\\000\\001\\158\\000\\000\\001\\162\\004r\\000\\000\\005\\021\\001\\166\\000\\000\\001\\170\\001\\174\\005\\021\\005\\021\\005\\021\\005\\021\\001\\205\\005\\021\\000\\000\\005\\021\\005\\021\\001\\205\\000\\000\\005\\021\\000\\000\\005\\021\\000\\000\\005\\021\\005\\021\\005\\021\\005\\021\\005\\021\\005\\021\\000\\000\\005\\021\\005\\021\\005\\021\\000\\000\\000\\000\\000\\000\\001\\205\\000\\000\\000\\000\\005\\021\\000\\000\\000\\000\\000\\000\\000\\000\\005\\021\\005\\021\\005\\021\\000\\000\\000\\000\\000\\000\\005\\021\\005\\021\\005\\021\\000\\000\\005\\021\\000\\000\\000\\000\\005\\021\\001\\205\\005\\021\\000\\000\\000\\000\\005\\021\\005\\021\\005\\021\\000\\000\\001\\205\\005\\021\\005\\021\\005\\021\\000\\000\\001\\205\\001\\205\\000\\238\\000\\000\\000\\000\\005\\021\\005\\021\\005\\021\\000\\000\\001\\205\\001\\205\\005\\021\\005\\021\\000\\000\\000\\000\\000\\000\\005\\021\\000\\000\\000\\000\\005\\021\\000\\000\\005\\021\\005\\021\\005\\021\\000\\000\\005\\021\\005\\021\\005\\021\\005\\021\\000\\000\\005\\021\\005\\021\\000\\000\\000\\000\\000\\000\\001\\205\\000\\000\\000\\000\\t2\\000\\000\\005\\021\\020\\214\\005\\021\\005\\021\\001\\205\\000\\000\\002\\158\\005\\021\\000\\000\\000\\000\\000\\000\\000\\000\\005\\021\\005\\021\\011\\001\\000\\000\\005\\021\\011\\001\\005\\021\\005\\021\\011\\001\\011\\001\\012\\233\\012\\213\\011\\001\\000\\000\\011\\001\\000\\000\\000\\000\\011\\001\\000\\000\\000\\000\\000\\000\\011\\001\\011\\001\\000\\000\\011\\001\\011\\001\\014&\\011\\001\\000\\000\\011\\001\\012\\233\\017\\030\\000\\000\\002&\\011\\001\\000\\000\\002*\\011\\001\\002\\014\\000\\000\\000\\000\\000\\000\\000\\000\\0022\\000\\238\\011\\001\\000\\000\\011\\001\\002\\018\\0026\\011\\001\\011\\001\\002>\\012\\213\\000\\000\\000\\000\\001\\210\\011\\001\\000\\000\\000\\000\\011\\001\\000\\000\\000\\000\\011\\001\\011\\001\\000\\000\\011\\001\\000\\000\\011\\001\\011\\001\\000\\000\\000\\000\\000\\000\\003R\\000\\000\\000\\000\\002B\\000\\000\\000\\000\\007J\\001\\222\\011\\001\\000\\000\\000\\000\\000\\000\\000\\000\\002\\178\\000\\000\\006F\\011\\001\\011\\001\\005\\234\\000\\000\\011\\001\\000\\000\\011\\001\\000\\000\\000\\000\\006f\\000\\000\\005\\166\\000\\000\\006r\\000\\000\\000\\000\\001\\202\\001\\206\\011\\001\\011\\001\\000\\000\\011\\001\\011\\001\\000\\000\\011\\001\\007N\\011\\001\\000\\000\\011\\001\\000\\000\\011\\001\\002F\\011\\001\\t\\r\\t\\r\\001\\210\\001\\250\\001\\230\\t\\r\\000\\000\\001\\206\\t\\r\\000\\000\\000\\000\\000\\000\\001\\242\\000\\000\\000\\000\\019z\\t\\r\\000\\000\\t\\r\\t\\r\\t\\r\\000\\000\\t\\r\\t\\r\\t\\r\\001\\246\\020\\210\\000\\000\\019\\242\\000\\000\\002\\166\\000\\000\\002\\178\\004\\030\\004*\\000\\000\\t\\r\\000\\000\\000\\000\\020\\226\\000\\000\\000\\000\\t\\r\\t\\r\\000\\000\\000\\000\\t\\r\\000\\000\\000\\000\\002\\162\\000\\000\\t\\r\\000\\000\\000\\000\\t\\r\\000\\000\\004:\\000\\000\\000\\000\\t\\r\\t\\r\\t\\r\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\r\\t\\r\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\r\\000\\000\\000\\000\\000\\000\\004\\154\\000\\000\\000\\000\\t\\r\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\r\\t\\r\\t\\r\\000\\000\\t\\r\\t\\r\\000\\000\\004q\\000\\000\\000\\000\\000\\000\\000\\000\\004q\\000\\000\\t\\r\\004q\\t\\r\\t\\r\\000\\000\\000\\000\\000\\000\\t\\r\\000\\000\\000\\000\\000\\000\\004q\\t\\r\\000\\000\\000\\000\\004q\\t\\r\\004q\\t\\r\\t\\r\\012\\169\\012\\169\\000\\000\\000\\000\\004q\\012\\169\\000\\000\\001\\206\\012\\169\\004q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004q\\004\\186\\000\\000\\012\\169\\012\\169\\012\\169\\004B\\012\\169\\012\\169\\012\\169\\000\\000\\000\\000\\004q\\004q\\000\\000\\000\\000\\000\\000\\004q\\002\\226\\000\\000\\000\\000\\012\\169\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\169\\012\\169\\000\\000\\000\\000\\012\\169\\000\\000\\004q\\002\\162\\004q\\012\\169\\000\\000\\000\\000\\012\\169\\000\\000\\000\\000\\000\\000\\004q\\012\\169\\012\\169\\012\\169\\004q\\004q\\002\\226\\000\\238\\004q\\004q\\012\\169\\012\\169\\000\\000\\000\\000\\004R\\004q\\000\\000\\012\\169\\000\\000\\000\\000\\000\\000\\004\\154\\000\\000\\000\\000\\012\\169\\004q\\000\\000\\000\\000\\000\\000\\000\\000\\021\\218\\012\\169\\012\\169\\012\\169\\000\\000\\012\\169\\012\\169\\000\\000\\007\\017\\000\\000\\004q\\000\\000\\000\\000\\007\\017\\000\\000\\012\\169\\007\\017\\012\\169\\012\\169\\004q\\000\\000\\000\\000\\012\\169\\000\\000\\000\\000\\000\\000\\007\\017\\012\\169\\000\\000\\000\\000\\007\\017\\012\\169\\007\\017\\012\\169\\012\\169\\t\\017\\t\\017\\000\\000\\000\\000\\000\\000\\t\\017\\000\\000\\001\\206\\t\\017\\007\\017\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\007\\017\\t\\017\\000\\000\\t\\017\\t\\017\\t\\017\\000\\000\\t\\017\\t\\017\\t\\017\\000\\000\\000\\000\\007\\017\\000\\000\\000\\000\\000\\000\\000\\000\\007\\017\\007\\017\\000\\000\\000\\000\\t\\017\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\017\\t\\017\\000\\000\\000\\000\\t\\017\\000\\000\\007\\017\\002\\162\\000\\000\\t\\017\\000\\000\\000\\000\\t\\017\\000\\000\\000\\000\\000\\000\\000\\000\\t\\017\\t\\017\\t\\017\\007\\017\\007\\017\\017b\\000\\000\\007\\017\\007\\017\\t\\017\\t\\017\\002\\225\\000\\000\\000\\000\\000\\000\\000\\000\\t\\017\\000\\000\\002\\225\\000\\000\\004\\154\\018\\162\\000\\000\\t\\017\\007\\017\\000\\000\\000\\000\\000\\000\\000\\000\\002\\225\\t\\017\\t\\017\\t\\017\\000\\000\\t\\017\\t\\017\\000\\000\\000\\n\\000\\000\\002\\225\\002\\225\\000\\000\\000\\000\\002\\225\\t\\017\\002\\225\\t\\017\\t\\017\\002\\225\\002\\225\\002\\225\\t\\017\\002\\225\\002\\225\\002\\225\\002\\225\\t\\017\\000\\000\\002\\225\\002\\225\\t\\017\\002\\225\\t\\017\\t\\017\\002\\225\\002\\225\\000\\n\\000\\000\\002\\225\\002\\225\\002\\225\\000\\000\\002\\225\\000\\n\\002\\225\\002\\225\\000\\n\\000\\000\\002\\225\\007\\\"\\000\\n\\002\\225\\002\\225\\002\\225\\000\\000\\015v\\002\\225\\002\\225\\002\\225\\000\\000\\002\\225\\002\\225\\002\\225\\002\\225\\002\\225\\002\\225\\000\\000\\002\\225\\002\\225\\002\\225\\002\\225\\002\\225\\002\\225\\000\\000\\002\\225\\002\\225\\002\\225\\002\\225\\002\\225\\002\\225\\002\\225\\000\\000\\002\\225\\005E\\r)\\002\\225\\000\\000\\000\\000\\000\\000\\000\\000\\002\\225\\002\\225\\002\\225\\002\\225\\000\\000\\000\\000\\000\\000\\002\\225\\002\\225\\002\\225\\002\\225\\002\\225\\005E\\015\\178\\002\\225\\000\\000\\005E\\002\\225\\002\\225\\000\\000\\000\\000\\000\\000\\000\\000\\002\\225\\002\\225\\000\\000\\000\\n\\000\\000\\002\\225\\000\\000\\002\\225\\000\\000\\000\\000\\000\\246\\002\\225\\002\\225\\002\\026\\000a\\000\\000\\002\\225\\002\\225\\002\\225\\000a\\003~\\000a\\000a\\018b\\000\\000\\002\\225\\000\\000\\000\\000\\000\\000\\003n\\000a\\002\\225\\000a\\000a\\000\\000\\000\\000\\000a\\000a\\000a\\000\\000\\b\\185\\018f\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\018\\142\\r)\\r)\\000a\\000\\000\\000\\000\\002\\225\\000\\000\\000\\000\\000a\\000a\\000\\000\\017\\178\\000a\\005E\\000\\000\\000a\\017\\202\\000a\\000\\000\\r)\\000a\\r)\\000\\000\\000\\000\\000\\000\\000a\\000a\\000a\\005E\\000\\000\\000\\000\\005E\\019&\\000\\000\\000a\\000a\\000\\000\\000\\000\\007&\\000\\000\\000\\000\\000a\\000a\\000\\000\\000\\000\\000a\\017\\230\\019:\\000a\\000\\000\\004y\\000\\000\\000\\000\\000\\000\\000\\000\\000a\\000a\\000a\\000\\000\\000a\\000a\\000\\000\\000\\000\\000\\000\\006\\169\\b\\185\\000A\\019J\\000\\000\\000a\\000A\\000A\\000a\\000A\\000A\\000\\000\\000a\\000\\000\\000\\000\\000A\\000\\000\\000a\\000\\000\\000\\000\\006\\169\\000a\\000\\000\\000a\\000\\000\\000A\\000\\000\\000\\000\\000\\000\\000A\\000\\000\\000A\\000A\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000A\\000\\000\\000A\\000\\000\\000\\000\\000\\000\\000A\\000A\\000\\000\\000A\\000A\\000A\\000A\\000A\\000\\000\\000\\000\\000\\000\\000A\\000\\000\\000\\000\\000A\\000\\000\\000\\000\\000\\000\\000A\\000A\\000A\\000A\\000\\000\\000A\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000A\\000\\000\\000\\000\\000\\000\\012\\233\\012\\213\\000\\000\\000A\\000A\\000A\\000A\\000A\\000\\000\\006\\165\\000\\000\\000=\\000\\000\\000\\000\\000\\000\\000=\\000=\\000\\000\\000=\\000=\\012\\233\\000\\000\\000\\000\\002&\\000=\\000\\000\\002*\\000\\000\\000\\000\\006\\165\\000A\\000A\\000\\000\\002\\206\\000=\\000A\\000A\\000A\\000=\\0026\\000=\\000=\\002>\\012\\213\\000\\000\\000\\000\\000\\000\\000=\\000\\000\\000=\\000\\000\\000\\000\\000\\000\\000=\\000=\\000\\000\\000=\\000=\\000=\\000=\\000=\\000\\000\\000\\000\\000\\000\\000=\\000\\000\\002B\\000=\\000\\000\\000\\000\\000\\000\\000=\\000=\\000=\\000=\\000\\000\\000=\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000=\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000=\\000=\\000=\\000=\\000=\\000\\000\\006\\181\\000\\000\\012q\\000\\000\\000\\000\\000\\000\\012q\\012q\\000\\000\\012q\\012q\\002F\\000\\000\\000\\000\\000\\000\\012q\\000\\000\\000\\000\\000\\000\\000\\000\\006\\181\\000=\\000=\\000\\000\\000\\000\\012q\\000=\\000=\\000=\\012q\\000\\000\\012q\\012q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012q\\000\\000\\012q\\000\\000\\000\\000\\000\\000\\012q\\012q\\001*\\012q\\012q\\012q\\012q\\012q\\000\\000\\002\\225\\000\\000\\012q\\000\\000\\000\\000\\012q\\000\\000\\002\\225\\000\\000\\012q\\012q\\012q\\012q\\000\\000\\012q\\000\\000\\000\\000\\000\\000\\002\\225\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012q\\000\\000\\000\\n\\000\\000\\000\\000\\000\\000\\000\\000\\012q\\012q\\012q\\012q\\012q\\000\\000\\006\\177\\000\\000\\012m\\000\\000\\002\\225\\000\\000\\012m\\012m\\000\\000\\012m\\012m\\002\\225\\000\\000\\000\\000\\000\\000\\012m\\000\\000\\002\\225\\000\\000\\000\\000\\006\\177\\012q\\012q\\000\\000\\000\\000\\012m\\012q\\012q\\012q\\012m\\000\\000\\012m\\012m\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012m\\002\\225\\012m\\000\\000\\000\\000\\000\\000\\012m\\012m\\000\\000\\012m\\012m\\012m\\012m\\012m\\000\\000\\001\\202\\001\\206\\012m\\000\\000\\000\\000\\012m\\000\\000\\000\\000\\000\\000\\012m\\012m\\012m\\012m\\000\\000\\012m\\000\\000\\000\\000\\000\\000\\000\\000\\001\\210\\001\\250\\001\\230\\000\\000\\000\\000\\012m\\000\\000\\000\\000\\000\\000\\000\\000\\001\\242\\000\\000\\012m\\012m\\012m\\012m\\012m\\002\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\246\\002\\154\\000\\000\\000\\000\\000\\000\\002\\166\\000\\000\\002\\178\\004\\030\\004*\\012\\173\\012\\173\\000\\000\\000\\000\\0046\\012\\173\\012m\\012m\\012\\173\\000\\000\\000\\000\\012m\\012m\\012m\\000\\000\\000\\000\\004\\138\\000\\000\\012\\173\\012\\173\\012\\173\\004:\\012\\173\\012\\173\\012\\173\\000\\000\\001\\029\\000\\000\\000\\000\\000\\000\\000\\000\\001\\029\\000\\000\\000\\000\\000\\000\\000\\000\\012\\173\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\173\\012\\173\\000\\000\\000\\000\\012\\173\\000\\000\\000\\000\\000\\000\\001\\029\\012\\173\\000\\000\\000\\000\\012\\173\\000\\000\\000\\000\\000\\000\\000\\000\\012\\173\\012\\173\\012\\173\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\173\\012\\173\\000\\000\\000\\000\\001\\029\\000\\000\\019\\130\\012\\173\\000\\000\\000\\000\\000\\000\\012\\173\\001\\029\\000\\000\\012\\173\\000\\000\\000\\000\\001\\029\\000\\000\\000\\000\\000\\000\\012\\173\\012\\173\\012\\173\\000\\000\\012\\173\\012\\173\\001\\029\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\249\\012\\173\\000\\006\\012\\173\\012\\173\\006\\249\\002\\186\\002\\190\\012\\173\\002\\234\\002\\138\\000\\000\\000\\000\\012\\173\\000\\000\\002\\246\\000\\000\\012\\173\\001\\029\\012\\173\\012\\173\\000\\000\\003\\254\\000\\000\\006\\249\\001\\210\\000\\000\\001\\029\\000\\000\\002\\250\\000\\000\\003r\\003v\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\254\\000\\000\\003\\150\\000\\000\\000\\000\\000\\000\\003\\202\\003\\206\\006\\249\\003\\210\\003\\222\\003\\234\\003\\242\\007\\030\\000\\000\\000\\000\\006\\249\\002\\178\\000\\000\\000\\000\\003\\230\\006\\249\\006\\249\\000\\238\\bz\\b~\\b\\138\\b\\158\\000\\000\\005v\\006\\249\\006\\249\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\018\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\030\\t6\\t\\130\\005\\130\\005\\134\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\249\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\000\\000\\000\\000\\006\\249\\002\\186\\002\\190\\000\\000\\002\\234\\002\\138\\000\\000\\000\\000\\005\\138\\b\\146\\002\\246\\000\\000\\000\\000\\b\\170\\004r\\t\\150\\024z\\014\\170\\000\\000\\000\\000\\001\\210\\000\\000\\000\\000\\000\\000\\002\\250\\000\\000\\003r\\003v\\000\\000\\000\\000\\000\\000\\r5\\000\\000\\002\\254\\000\\000\\003\\150\\r5\\000\\000\\000\\000\\003\\202\\003\\206\\000\\000\\003\\210\\003\\222\\003\\234\\003\\242\\007\\030\\000\\000\\000\\000\\000\\000\\002\\178\\000\\000\\000\\000\\003\\230\\000\\000\\r5\\000\\000\\bz\\b~\\b\\138\\b\\158\\000\\000\\005v\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005I\\r)\\t\\018\\000\\000\\000\\000\\000\\000\\000\\000\\r5\\000\\000\\t\\030\\t6\\t\\130\\005\\130\\005\\134\\000\\000\\r5\\000\\000\\000\\000\\000\\000\\005I\\r5\\r5\\000\\238\\005I\\000\\000\\000\\000\\003\\029\\003\\029\\000\\000\\r5\\r5\\003\\029\\000\\000\\000\\000\\003\\029\\000\\000\\005\\138\\b\\146\\000\\000\\000\\000\\000\\000\\b\\170\\004r\\t\\150\\003\\029\\003\\029\\003\\029\\000\\000\\003\\029\\003\\029\\003\\029\\000\\000\\000\\000\\000\\000\\000\\000\\r5\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\029\\000\\000\\r5\\000\\000\\000\\000\\000\\000\\003\\029\\004\\130\\000\\000\\000\\000\\003\\029\\000\\000\\000\\000\\000\\000\\000\\000\\003\\029\\r)\\r)\\003\\029\\000\\000\\000\\000\\000\\000\\000\\000\\003\\029\\003\\029\\003\\029\\000\\000\\000\\000\\000\\000\\005I\\000\\000\\000\\000\\003\\029\\003\\029\\000\\000\\r)\\000\\000\\r)\\000\\000\\003\\029\\000\\000\\000\\000\\000\\000\\003\\029\\005I\\000\\000\\003\\029\\005I\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\029\\003\\029\\003\\029\\004\\149\\003\\029\\003\\029\\000\\000\\000\\000\\019\\146\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\029\\000\\000\\003\\029\\003\\029\\000\\000\\000\\000\\000\\000\\003\\029\\000\\000\\000\\000\\000\\000\\000\\000\\003\\029\\003n\\011\\r\\000\\000\\003\\029\\011\\r\\003\\029\\003\\029\\003\\014\\002\\190\\000\\000\\000\\000\\002\\138\\000\\000\\006\\238\\000\\000\\000\\000\\002\\246\\000\\000\\000\\000\\000\\000\\011\\r\\011\\r\\019\\190\\011\\r\\011\\r\\000\\000\\001\\210\\000\\000\\007\\014\\000\\000\\017\\178\\000\\000\\000\\000\\003\\018\\000\\000\\017\\202\\tB\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\011\\r\\019\\234\\003\\030\\000\\000\\000\\000\\003*\\001\\190\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\011\\r\\003\\250\\000\\000\\004\\002\\005j\\011F\\005v\\000\\000\\004\\149\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\020N\\005z\\001\\202\\001\\206\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\011\\r\\000\\000\\011\\r\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\210\\001\\250\\000\\000\\000\\000\\000\\000\\000\\000\\011\\r\\000\\000\\000\\000\\011\\r\\011\\r\\000\\000\\005\\138\\000\\000\\011\\r\\000\\000\\011\\r\\000\\000\\004r\\011\\t\\011\\r\\000\\000\\011\\t\\001\\246\\002\\170\\003\\014\\002\\190\\000\\000\\002\\166\\002\\138\\002\\178\\004\\030\\004*\\000\\000\\002\\246\\000\\000\\000\\000\\0046\\011\\t\\011\\t\\000\\000\\011\\t\\011\\t\\000\\000\\001\\210\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\000\\000\\000\\000\\004:\\000\\000\\000\\000\\026\\138\\000\\000\\000\\000\\000\\000\\000\\000\\011\\t\\000\\000\\003\\030\\000\\000\\000\\000\\006\\n\\001\\190\\000\\000\\000\\000\\000\\000\\000\\000\\026v\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\011\\t\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005z\\000\\000\\012\\141\\000\\000\\000\\000\\012\\141\\000\\000\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\011\\t\\000\\000\\011\\t\\012\\141\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\141\\000\\000\\001\\229\\001\\229\\000\\000\\011\\t\\000\\000\\001\\229\\011\\t\\011\\t\\001\\229\\005\\138\\012\\141\\011\\t\\000\\000\\011\\t\\000\\000\\004r\\012\\141\\011\\t\\001\\229\\001\\229\\001\\229\\000\\000\\001\\229\\001\\229\\001\\229\\012\\141\\000\\000\\000\\000\\012\\141\\000\\000\\000\\000\\000\\000\\000\\000\\012\\141\\000\\000\\000\\000\\001\\229\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\229\\001\\229\\000\\000\\000\\000\\001\\229\\000\\000\\000\\000\\012\\141\\000\\000\\001\\229\\000\\000\\012\\141\\001\\229\\000\\000\\000\\000\\000\\000\\000\\000\\001\\229\\001\\229\\001\\229\\000\\000\\012\\141\\012\\141\\000\\000\\000\\000\\012\\141\\001\\229\\001\\229\\000\\000\\000\\000\\000\\000\\028\\134\\000\\000\\001\\229\\004\\157\\000\\000\\000\\000\\001\\229\\000\\000\\022\\130\\001\\229\\000\\000\\012\\141\\000\\000\\000\\000\\000\\000\\000\\000\\001\\229\\001\\229\\001\\229\\000\\000\\001\\229\\001\\229\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003n\\000\\000\\000\\000\\001\\229\\000\\000\\001\\229\\001\\229\\003\\014\\002\\190\\000\\000\\001\\229\\002\\138\\000\\000\\006\\238\\000\\000\\001\\229\\002\\246\\000\\000\\000\\000\\004\\254\\000\\000\\001\\229\\022\\242\\000\\000\\000\\000\\000\\000\\001\\210\\000\\000\\007\\014\\000\\000\\017\\178\\000\\000\\000\\000\\003\\018\\000\\000\\017\\202\\tB\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\023\\150\\023\\166\\003\\030\\000\\000\\000\\000\\0116\\001\\190\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\n\\229\\003\\250\\000\\000\\004\\002\\000\\000\\011F\\005v\\000\\000\\004\\157\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\029\\000\\000\\024\\154\\005z\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\130\\005\\134\\000\\000\\000\\000\\011N\\005\\149\\005\\149\\000\\000\\000\\000\\000\\000\\005\\149\\000\\000\\000\\000\\005\\149\\000\\000\\000\\000\\000\\000\\000\\000\\n\\229\\000\\000\\000\\000\\n\\229\\n\\229\\005\\149\\005\\138\\005\\149\\000\\000\\005\\149\\n\\229\\005\\149\\004r\\000\\000\\n\\229\\004\\029\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\246\\000\\000\\005\\149\\002\\194\\000\\000\\000\\000\\000\\000\\000\\000\\005\\149\\005\\149\\000\\000\\000\\000\\000\\000\\028\\222\\005\\149\\000\\000\\000\\000\\005\\149\\000\\000\\003n\\005\\149\\000\\000\\000\\000\\000\\000\\000\\000\\005\\149\\005\\149\\005\\149\\000\\000\\000\\000\\000\\000\\003z\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\017N\\000\\000\\000\\000\\000\\000\\005\\149\\005\\149\\000\\000\\000\\000\\005\\149\\025\\026\\000\\000\\001\\006\\017\\178\\000\\000\\000\\000\\000\\000\\000\\000\\017\\202\\005\\149\\005\\149\\005\\149\\000\\000\\005\\149\\005\\149\\000\\000\\000\\000\\000\\000\\001\\n\\007\\246\\000\\000\\000\\000\\002\\150\\000\\000\\017\\210\\000\\000\\005\\149\\000\\000\\028\\142\\005\\149\\005\\149\\001\\014\\001\\018\\001\\022\\001\\026\\001\\030\\001\\\"\\000\\000\\017\\230\\018\\\"\\000\\000\\005\\149\\004\\173\\000\\000\\001&\\000\\000\\001.\\0012\\000\\000\\000\\000\\000\\000\\000\\000\\0016\\000\\000\\000\\000\\001:\\000\\000\\000\\000\\000\\000\\022Z\\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>\\001B\\001F\\001J\\001N\\000\\000\\003e\\003e\\001R\\000\\000\\000\\000\\003e\\001V\\000\\000\\003e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001Z\\000\\000\\003e\\003e\\000\\000\\003e\\001^\\003e\\000\\000\\003e\\003e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\154\\027\\162\\000\\000\\000\\000\\003e\\003e\\003e\\001\\158\\003e\\001\\162\\003e\\003e\\003e\\001\\166\\000\\000\\001\\170\\001\\174\\005\\029\\000\\000\\000\\000\\003e\\000\\000\\003e\\003e\\000\\000\\000\\000\\000\\000\\000\\000\\003e\\003e\\003e\\000\\000\\000\\000\\000\\000\\005!\\000\\000\\000\\000\\003e\\000\\000\\000\\000\\003e\\000\\000\\000\\000\\000\\000\\003e\\003e\\003e\\003e\\003e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003e\\003e\\003e\\003e\\003e\\003e\\000\\000\\003e\\000\\000\\000\\000\\005\\029\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003e\\003e\\003e\\000\\000\\003e\\003e\\005\\137\\005\\137\\000\\000\\000\\000\\005!\\005\\137\\000\\000\\000\\000\\005\\137\\003e\\000\\000\\003e\\003e\\000\\000\\000\\000\\003e\\000\\000\\000\\000\\005\\137\\000\\000\\005\\137\\000\\000\\005\\137\\000\\000\\005\\137\\000\\000\\003e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\137\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\137\\005\\137\\000\\000\\000\\000\\000\\000\\000\\000\\b>\\000\\000\\000\\000\\005\\137\\000\\000\\000\\000\\005\\137\\000\\000\\000\\000\\000\\000\\000\\000\\005\\137\\005\\137\\000\\238\\000\\000\\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\\137\\005\\137\\000\\000\\000\\000\\005\\137\\000\\000\\t\\029\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\137\\005\\137\\005\\137\\000\\000\\005\\137\\005\\137\\000\\000\\000\\000\\nR\\000\\000\\000\\000\\012z\\t\\029\\000\\000\\t\\029\\t\\029\\000\\000\\005\\137\\000\\000\\000\\000\\005\\137\\005\\137\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\000\\000\\001\\202\\002\\134\\000\\000\\005\\137\\002\\138\\000\\000\\000\\000\\n\\186\\n\\194\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\202\\000\\000\\000\\000\\001\\210\\001\\250\\001\\230\\002\\142\\000\\000\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\001\\242\\001\\006\\000\\000\\000\\000\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\000\\000\\000\\000\\000\\000\\000\\000\\002\\146\\002\\154\\000\\000\\n\\242\\001\\n\\002\\166\\000\\000\\002\\178\\004\\030\\004*\\000\\000\\000\\000\\n\\250\\000\\000\\021\\178\\000\\000\\021\\182\\001\\014\\001\\018\\001\\022\\001\\026\\001\\030\\001\\\"\\000\\000\\000\\000\\000\\000\\011\\026\\000\\000\\011\\\"\\n\\226\\001&\\004:\\001.\\0012\\t\\029\\011\\002\\000\\000\\000\\000\\0016\\000\\000\\005\\134\\001:\\000\\000\\011\\n\\011\\018\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\021\\194\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001>\\001B\\001F\\001J\\001N\\000\\000\\b\\153\\b\\153\\001R\\021\\198\\000\\000\\b\\153\\001V\\000\\000\\b\\153\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001Z\\000\\000\\000\\000\\b\\153\\000\\000\\b\\153\\001^\\b\\153\\000\\000\\b\\153\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\154\\027\\190\\000\\000\\000\\000\\000\\000\\b\\153\\000\\000\\001\\158\\000\\000\\001\\162\\000\\000\\b\\153\\b\\153\\001\\166\\000\\000\\001\\170\\001\\174\\000\\000\\000\\000\\000\\000\\b\\153\\000\\000\\000\\000\\b\\153\\000\\000\\000\\000\\000\\000\\000\\000\\b\\153\\b\\153\\b\\153\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\153\\000\\000\\000\\000\\000\\000\\b\\153\\ru\\ru\\000\\000\\000\\000\\000\\000\\ru\\000\\000\\000\\000\\ru\\b\\153\\b\\153\\b\\153\\000\\000\\b\\153\\b\\153\\000\\000\\000\\000\\000\\000\\ru\\000\\000\\ru\\000\\000\\ru\\b\\153\\ru\\000\\000\\b\\153\\001\\202\\001\\206\\000\\000\\b\\153\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\ru\\000\\000\\000\\000\\004\\254\\000\\000\\b\\153\\ru\\ru\\ry\\ry\\001\\210\\001\\250\\004B\\ry\\000\\000\\ru\\ry\\000\\000\\ru\\000\\000\\000\\000\\000\\000\\000\\000\\ru\\ru\\ru\\ry\\000\\000\\ry\\000\\000\\ry\\000\\000\\ry\\001\\246\\002\\162\\000\\000\\000\\000\\000\\000\\002\\166\\ru\\002\\178\\004\\030\\004*\\ru\\ry\\000\\000\\000\\000\\0046\\000\\000\\015\\218\\ry\\ry\\000\\000\\ru\\ru\\ru\\004B\\ru\\ru\\ry\\000\\000\\000\\000\\ry\\004R\\004:\\000\\000\\000\\000\\ry\\ry\\ry\\ru\\000\\000\\000\\000\\000\\000\\ru\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\ry\\000\\000\\ru\\000\\000\\ry\\001\\213\\000\\000\\000\\000\\000\\000\\000\\000\\001\\213\\000\\000\\001\\206\\001\\213\\ry\\ry\\ry\\000\\000\\ry\\ry\\000\\000\\b\\249\\000\\000\\001\\213\\004R\\000\\000\\000\\000\\001\\213\\004q\\001\\213\\000\\000\\ry\\000\\000\\004q\\000\\000\\ry\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\213\\000\\000\\000\\000\\000\\000\\000\\000\\ry\\001\\213\\001\\213\\000\\000\\000\\000\\000\\000\\004q\\000\\000\\002\\162\\000\\000\\001\\213\\000\\000\\000\\000\\001\\213\\000\\000\\000\\000\\000\\000\\000\\000\\001\\213\\001\\213\\001\\213\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\213\\001\\213\\004q\\000\\000\\004\\154\\003I\\000\\000\\004q\\002\\226\\000\\000\\003I\\000\\000\\001\\206\\003I\\001\\213\\001\\213\\004q\\004q\\001\\213\\001\\213\\000\\000\\b\\245\\000\\000\\003I\\000\\000\\000\\000\\000\\000\\003I\\001\\213\\003I\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\213\\000\\000\\000\\000\\000\\000\\000\\000\\001\\213\\003I\\004q\\000\\000\\000\\000\\000\\000\\001\\213\\003I\\001\\209\\000\\000\\000\\000\\004q\\000\\000\\000\\000\\002\\162\\000\\000\\003I\\000\\000\\000\\000\\003I\\000\\000\\000\\000\\000\\000\\000\\000\\003I\\003I\\003I\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003I\\003I\\000\\000\\000\\000\\004\\154\\003E\\000\\000\\000\\000\\000\\000\\000\\000\\003E\\000\\000\\001\\206\\003E\\003I\\003I\\000\\000\\000\\000\\003I\\003I\\000\\000\\b\\245\\000\\000\\003E\\000\\000\\000\\000\\000\\000\\003E\\003I\\003E\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003I\\000\\000\\000\\000\\000\\000\\000\\000\\003I\\003E\\000\\000\\000\\000\\000\\000\\000\\000\\003I\\003E\\001\\209\\000\\000\\000\\189\\000\\000\\000\\000\\000\\000\\002\\162\\000\\189\\003E\\000\\000\\000\\189\\003E\\000\\000\\000\\000\\000\\000\\000\\000\\003E\\003E\\003E\\000\\000\\000\\189\\000\\000\\000\\189\\000\\000\\000\\189\\000\\000\\000\\189\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003E\\003E\\000\\000\\000\\000\\004\\154\\000\\000\\000\\189\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\189\\000\\000\\003E\\003E\\000\\189\\000\\000\\003E\\003E\\000\\000\\000\\189\\000\\000\\000\\000\\000\\189\\000\\000\\000\\000\\000\\000\\003E\\000\\189\\000\\189\\000\\238\\000\\000\\000\\000\\000\\000\\003E\\000\\000\\000\\000\\000\\189\\000\\189\\003E\\000\\000\\000\\000\\000\\000\\000\\000\\000\\189\\003E\\000\\000\\001\\001\\000\\189\\000\\000\\000\\000\\000\\000\\001\\001\\000\\000\\000\\000\\001\\001\\000\\000\\000\\000\\000\\189\\000\\189\\000\\000\\000\\000\\000\\189\\000\\189\\000\\000\\001\\001\\000\\000\\001\\001\\000\\000\\001\\001\\000\\000\\001\\001\\000\\189\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\189\\000\\189\\000\\000\\000\\000\\000\\000\\001\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\189\\001\\001\\000\\189\\000\\000\\000\\000\\001\\001\\000\\000\\000\\000\\000\\000\\000\\000\\001\\001\\000\\000\\000\\000\\001\\001\\000\\000\\000\\000\\000\\000\\000\\000\\001\\001\\001\\001\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\001\\001\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\001\\000\\000\\000\\000\\000\\197\\001\\001\\000\\000\\000\\000\\000\\000\\000\\197\\000\\000\\000\\000\\000\\197\\000\\000\\000\\000\\001\\001\\001\\001\\000\\000\\000\\000\\001\\001\\001\\001\\000\\000\\000\\197\\000\\000\\000\\197\\000\\000\\000\\197\\000\\000\\000\\197\\001\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\001\\001\\001\\000\\000\\000\\000\\000\\000\\000\\197\\000\\000\\000\\000\\000\\000\\000\\000\\001\\001\\000\\197\\001\\001\\000\\000\\000\\000\\000\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\197\\000\\000\\000\\000\\000\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\197\\000\\197\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\197\\000\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\197\\000\\000\\000\\000\\000\\193\\000\\197\\000\\000\\000\\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\197\\000\\197\\000\\000\\000\\000\\000\\197\\000\\197\\000\\000\\000\\193\\000\\000\\000\\193\\000\\000\\000\\193\\000\\000\\000\\193\\000\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\197\\000\\197\\000\\000\\000\\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\000\\000\\000\\000\\197\\000\\193\\000\\197\\000\\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\193\\000\\000\\000\\000\\000\\000\\000\\000\\000\\193\\000\\193\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\193\\000\\193\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\193\\000\\000\\000\\000\\001\\177\\000\\193\\000\\000\\000\\000\\000\\000\\001\\177\\000\\000\\000\\000\\001\\177\\000\\000\\000\\000\\000\\193\\000\\193\\000\\000\\000\\000\\000\\193\\000\\193\\000\\000\\001\\177\\000\\000\\000\\000\\000\\000\\001\\177\\000\\000\\001\\177\\000\\193\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\193\\000\\193\\000\\000\\000\\000\\000\\000\\001\\177\\001\\177\\000\\000\\000\\000\\000\\000\\000\\193\\001\\177\\000\\193\\000\\000\\000\\000\\000\\000\\000\\000\\005\\029\\000\\000\\000\\000\\001\\177\\000\\000\\000\\000\\001\\177\\000\\000\\000\\000\\000\\000\\000\\000\\001\\177\\001\\177\\001\\177\\000\\000\\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\\177\\000\\000\\001\\202\\001\\206\\001\\177\\rq\\rq\\000\\000\\000\\000\\000\\000\\rq\\000\\000\\000\\000\\rq\\001\\177\\001\\177\\000\\000\\000\\000\\001\\177\\001\\177\\000\\000\\001\\210\\001\\214\\rq\\005\\029\\rq\\000\\000\\rq\\001\\177\\rq\\000\\000\\000\\000\\000\\000\\000\\000\\001\\177\\001\\177\\000\\000\\000\\000\\000\\000\\000\\000\\001\\177\\rq\\000\\000\\000\\000\\001\\246\\002\\162\\001\\177\\rq\\rq\\002\\166\\000\\000\\002\\178\\004\\030\\004*\\000\\000\\000\\000\\rq\\000\\000\\0046\\rq\\015\\218\\000\\000\\000\\000\\000\\000\\rq\\rq\\rq\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004:\\000\\000\\000\\000\\000\\000\\000\\000\\rq\\000\\000\\000\\000\\000\\000\\rq\\rm\\rm\\000\\000\\000\\000\\000\\000\\rm\\000\\000\\000\\000\\rm\\rq\\rq\\rq\\000\\000\\rq\\rq\\000\\000\\000\\000\\000\\000\\rm\\000\\000\\rm\\000\\000\\rm\\000\\000\\rm\\000\\000\\rq\\000\\000\\000\\000\\000\\000\\rq\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\rm\\000\\000\\000\\000\\004\\254\\000\\000\\rq\\rm\\rm\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004y\\rm\\000\\000\\000\\000\\rm\\000\\246\\000\\000\\000\\000\\002\\026\\rm\\rm\\rm\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\018b\\000\\000\\000\\000\\000\\000\\004y\\000\\000\\003n\\rm\\000\\000\\b\\157\\b\\157\\rm\\000\\000\\000\\000\\b\\157\\000\\000\\000\\000\\b\\157\\018f\\000\\000\\000\\000\\rm\\rm\\rm\\018\\142\\rm\\rm\\b\\157\\000\\000\\b\\157\\000\\000\\b\\157\\000\\000\\b\\157\\000\\000\\007\\146\\017\\178\\000\\000\\rm\\000\\000\\000\\000\\017\\202\\rm\\000\\000\\000\\000\\b\\157\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\157\\b\\157\\rm\\000\\000\\000\\000\\000\\000\\019&\\000\\000\\000\\000\\b\\157\\000\\000\\000\\000\\b\\157\\000\\000\\000\\000\\000\\000\\000\\000\\b\\157\\b\\157\\000\\238\\017\\230\\019:\\000\\000\\000\\000\\004y\\004y\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\157\\000\\000\\000\\000\\000\\000\\b\\157\\000\\000\\007\\r\\000\\000\\019J\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\157\\b\\157\\b\\157\\000\\000\\b\\157\\b\\157\\000\\000\\000\\000\\nR\\000\\000\\000\\000\\007\\r\\000\\000\\000\\000\\b\\157\\007\\r\\000\\000\\b\\157\\000\\000\\000\\000\\000\\000\\b\\157\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\157\\001\\209\\000\\000\\000\\000\\n\\186\\n\\194\\001\\209\\000\\000\\001\\206\\001\\209\\000\\000\\000\\000\\000\\000\\n\\202\\000\\000\\000\\000\\000\\000\\b\\245\\000\\000\\001\\209\\000\\000\\000\\238\\000\\000\\001\\209\\000\\000\\001\\209\\000\\000\\000\\000\\000\\000\\000\\000\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\000\\000\\000\\000\\001\\209\\000\\000\\000\\000\\000\\000\\007\\r\\n\\242\\001\\209\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\162\\n\\250\\001\\209\\000\\000\\000\\000\\001\\209\\000\\000\\000\\000\\000\\000\\000\\000\\001\\209\\001\\209\\001\\209\\000\\000\\000\\000\\011\\026\\000\\000\\011\\\"\\n\\226\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\011\\002\\000\\000\\001\\209\\001\\209\\000\\000\\000\\000\\004\\154\\000\\000\\011\\n\\011\\018\\000\\000\\000\\000\\000\\000\\017\\002\\000\\000\\000\\000\\001\\209\\001\\209\\000\\000\\000\\000\\001\\209\\001\\209\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\nR\\001\\209\\000\\000\\000\\000\\017\\006\\000\\000\\000\\000\\000\\000\\001\\209\\000\\000\\000\\000\\000\\000\\000\\000\\001\\209\\n\\138\\n\\162\\n\\170\\n\\146\\n\\178\\001\\209\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006V\\000\\000\\000\\000\\n\\186\\n\\194\\000\\246\\001\\202\\001\\206\\002\\026\\000\\000\\000\\000\\000\\000\\n\\202\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\018b\\000\\000\\000\\238\\000\\000\\004y\\000\\000\\003n\\001\\210\\001\\250\\001\\230\\000\\000\\nZ\\n\\154\\n\\210\\n\\218\\n\\234\\000\\000\\001\\242\\018f\\000\\000\\000\\000\\000\\000\\000\\000\\n\\242\\018\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\246\\002\\154\\n\\250\\000\\000\\000\\000\\002\\166\\017\\178\\002\\178\\004\\030\\004*\\000\\000\\017\\202\\000\\000\\000\\000\\0046\\000\\000\\011\\026\\017\\n\\011\\\"\\n\\226\\017\\026\\000\\000\\000\\000\\000\\000\\000\\000\\011\\002\\000\\000\\019&\\000\\000\\000\\000\\000\\000\\004:\\000\\000\\011\\n\\011\\018\\005\\193\\005\\193\\000\\000\\000\\000\\000\\000\\005\\193\\017\\230\\019:\\005\\193\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\193\\000\\000\\005\\193\\000\\000\\005\\193\\000\\000\\005\\193\\000\\000\\000\\000\\019J\\000\\000\\000\\000\\000\\000\\000\\000\\004n\\000\\000\\004r\\000\\000\\005\\193\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\193\\005\\193\\005\\189\\007f\\000\\000\\000\\000\\b>\\005\\189\\000\\000\\005\\193\\005\\189\\000\\000\\005\\193\\000\\000\\000\\000\\000\\000\\000\\000\\005\\193\\005\\193\\000\\238\\005\\189\\000\\000\\005\\189\\000\\000\\005\\189\\000\\000\\005\\189\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\193\\000\\000\\000\\000\\000\\000\\005\\193\\005\\189\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\189\\007\\226\\000\\000\\005\\193\\005\\193\\005\\193\\000\\000\\005\\193\\005\\193\\005\\189\\000\\000\\000\\000\\005\\189\\000\\000\\000\\000\\000\\000\\000\\000\\005\\189\\005\\189\\000\\238\\005\\193\\000\\000\\000\\000\\000\\000\\005\\193\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\189\\000\\000\\005\\193\\000\\000\\005\\189\\r}\\r}\\000\\000\\000\\000\\000\\000\\r}\\000\\000\\000\\000\\r}\\005\\189\\005\\189\\005\\189\\000\\000\\005\\189\\005\\189\\000\\000\\000\\000\\000\\000\\r}\\000\\000\\r}\\t\\218\\r}\\000\\000\\r}\\000\\000\\005\\189\\001\\202\\001\\206\\011z\\005\\189\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\r}\\000\\000\\000\\000\\000\\000\\000\\000\\005\\189\\r}\\r}\\r\\129\\r\\129\\001\\210\\001\\214\\001\\230\\r\\129\\000\\000\\r}\\r\\129\\000\\000\\r}\\000\\000\\001\\242\\000\\000\\000\\000\\r}\\r}\\000\\238\\r\\129\\000\\000\\r\\129\\000\\000\\r\\129\\000\\000\\r\\129\\001\\246\\002\\154\\000\\000\\000\\000\\000\\000\\002\\166\\r}\\002\\178\\004\\030\\004*\\r}\\r\\129\\000\\000\\000\\000\\0046\\000\\000\\000\\000\\r\\129\\007\\226\\000\\000\\r}\\r}\\r}\\000\\000\\r}\\r}\\r\\129\\000\\000\\000\\000\\r\\129\\000\\000\\004:\\000\\000\\000\\000\\r\\129\\r\\129\\000\\238\\r}\\000\\000\\000\\000\\000\\000\\r}\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\r\\129\\000\\000\\r}\\000\\000\\r\\129\\005\\213\\007f\\000\\000\\000\\000\\000\\000\\005\\213\\000\\000\\000\\000\\005\\213\\r\\129\\r\\129\\r\\129\\000\\000\\r\\129\\r\\129\\000\\000\\000\\000\\000\\000\\005\\213\\000\\000\\005\\213\\000\\000\\005\\213\\000\\000\\005\\213\\000\\000\\r\\129\\006\\229\\006\\229\\000\\000\\r\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\213\\000\\000\\000\\000\\000\\000\\000\\000\\r\\129\\005\\213\\007\\226\\005\\217\\005\\217\\006\\229\\006\\229\\006\\229\\005\\217\\000\\000\\005\\213\\005\\217\\000\\000\\005\\213\\000\\000\\006\\229\\000\\000\\000\\000\\005\\213\\005\\213\\000\\238\\005\\217\\000\\000\\005\\217\\000\\000\\005\\217\\000\\000\\005\\217\\006\\229\\006\\229\\000\\000\\000\\000\\000\\000\\006\\229\\005\\213\\006\\229\\006\\229\\006\\229\\005\\213\\005\\217\\000\\000\\000\\000\\006\\229\\000\\000\\000\\000\\005\\217\\005\\217\\000\\000\\005\\213\\005\\213\\005\\213\\000\\000\\005\\213\\005\\213\\005\\217\\000\\000\\000\\000\\005\\217\\000\\000\\006\\229\\000\\000\\000\\000\\005\\217\\005\\217\\005\\217\\005\\213\\000\\000\\000\\000\\000\\000\\005\\213\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\217\\000\\000\\005\\213\\000\\000\\005\\217\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\217\\005\\217\\005\\217\\000\\000\\005\\217\\005\\217\\000\\246\\003\\014\\002\\190\\002\\194\\004\\230\\002\\138\\000\\000\\006\\238\\000\\000\\000\\000\\002\\246\\005\\217\\000\\000\\004\\165\\000\\000\\005\\217\\000\\000\\000\\000\\000\\000\\003n\\001\\210\\000\\000\\007\\014\\000\\000\\000\\000\\000\\000\\b\\n\\003\\018\\000\\000\\000\\000\\tB\\003z\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\017N\\000\\000\\000\\000\\003\\030\\000\\000\\000\\000\\0116\\001\\190\\000\\000\\025\\026\\000\\000\\000\\000\\017\\178\\002\\178\\000\\000\\000\\000\\003\\246\\017\\202\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\000\\000\\011F\\005v\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\017\\210\\003A\\000\\000\\000\\000\\005z\\000\\000\\003A\\000\\000\\001\\206\\003A\\000\\000\\000\\000\\005\\130\\005\\134\\017\\230\\018\\\"\\011N\\000\\000\\000\\000\\003A\\000\\000\\000\\000\\000\\000\\003A\\000\\000\\003A\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t\\202\\000\\000\\000\\000\\t\\214\\022Z\\005\\138\\003A\\000\\000\\000\\000\\000\\000\\000\\000\\004r\\003A\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\162\\000\\000\\003A\\000\\000\\000\\000\\003A\\000\\000\\000\\000\\000\\000\\000\\000\\003A\\003A\\003A\\000\\000\\003=\\000\\000\\000\\000\\000\\000\\000\\000\\003=\\000\\000\\001\\206\\003=\\000\\000\\000\\000\\000\\000\\003A\\003A\\000\\000\\000\\000\\004\\154\\000\\000\\003=\\000\\000\\000\\000\\000\\000\\003=\\000\\000\\003=\\000\\000\\003A\\003A\\000\\000\\000\\000\\003A\\003A\\000\\000\\000\\000\\000\\000\\000\\000\\003=\\000\\000\\000\\000\\000\\000\\003A\\000\\000\\003=\\000\\000\\000\\000\\001U\\000\\000\\003A\\000\\000\\002\\162\\001U\\003=\\003A\\001U\\003=\\000\\000\\000\\000\\000\\000\\003A\\003=\\003=\\003=\\000\\000\\001U\\000\\000\\001U\\000\\000\\001U\\000\\000\\001U\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003=\\003=\\000\\000\\000\\000\\004\\154\\000\\000\\001U\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001U\\000\\000\\003=\\003=\\001U\\000\\000\\003=\\003=\\000\\000\\001U\\000\\000\\000\\000\\001U\\000\\000\\000\\000\\000\\000\\003=\\001U\\001U\\000\\238\\000\\000\\001Q\\000\\000\\003=\\000\\000\\000\\000\\001Q\\001U\\003=\\001Q\\000\\000\\000\\000\\000\\000\\001U\\003=\\000\\000\\000\\000\\001U\\000\\000\\001Q\\000\\000\\001Q\\000\\000\\001Q\\000\\000\\001Q\\000\\000\\001U\\001U\\001U\\000\\000\\001U\\001U\\000\\000\\000\\000\\000\\000\\000\\000\\001Q\\000\\000\\000\\000\\000\\000\\001U\\000\\000\\001Q\\000\\000\\000\\000\\000\\000\\001Q\\001U\\000\\000\\000\\000\\000\\000\\001Q\\000\\000\\000\\000\\001Q\\000\\000\\000\\000\\000\\000\\001U\\001Q\\001Q\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001Q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001Q\\000\\000\\000\\000\\000\\000\\001Q\\001\\141\\000\\000\\000\\000\\000\\000\\000\\000\\001\\141\\000\\000\\012\\205\\001\\141\\001Q\\001Q\\001Q\\000\\000\\001Q\\001Q\\000\\000\\012\\205\\000\\000\\001\\141\\000\\000\\001\\141\\000\\000\\001\\141\\001Q\\001\\141\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001Q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\141\\000\\000\\000\\000\\000\\000\\000\\000\\001Q\\001\\141\\012\\205\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\205\\000\\000\\000\\000\\000\\000\\000\\000\\001\\141\\000\\000\\000\\000\\000\\000\\000\\000\\001\\141\\001\\141\\001\\141\\000\\000\\000\\000\\001A\\000\\000\\000\\000\\000\\000\\000\\000\\001A\\000\\000\\000\\165\\001A\\000\\000\\000\\000\\001\\141\\000\\000\\000\\000\\000\\000\\012\\205\\000\\165\\000\\000\\001A\\000\\000\\001A\\000\\000\\001A\\000\\000\\001A\\001\\141\\001\\141\\001\\141\\000\\000\\001\\141\\001\\141\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001A\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001A\\000\\165\\000\\000\\000\\000\\001\\141\\000\\000\\000\\000\\000\\165\\000\\000\\000\\000\\000\\000\\000\\000\\001A\\000\\000\\000\\000\\001\\141\\000\\000\\001A\\001A\\001A\\000\\000\\001\\221\\000\\000\\000\\000\\000\\000\\000\\000\\001\\221\\000\\000\\015\\190\\001\\221\\000\\000\\002\\138\\000\\000\\001A\\000\\000\\000\\000\\000\\000\\000\\165\\000\\000\\001\\221\\000\\000\\000\\000\\000\\000\\001\\221\\000\\000\\001\\221\\000\\000\\001A\\001A\\001A\\000\\000\\001A\\001A\\000\\000\\000\\000\\000\\000\\000\\000\\001\\221\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\221\\000\\000\\000\\000\\000\\000\\000\\000\\001A\\015\\194\\000\\000\\000\\000\\001\\221\\000\\000\\000\\000\\001\\221\\000\\000\\000\\000\\000\\000\\001A\\001\\221\\001\\221\\000\\000\\015\\206\\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\\221\\003\\014\\002\\190\\000\\000\\001\\221\\002\\138\\000\\000\\006\\238\\000\\000\\000\\000\\002\\246\\000\\000\\000\\000\\005\\134\\001\\221\\001\\221\\000\\000\\000\\000\\001\\221\\001\\221\\001\\210\\000\\000\\007\\014\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\001\\221\\000\\000\\tB\\000\\000\\000\\000\\000\\000\\004q\\001\\221\\000\\000\\000\\000\\t~\\004q\\003\\030\\000\\000\\004q\\r\\226\\001\\190\\000\\000\\001\\221\\000\\000\\000\\000\\000\\000\\002\\178\\000\\000\\004q\\003\\246\\000\\000\\000\\000\\004q\\003\\250\\004q\\004\\002\\000\\000\\011F\\005v\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004q\\000\\000\\000\\000\\000\\000\\005z\\000\\000\\004q\\000\\000\\000\\000\\000\\000\\004q\\000\\000\\005\\130\\005\\134\\000\\000\\004q\\000\\000\\000\\000\\004q\\000\\000\\000\\000\\000\\000\\000\\000\\004q\\002\\226\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004q\\004q\\r\\242\\000\\000\\005\\138\\000\\000\\000\\000\\004q\\004q\\b)\\004r\\004q\\000\\000\\000\\000\\b)\\000\\000\\000\\000\\b)\\000\\000\\000\\000\\000\\000\\004q\\004q\\000\\000\\000\\000\\004q\\004q\\b)\\000\\000\\000\\000\\000\\000\\b)\\000\\000\\b)\\000\\000\\004q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004q\\000\\000\\000\\000\\b)\\000\\000\\025\\242\\000\\000\\000\\000\\000\\000\\b)\\000\\000\\004q\\000\\000\\b)\\000\\000\\000\\000\\000\\000\\000\\000\\b)\\000\\000\\000\\000\\b)\\000\\000\\000\\000\\000\\000\\000\\000\\b)\\b)\\000\\238\\b%\\000\\000\\000\\000\\000\\000\\000\\000\\b%\\b)\\b)\\b%\\000\\000\\000\\000\\000\\000\\000\\000\\b)\\000\\000\\000\\000\\000\\000\\b)\\b%\\000\\000\\000\\000\\000\\000\\b%\\000\\000\\b%\\000\\000\\000\\000\\b)\\b)\\b)\\000\\000\\b)\\b)\\000\\000\\000\\000\\000\\000\\b%\\000\\000\\000\\000\\000\\000\\000\\000\\b)\\b%\\000\\000\\000\\000\\000\\000\\b%\\000\\000\\b)\\000\\000\\000\\000\\b%\\000\\000\\000\\000\\b%\\000\\000\\000\\000\\000\\000\\000\\000\\b%\\b%\\000\\238\\0035\\000\\000\\000\\000\\000\\000\\000\\000\\0035\\b%\\b%\\0035\\000\\000\\000\\000\\000\\000\\000\\000\\b%\\000\\000\\000\\000\\000\\000\\b%\\0035\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\0035\\000\\000\\000\\000\\b%\\b%\\b%\\000\\000\\b%\\b%\\000\\000\\000\\000\\000\\000\\0035\\015\\214\\000\\000\\000\\000\\000\\000\\b%\\0035\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b%\\000\\000\\000\\000\\0035\\000\\000\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\000\\000\\0035\\0035\\0035\\003\\014\\002\\190\\000\\000\\000\\000\\002\\138\\000\\000\\006\\238\\000\\000\\000\\000\\002\\246\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\001\\210\\000\\000\\007\\014\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\0035\\0035\\tB\\000\\000\\0035\\0035\\000\\000\\000\\000\\000\\000\\000\\000\\024\\002\\000\\000\\003\\030\\000\\000\\0035\\003*\\001\\190\\000\\000\\000\\000\\000\\000\\0166\\0035\\002\\178\\000\\000\\000\\000\\003\\246\\0035\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\0035\\011F\\005v\\000\\000\\000\\000\\000\\000\\003\\014\\002\\190\\000\\000\\000\\000\\002\\138\\000\\000\\006\\238\\000\\000\\005z\\002\\246\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\130\\005\\134\\000\\000\\001\\210\\022r\\007\\014\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\000\\000\\000\\000\\tB\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\024\\206\\003\\030\\005\\138\\000\\000\\0116\\001\\190\\000\\000\\000\\000\\004r\\000\\000\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\000\\000\\011F\\005v\\000\\000\\000\\000\\000\\000\\003\\014\\002\\190\\000\\000\\000\\000\\002\\138\\000\\000\\006\\238\\000\\000\\005z\\002\\246\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\130\\005\\134\\000\\000\\001\\210\\011N\\007\\014\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\000\\000\\000\\000\\tB\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\023\\n\\003\\030\\005\\138\\000\\000\\0116\\001\\190\\000\\000\\000\\000\\004r\\000\\000\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\005\\194\\011F\\005v\\000\\000\\000\\000\\000\\000\\003\\014\\002\\190\\000\\000\\000\\000\\002\\138\\000\\000\\000\\000\\000\\000\\005z\\002\\246\\000\\000\\000\\000\\000\\000\\000\\000\\005\\198\\000\\000\\005\\130\\005\\134\\000\\000\\001\\210\\011N\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\023j\\003\\030\\005\\138\\000\\000\\003*\\001\\190\\000\\000\\000\\000\\004r\\000\\000\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\000\\000\\000\\000\\t9\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\014\\002\\190\\000\\000\\005z\\002\\138\\000\\000\\000\\000\\000\\000\\000\\000\\002\\246\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\000\\000\\t9\\000\\000\\000\\000\\001\\210\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\134\\000\\000\\000\\000\\005\\138\\004Y\\004Y\\000\\000\\003\\030\\004Y\\004r\\003*\\001\\190\\000\\000\\004Y\\000\\000\\000\\000\\000\\000\\002\\178\\000\\000\\004Y\\003\\246\\000\\000\\000\\000\\004Y\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\004Y\\023\\186\\000\\000\\000\\000\\023\\210\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005z\\000\\000\\004Y\\000\\000\\000\\000\\004Y\\004Y\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\004Y\\000\\000\\000\\000\\004Y\\000\\000\\000\\000\\000\\238\\004Y\\000\\000\\004Y\\004Y\\000\\000\\004Y\\0035\\000\\000\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\005\\138\\0035\\t9\\0035\\004Y\\000\\000\\004r\\000\\000\\0035\\000\\000\\000\\000\\0035\\004Y\\004Y\\000\\000\\0035\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\0035\\000\\000\\0035\\015\\214\\000\\000\\000\\000\\000\\000\\000\\000\\0035\\004Y\\000\\000\\000\\000\\0035\\015\\214\\000\\000\\004Y\\000\\000\\0035\\0035\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\000\\000\\0035\\0035\\0035\\000\\000\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\000\\000\\0035\\0035\\0035\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\0035\\0035\\025\\250\\000\\000\\0035\\0035\\000\\000\\000\\000\\000\\000\\000\\000\\0035\\0035\\026*\\000\\000\\0035\\0035\\000\\000\\012\\197\\000\\000\\000\\000\\0166\\0035\\012\\197\\000\\000\\000\\000\\012\\197\\0035\\000\\000\\000\\000\\000\\000\\0166\\0035\\000\\000\\000\\000\\000\\000\\012\\197\\0035\\000\\000\\000\\000\\012\\197\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\021\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\012\\197\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\190\\012\\197\\000\\000\\002\\138\\000\\000\\012\\197\\000\\000\\000\\000\\002\\246\\000\\000\\000\\000\\000\\000\\000\\000\\006e\\000\\000\\012\\197\\012\\197\\002\\130\\001\\210\\012\\197\\012\\197\\000\\000\\002\\250\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\197\\000\\000\\002\\254\\000\\000\\003\\150\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\003\\222\\001\\190\\000\\000\\000\\000\\000\\000\\000\\000\\012\\197\\002\\178\\000\\000\\000\\000\\003\\230\\000\\000\\000\\000\\000\\000\\bz\\b~\\b\\138\\000\\000\\000\\000\\005v\\000\\000\\000\\000\\000\\000\\003\\014\\002\\190\\000\\000\\000\\000\\002\\138\\000\\000\\006\\238\\000\\000\\000\\000\\002\\246\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\130\\005\\134\\000\\000\\001\\210\\000\\000\\007\\014\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\000\\000\\000\\000\\tB\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\030\\005\\138\\b\\146\\tn\\001\\190\\000\\000\\b\\170\\004r\\000\\000\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\006\\141\\003\\250\\000\\000\\004\\002\\000\\000\\011F\\005v\\002\\190\\000\\000\\000\\000\\002\\138\\000\\000\\000\\000\\000\\000\\000\\000\\002\\246\\000\\000\\000\\000\\005z\\000\\000\\006\\141\\000\\000\\000\\000\\000\\000\\000\\000\\001\\210\\005\\130\\005\\134\\000\\000\\002\\250\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\254\\000\\000\\003\\150\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\222\\001\\190\\005\\138\\000\\000\\000\\000\\000\\000\\000\\000\\002\\178\\004r\\000\\000\\003\\230\\000\\000\\000\\000\\000\\000\\bz\\b~\\b\\138\\000\\000\\000\\000\\005v\\000\\000\\000\\000\\000\\000\\005m\\000\\000\\000\\000\\000\\000\\000\\000\\005m\\000\\000\\000\\000\\005m\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\130\\005\\134\\005m\\000\\000\\000\\000\\000\\000\\005m\\000\\000\\005m\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005m\\000\\000\\000\\000\\000\\000\\005\\138\\b\\146\\005m\\000\\000\\005q\\b\\170\\004r\\000\\000\\b>\\005q\\000\\000\\005m\\005q\\000\\000\\005m\\000\\000\\000\\000\\000\\000\\000\\000\\005m\\005m\\000\\238\\005q\\000\\000\\000\\000\\000\\000\\005q\\000\\000\\005q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005m\\005m\\000\\000\\000\\000\\005m\\005q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005q\\000\\000\\000\\000\\005m\\005m\\000\\000\\b>\\005m\\005m\\005q\\000\\000\\000\\000\\005q\\000\\000\\000\\000\\000\\000\\000\\000\\005q\\005q\\000\\238\\000\\000\\0035\\000\\000\\000\\000\\005m\\000\\000\\0035\\000\\000\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\005q\\005q\\005m\\000\\000\\005q\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\0035\\000\\000\\005q\\005q\\000\\000\\000\\000\\005q\\005q\\000\\000\\000\\000\\000\\000\\000\\000\\0035\\015\\214\\000\\000\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\006\\029\\000\\000\\000\\000\\005q\\000\\000\\006\\029\\000\\000\\0035\\006\\029\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\005q\\0035\\0035\\0035\\006\\029\\000\\000\\000\\000\\000\\000\\006\\029\\000\\000\\006\\029\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0035\\000\\000\\000\\000\\000\\000\\0035\\006\\029\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\029\\000\\000\\000\\000\\0035\\0035\\0182\\000\\000\\0035\\0035\\006\\029\\000\\000\\000\\000\\006\\029\\000\\000\\000\\000\\000\\000\\000\\000\\006\\029\\006\\029\\000\\238\\000\\000\\000\\000\\000\\000\\0166\\0035\\025\\210\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\014\\002\\190\\006\\029\\000\\000\\002\\138\\000\\000\\006\\029\\000\\000\\000\\000\\002\\246\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\029\\006\\029\\021\\254\\001\\210\\006\\029\\006\\029\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\000\\000\\000\\000\\000\\000\\006\\029\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\006\\029\\012\\197\\003\\030\\000\\000\\012\\197\\003*\\001\\190\\000\\000\\000\\000\\000\\000\\000\\000\\006\\029\\002\\178\\000\\000\\012\\197\\003\\246\\000\\000\\000\\000\\012\\197\\003\\250\\012\\197\\004\\002\\005j\\000\\000\\005v\\000\\000\\005\\021\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\005z\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\012\\197\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\138\\000\\000\\006\\218\\012\\197\\t*\\005\\238\\004r\\000\\000\\000\\000\\000\\000\\000\\000\\003\\014\\002\\190\\000\\000\\000\\000\\002\\138\\000\\000\\012\\197\\012\\197\\002\\130\\002\\246\\012\\197\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\003\\254\\000\\000\\000\\000\\001\\210\\012\\197\\000\\000\\000\\000\\000\\000\\026\\234\\000\\000\\003\\018\\012\\197\\000\\000\\000\\000\\006J\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\014\\002\\190\\012\\197\\003\\030\\002\\138\\000\\000\\003*\\001\\190\\000\\000\\002\\246\\000\\000\\000\\000\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\001\\210\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\003\\018\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005z\\000\\000\\003\\030\\000\\000\\000\\000\\003*\\001\\190\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\000\\000\\000\\000\\006j\\000\\000\\000\\000\\000\\000\\000\\000\\005\\138\\003\\014\\002\\190\\000\\000\\005z\\002\\138\\004r\\000\\000\\000\\000\\000\\000\\002\\246\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\000\\000\\006\\158\\000\\000\\000\\000\\001\\210\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\000\\000\\000\\000\\000\\000\\006i\\000\\000\\000\\000\\000\\000\\000\\000\\005\\138\\003\\014\\002\\190\\000\\000\\003\\030\\002\\138\\004r\\003*\\001\\190\\000\\000\\002\\246\\000\\000\\000\\000\\000\\000\\002\\178\\006i\\000\\000\\003\\246\\000\\000\\000\\000\\001\\210\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\003\\018\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005z\\000\\000\\003\\030\\000\\000\\000\\000\\003*\\001\\190\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\000\\000\\000\\000\\011\\226\\000\\000\\000\\000\\000\\000\\000\\000\\005\\138\\003\\014\\002\\190\\000\\000\\005z\\002\\138\\004r\\000\\000\\000\\000\\000\\000\\002\\246\\000\\000\\005\\130\\005\\134\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\210\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\000\\000\\000\\000\\000\\000\\011\\238\\000\\000\\000\\000\\000\\000\\000\\000\\005\\138\\003\\014\\002\\190\\000\\000\\003\\030\\002\\138\\004r\\003*\\001\\190\\000\\000\\002\\246\\000\\000\\000\\000\\000\\000\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\001\\210\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\003\\018\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005z\\000\\000\\003\\030\\000\\000\\000\\000\\003*\\001\\190\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\002\\178\\000\\000\\000\\000\\003\\246\\000\\000\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\000\\000\\000\\000\\011\\250\\000\\000\\000\\000\\000\\000\\000\\000\\005\\138\\003\\014\\002\\190\\000\\000\\005z\\002\\138\\004r\\000\\000\\000\\000\\000\\000\\002\\246\\000\\000\\005\\130\\005\\134\\000\\000\\005\\202\\000\\000\\000\\000\\000\\000\\000\\000\\001\\210\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\018\\000\\000\\000\\000\\007\\021\\007f\\000\\000\\000\\000\\000\\000\\007\\021\\005\\138\\000\\000\\007\\021\\000\\000\\003\\030\\000\\000\\004r\\003*\\001\\190\\000\\000\\000\\000\\000\\000\\007\\021\\000\\000\\002\\178\\000\\000\\007\\021\\003\\246\\007\\021\\000\\000\\000\\000\\003\\250\\000\\000\\004\\002\\005j\\000\\000\\005v\\000\\000\\000\\000\\000\\000\\007\\021\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\007\\021\\007\\226\\005z\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\007\\021\\005\\130\\005\\134\\007\\021\\005\\202\\000\\000\\000\\000\\000\\000\\007\\021\\007\\021\\000\\238\\001\\189\\000\\000\\000\\000\\000\\000\\000\\000\\001\\189\\000\\000\\000\\000\\001\\189\\000\\000\\000\\000\\000\\000\\000\\000\\007\\021\\005\\138\\000\\000\\000\\000\\007\\021\\001\\189\\000\\000\\004r\\000\\000\\001\\189\\000\\000\\001\\189\\000\\000\\000\\000\\007\\021\\007\\021\\000\\000\\000\\000\\007\\021\\007\\021\\000\\000\\000\\000\\000\\000\\001\\189\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\189\\000\\000\\001\\225\\000\\000\\000\\000\\000\\000\\007\\021\\001\\225\\000\\000\\001\\189\\001\\225\\000\\000\\001\\189\\000\\000\\000\\000\\000\\000\\000\\000\\001\\189\\001\\189\\001\\189\\001\\225\\000\\000\\000\\000\\000\\000\\001\\225\\000\\000\\001\\225\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\189\\000\\000\\000\\000\\000\\000\\001\\189\\001\\225\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\225\\000\\000\\000\\000\\001\\189\\001\\189\\000\\000\\000\\000\\001\\189\\001\\189\\001\\225\\000\\000\\000\\000\\001\\225\\018>\\000\\000\\000\\000\\000\\000\\001\\225\\001\\225\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\189\\000\\000\\000\\000\\000\\000\\000\\000\\001\\189\\000\\000\\000\\000\\000\\000\\001\\225\\000\\000\\006!\\000\\000\\001\\225\\000\\000\\000\\000\\006!\\000\\000\\000\\000\\006!\\000\\000\\000\\000\\000\\000\\001\\225\\001\\225\\000\\000\\000\\000\\001\\225\\001\\225\\006!\\000\\000\\000\\000\\000\\000\\006!\\000\\000\\006!\\000\\000\\001\\225\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\225\\000\\000\\000\\000\\006!\\000\\000\\021\\218\\000\\000\\000\\000\\000\\000\\006!\\000\\000\\001\\225\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006!\\000\\000\\000\\000\\006!\\000\\000\\000\\000\\000\\000\\000\\000\\006!\\006!\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006!\\000\\000\\012\\197\\000\\000\\006!\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\006!\\006!\\000\\000\\000\\000\\006!\\006!\\012\\197\\000\\000\\000\\000\\000\\000\\012\\197\\000\\000\\012\\197\\000\\000\\006!\\000\\000\\000\\000\\000\\000\\005\\021\\000\\000\\000\\000\\006!\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\197\\000\\000\\006!\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\012\\197\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012}\\000\\000\\002\\190\\012}\\000\\000\\028\\150\\000\\000\\012\\197\\000\\000\\000\\000\\028\\154\\000\\000\\000\\000\\012}\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012}\\000\\000\\012\\197\\012\\197\\002\\130\\000\\000\\012\\197\\012\\197\\000\\000\\000\\000\\000\\000\\000\\000\\012}\\000\\000\\004q\\007f\\012\\197\\000\\000\\012}\\004q\\027\\\"\\000\\000\\004q\\012\\197\\001\\002\\001\\190\\000\\000\\012}\\000\\000\\000\\000\\012}\\000\\000\\004q\\000\\000\\012\\197\\012}\\004q\\000\\000\\004q\\000\\000\\000\\000\\004q\\000\\000\\028\\158\\004q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004q\\012}\\000\\000\\000\\000\\004q\\012}\\004q\\007\\226\\004q\\000\\000\\004q\\000\\000\\000\\000\\000\\000\\028\\162\\012}\\012}\\000\\000\\004q\\012}\\000\\000\\000\\000\\004q\\004q\\002\\226\\000\\238\\000\\000\\000\\000\\004q\\bY\\bY\\000\\000\\000\\000\\bY\\b>\\000\\000\\012}\\004q\\bY\\004q\\004q\\000\\000\\000\\000\\000\\000\\016~\\004q\\002\\226\\000\\238\\bY\\000\\000\\000\\000\\000\\000\\000\\000\\004q\\004q\\bY\\000\\000\\004q\\004q\\007f\\000\\000\\004q\\000\\000\\004q\\000\\000\\004q\\004q\\000\\000\\bY\\000\\000\\000\\000\\bY\\bY\\000\\000\\004q\\004q\\004q\\000\\000\\bY\\004q\\004q\\bY\\004q\\000\\000\\000\\000\\bY\\000\\000\\bY\\bY\\007\\146\\bY\\000\\000\\000\\000\\000\\000\\004q\\000\\000\\004q\\000\\000\\000\\000\\000\\000\\004q\\007\\226\\bY\\000\\000\\000\\000\\000\\000\\000\\000\\004q\\000\\000\\000\\000\\bY\\bY\\004q\\000\\000\\000\\000\\000\\000\\000\\000\\004q\\002\\226\\000\\238\\000\\000\\001y\\000\\000\\000\\000\\000\\000\\000\\000\\001y\\000\\000\\000\\000\\001y\\000\\000\\000\\000\\000\\000\\004q\\bY\\000\\000\\000\\000\\000\\000\\000\\000\\001y\\bY\\001y\\000\\000\\001y\\000\\000\\001y\\000\\000\\004q\\004q\\000\\000\\000\\000\\004q\\004q\\000\\000\\000\\000\\000\\000\\000\\000\\001y\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001y\\000\\000\\000\\245\\000\\000\\000\\000\\004q\\000\\000\\000\\245\\000\\000\\000\\000\\000\\245\\000\\000\\001y\\000\\000\\000\\000\\000\\000\\004q\\001y\\001y\\000\\238\\000\\245\\000\\000\\000\\000\\000\\000\\000\\245\\000\\000\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001y\\000\\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\000\\000\\000\\001y\\001y\\001y\\000\\000\\001y\\001y\\000\\245\\000\\000\\000\\000\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\245\\000\\245\\000\\238\\000\\000\\000\\249\\000\\000\\000\\000\\001y\\000\\000\\000\\249\\000\\000\\000\\000\\000\\249\\000\\000\\000\\000\\000\\000\\000\\245\\000\\000\\001y\\000\\000\\000\\245\\000\\000\\000\\249\\000\\000\\000\\000\\000\\000\\000\\249\\000\\000\\000\\249\\000\\000\\000\\245\\000\\245\\000\\000\\000\\000\\000\\245\\000\\245\\000\\000\\000\\000\\000\\000\\000\\000\\000\\249\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\249\\000\\000\\007\\017\\000\\000\\000\\000\\000\\245\\000\\000\\007\\017\\000\\000\\000\\249\\007\\017\\000\\000\\000\\249\\000\\000\\000\\000\\000\\000\\000\\245\\000\\249\\000\\249\\000\\238\\007\\017\\000\\000\\000\\000\\000\\000\\007\\017\\000\\000\\007\\017\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\249\\000\\000\\000\\000\\000\\000\\000\\249\\007\\017\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\007\\017\\000\\000\\000\\000\\000\\249\\000\\249\\000\\000\\000\\000\\000\\249\\000\\249\\007\\017\\000\\000\\000\\000\\007\\017\\000\\000\\000\\000\\000\\000\\000\\000\\007\\017\\007\\017\\000\\000\\000\\000\\006\\021\\000\\000\\000\\000\\000\\249\\000\\000\\006\\021\\000\\000\\000\\000\\006\\021\\000\\000\\000\\000\\000\\000\\007\\017\\000\\000\\000\\249\\018\\014\\007\\017\\000\\000\\006\\021\\000\\000\\000\\000\\000\\000\\006\\021\\000\\000\\006\\021\\000\\000\\007\\017\\007\\017\\017b\\000\\000\\007\\017\\007\\017\\000\\000\\000\\000\\000\\000\\000\\000\\006\\021\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\021\\000\\000\\005y\\007f\\000\\000\\007\\017\\000\\000\\005y\\000\\000\\006\\021\\005y\\000\\000\\006\\021\\000\\000\\000\\000\\000\\000\\000\\000\\006\\021\\006\\021\\000\\000\\005y\\000\\000\\000\\000\\000\\000\\005y\\000\\000\\005y\\000\\000\\000\\000\\000\\000\\000\\000\\012-\\000\\000\\006\\021\\000\\000\\000\\000\\012-\\006\\021\\005y\\012-\\000\\000\\000\\000\\000\\000\\000\\000\\005y\\007\\226\\000\\000\\006\\021\\006\\021\\012-\\000\\000\\006\\021\\006\\021\\012-\\000\\000\\012-\\005y\\000\\000\\000\\000\\000\\000\\000\\000\\005y\\005y\\000\\238\\000\\000\\000\\000\\000\\000\\012-\\006\\021\\000\\000\\000\\000\\000\\000\\000\\000\\012-\\000\\000\\000\\000\\000\\000\\005y\\000\\000\\000\\000\\001\\202\\002\\134\\012-\\000\\000\\002\\138\\012-\\000\\000\\000\\000\\000\\000\\000\\000\\012-\\005y\\005y\\000\\000\\000\\000\\005y\\005y\\000\\000\\000\\000\\001\\210\\001\\250\\001\\230\\000\\000\\000\\000\\000\\000\\000\\000\\012-\\nF\\000\\000\\001\\242\\012-\\000\\000\\005y\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012-\\012-\\002\\146\\002\\154\\012-\\012-\\000\\000\\002\\166\\000\\000\\002\\178\\004\\030\\004*\\004I\\000\\000\\000\\000\\000\\000\\021\\178\\004I\\026\\206\\004A\\004I\\012-\\000\\000\\000\\000\\004A\\000\\000\\000\\000\\004A\\000\\000\\000\\000\\004I\\000\\000\\011*\\004:\\004I\\000\\000\\004I\\004A\\000\\000\\000\\000\\000\\000\\004A\\005\\134\\004A\\000\\000\\000\\000\\000\\000\\000\\000\\004I\\000\\000\\000\\000\\000\\000\\026\\218\\000\\000\\004I\\004A\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004A\\000\\000\\004I\\000\\000\\000\\000\\004I\\000\\000\\000\\000\\021\\198\\004A\\004I\\000\\000\\004A\\000\\000\\000\\000\\000\\000\\000\\000\\004A\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004I\\000\\000\\000\\000\\000\\000\\004I\\004a\\000\\000\\004A\\000\\000\\000\\000\\004a\\004A\\0041\\004a\\004I\\004I\\000\\000\\0041\\004I\\004I\\0041\\004A\\004A\\004a\\000\\000\\004A\\004A\\004a\\000\\000\\004a\\0041\\000\\000\\000\\000\\000\\000\\0041\\004I\\0041\\000\\000\\000\\000\\000\\000\\000\\000\\004a\\004A\\000\\000\\000\\000\\000\\000\\017\\138\\004a\\0041\\000\\000\\004q\\000\\000\\000\\000\\020\\146\\0041\\004q\\004a\\000\\000\\004q\\004a\\000\\000\\000\\000\\000\\000\\0041\\004a\\000\\000\\0041\\000\\000\\004q\\000\\000\\000\\000\\0041\\004q\\000\\000\\004q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004a\\000\\000\\000\\000\\000\\000\\004a\\000\\000\\004q\\0041\\000\\000\\000\\000\\000\\000\\0041\\004q\\000\\000\\004a\\004a\\000\\000\\000\\000\\004a\\004a\\000\\000\\0041\\0041\\000\\000\\004q\\0041\\0041\\000\\000\\000\\000\\004q\\002\\226\\000\\000\\000\\000\\000\\000\\000\\000\\004a\\001\\202\\001\\206\\000\\000\\000\\000\\000\\000\\000\\000\\0041\\000\\000\\000\\000\\004q\\021v\\000\\000\\000\\000\\000\\000\\002\\150\\000\\000\\000\\000\\024\\238\\000\\000\\001\\210\\001\\250\\001\\230\\000\\000\\004q\\004q\\000\\000\\000\\000\\004q\\004q\\001\\242\\000\\000\\000\\000\\000\\000\\007\\246\\000\\000\\000\\000\\002\\002\\000\\000\\006\\233\\006\\233\\000\\000\\000\\000\\001\\246\\002\\154\\004q\\000\\000\\000\\000\\002\\166\\000\\000\\002\\178\\004\\030\\004*\\000\\000\\000\\000\\004.\\000\\000\\0046\\006\\233\\006\\233\\006\\233\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\233\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004:\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\233\\006\\233\\000\\000\\000\\000\\000\\000\\006\\233\\000\\000\\006\\233\\006\\233\\006\\233\\000\\000\\004Q\\000\\000\\000\\000\\006\\233\\000\\000\\004Q\\000\\000\\0049\\004Q\\000\\000\\000\\000\\015\\198\\0049\\000\\000\\000\\000\\0049\\000\\000\\000\\000\\004Q\\000\\000\\006\\233\\000\\000\\004Q\\000\\000\\004Q\\0049\\000\\000\\000\\000\\000\\000\\0049\\000\\000\\0049\\000\\000\\000\\000\\000\\000\\000\\000\\004Q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004Q\\0049\\000\\000\\004i\\000\\000\\000\\000\\000\\000\\0049\\004i\\000\\000\\000\\000\\004i\\004Q\\000\\000\\004\\\"\\000\\000\\006\\233\\004Q\\000\\000\\0049\\000\\000\\004i\\000\\000\\000\\000\\0049\\004i\\000\\000\\004i\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004Q\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004i\\0049\\000\\000\\000\\000\\000\\000\\000\\000\\004i\\000\\000\\004Q\\004Q\\000\\000\\000\\000\\004Q\\004Q\\000\\000\\0049\\0049\\000\\000\\004i\\0049\\0049\\000\\000\\000\\000\\004i\\t\\206\\000\\000\\000\\000\\000\\000\\000\\000\\004Q\\001\\202\\001\\206\\000\\000\\000\\000\\000\\000\\000\\000\\0049\\000\\000\\000\\000\\004i\\018\\222\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\254\\021\\030\\000\\000\\001\\210\\001\\250\\001\\230\\000\\000\\004i\\004i\\000\\000\\000\\000\\004i\\004i\\001\\242\\004\\133\\000\\000\\000\\000\\000\\000\\000\\000\\000\\246\\000\\000\\000\\000\\002\\194\\000\\000\\000\\000\\000\\000\\001\\246\\002\\154\\004i\\000\\000\\000\\000\\002\\166\\003j\\002\\178\\004\\030\\004*\\004\\133\\000\\000\\003n\\021\\158\\0046\\007\\165\\000\\000\\000\\000\\007\\165\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003z\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\017N\\004:\\000\\000\\000\\000\\007\\165\\007\\165\\000\\000\\007\\165\\007\\165\\025\\026\\000\\000\\000\\000\\017\\178\\000\\000\\000\\000\\000\\000\\000\\000\\017\\202\\000\\000\\000\\000\\000\\000\\007\\185\\000\\000\\000\\000\\007\\185\\000\\000\\000\\000\\000\\000\\007\\165\\000\\000\\000\\000\\000\\000\\000\\000\\017\\210\\000\\000\\000\\000\\000\\000\\004n\\000\\000\\004r\\007\\185\\007\\185\\000\\000\\007\\185\\007\\185\\000\\000\\007\\165\\017\\230\\018\\\"\\000\\000\\000\\000\\004\\133\\004\\133\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\007\\185\\000\\000\\007\\145\\000\\000\\022Z\\007\\145\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\007\\165\\000\\000\\007\\165\\000\\000\\000\\000\\000\\000\\000\\238\\000\\000\\000\\000\\007\\145\\007\\145\\000\\000\\007\\145\\007\\145\\005\\226\\000\\000\\000\\000\\007\\165\\007\\165\\000\\000\\000\\000\\000\\000\\007\\165\\007\\189\\007\\165\\000\\000\\007\\189\\000\\000\\007\\165\\000\\000\\000\\000\\000\\000\\000\\000\\007\\145\\000\\000\\000\\000\\007\\185\\000\\000\\007\\185\\000\\000\\000\\000\\000\\000\\007\\189\\007\\189\\000\\000\\007\\189\\007\\189\\000\\000\\000\\000\\000\\000\\007\\185\\007\\145\\000\\000\\005\\234\\007\\185\\000\\000\\000\\000\\000\\000\\007\\185\\000\\000\\007\\185\\000\\000\\000\\000\\000\\000\\007\\185\\000\\000\\007\\189\\000\\000\\007\\173\\000\\000\\000\\000\\007\\173\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\007\\145\\000\\000\\007\\145\\000\\238\\000\\000\\000\\000\\007\\173\\007\\173\\000\\000\\007\\173\\007\\173\\000\\000\\000\\000\\000\\000\\007\\145\\000\\000\\000\\000\\005\\234\\007\\145\\000\\000\\r\\133\\r\\133\\007\\145\\000\\000\\007\\145\\000\\000\\000\\000\\000\\000\\007\\145\\000\\000\\007\\173\\000\\000\\000\\000\\007\\189\\000\\000\\007\\189\\000\\000\\000\\000\\000\\000\\r\\133\\r\\133\\r\\133\\007z\\000\\000\\000\\000\\000\\000\\000\\000\\007\\189\\000\\238\\r\\133\\005\\234\\007\\189\\000\\000\\000\\000\\000\\000\\007\\189\\000\\000\\007\\189\\000\\000\\t\\218\\000\\000\\007\\189\\r\\133\\r\\133\\000\\000\\001\\202\\001\\206\\r\\133\\000\\000\\r\\133\\r\\133\\r\\133\\000\\000\\000\\000\\000\\000\\000\\000\\r\\133\\000\\000\\007\\173\\000\\000\\007\\173\\000\\000\\000\\000\\000\\000\\001\\210\\001\\250\\001\\230\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006F\\r\\133\\001\\242\\005\\234\\007\\173\\000\\000\\000\\000\\000\\000\\007\\173\\000\\000\\007\\173\\001\\202\\001\\206\\023\\014\\007\\173\\001\\246\\002\\154\\000\\000\\000\\000\\000\\000\\002\\166\\000\\000\\002\\178\\004\\030\\004*\\000\\000\\000\\000\\000\\000\\000\\000\\0046\\001\\210\\001\\214\\001\\230\\000\\000\\000\\000\\000\\000\\001\\202\\001\\206\\023n\\000\\000\\001\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004:\\000\\000\\000\\000\\000\\000\\000\\000\\001\\202\\001\\206\\001\\246\\002\\154\\001\\210\\001\\214\\001\\230\\002\\166\\000\\000\\002\\178\\004\\030\\004*\\000\\000\\000\\000\\001\\242\\000\\000\\0046\\000\\000\\000\\000\\001\\210\\001\\250\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\246\\002\\154\\000\\000\\000\\000\\000\\000\\002\\166\\004:\\002\\178\\004\\030\\004*\\000\\000\\000\\000\\000\\000\\000\\000\\0046\\001\\246\\002\\170\\001\\202\\001\\206\\000\\000\\002\\166\\000\\000\\002\\178\\004\\030\\004*\\000\\000\\000\\000\\000\\000\\000\\000\\0046\\000\\000\\004:\\000\\000\\000\\000\\000\\000\\000\\000\\001\\210\\001\\250\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004:\\000\\000\\000\\000\\004\\229\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\246\\002\\170\\000\\000\\000\\000\\000\\000\\002\\166\\026v\\002\\178\\004\\030\\004*\\000\\000\\000\\000\\000\\000\\000\\000\\0046\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004:\\000\\000\\000\\000\\004\\233\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\026v\"))\n \n and lhs =\n (8, \"\\014\\r\\012\\011\\n\\t\\b\\007\\006\\005\\004\\003\\002\\001\\000\\222\\222\\221\\221\\220\\219\\219\\218\\218\\218\\218\\218\\218\\218\\218\\218\\218\\218\\218\\218\\218\\218\\218\\218\\218\\218\\218\\217\\217\\216\\215\\215\\215\\215\\215\\215\\215\\215\\214\\214\\214\\214\\214\\214\\214\\214\\213\\213\\213\\212\\212\\211\\210\\210\\210\\209\\209\\208\\208\\208\\208\\208\\208\\207\\207\\207\\207\\207\\207\\207\\207\\206\\206\\206\\206\\206\\206\\206\\206\\205\\205\\205\\205\\204\\203\\202\\202\\202\\202\\201\\201\\201\\201\\200\\200\\200\\199\\199\\199\\199\\198\\197\\197\\197\\196\\196\\195\\195\\194\\194\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\193\\192\\192\\191\\191\\190\\189\\188\\187\\187\\186\\186\\185\\185\\185\\185\\184\\184\\184\\184\\183\\183\\182\\182\\182\\182\\182\\182\\181\\180\\179\\179\\178\\178\\177\\177\\176\\175\\175\\174\\173\\173\\172\\171\\170\\170\\170\\169\\169\\168\\167\\167\\167\\167\\167\\167\\166\\166\\166\\166\\166\\166\\166\\166\\165\\165\\164\\164\\164\\164\\164\\164\\163\\163\\162\\162\\162\\161\\161\\160\\160\\160\\160\\159\\159\\158\\158\\157\\157\\156\\156\\155\\155\\154\\154\\153\\153\\152\\152\\151\\151\\150\\150\\149\\149\\149\\148\\148\\148\\148\\147\\147\\146\\146\\145\\145\\144\\144\\144\\144\\144\\143\\143\\143\\143\\142\\142\\142\\141\\141\\141\\141\\141\\141\\141\\140\\140\\140\\140\\140\\140\\140\\139\\139\\138\\138\\137\\137\\137\\137\\137\\137\\136\\136\\135\\135\\134\\134\\133\\133\\132\\132\\132\\131\\130\\130\\130\\129\\129\\128\\128\\128\\128\\128\\128\\128\\128\\128\\127\\127~~}}}}}}}}}}}|{zyyxxxxxwvvuuttttttttttttttssrrqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqppoonnmmllkkjjiihhggffeeeeeeeeeeedcba`_^]\\\\[ZYYYYYYYYYYXXXWWWVVVVVUUUUUUUUUTTSSSSSRRQQPONNMMMMMLLKKJJJIIIIIIHHHGGFFEEDDCCBBBAA@@??>>==<<;;::99887776665554443333210000000000000000000/////.......-----------------------------------------------------------------,,++++++++++++++++++++++***************************************************))(((''&&&&&&&&&&&&&&&&%%$$#######\\\"\\\"\\\"\\\"!! \\031\\031\\030\\029\\028\\028\\028\\027\\027\\026\\026\\026\\026\\026\\026\\026\\026\\026\\026\\025\\025\\024\\024\\024\\024\\023\\023\\022\\021\\021\\021\\021\\021\\020\\019\\019\\018\\018\\018\\017\\017\\017\\016\\016\\016\\016\\016\\016\\015\\015\")\n \n and goto =\n ((16, \"\\000)\\001A\\000S\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000v\\000\\000\\000\\000\\000\\203\\000\\134\\000\\\"\\000\\024\\000\\165\\000\\164\\000\\186\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000T\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\136\\000\\000\\000\\000\\000\\000\\000\\140\\000\\000\\000\\000\\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\\000\\000\\000\\000\\000\\000\\000\\190\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\007 \\000\\250\\000\\000\\001\\022\\000\\141\\000\\225\\000\\000\\000\\214\\023R\\001r\\001\\158\\000 \\000\\000\\000\\000\\000\\000\\001\\138\\000\\000\\000\\000\\000v\\000\\000\\000\\000\\000\\000\\000\\000\\003\\012\\000\\000\\002*\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000~\\000\\000\\000z\\003R\\b2\\000\\000\\000\\000\\011:\\007 \\000\\000\\000\\000\\000-\\000\\000\\001D\\000\\000%\\156\\001\\026\\001~\\000\\000\\000\\000\\002\\020\\0028\\003\\178\\007\\026\\005\\216\\003R\\0038\\000\\023\\002\\002\\001\\200\\002`\\002p\\011\\200\\000\\000>\\018\\002r\\002\\214\\002z2n\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000#\\224\\000\\000\\002\\168\\003\\014\\003.\\000\\000\\000\\000\\000\\000\\000\\000\\tZ\\000\\000\\000\\000\\003\\030\\000Y\\003h\\006p\\b\\022\\000\\000\\000\\000\\000\\000\\002\\238\\003\\014\\003v\\001:\\003<\\003\\158\\001H\\003T\\003\\168\\001\\\\\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\196\\000\\000\\000\\000\\000\\000\\003h\\005D\\011\\236\\t\\180>\\018\\012F\\000\\000\\002\\238\\012\\142#\\250$\\152\\000\\000\\000\\143\\000\\000\\000\\000\\000\\000\\000\\000\\004F>p\\004\\\\\\000\\0002\\152\\004~\\000\\0002\\1828d\\000\\221\\000\\000\\001\\224\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0003\\006\\004\\020\\000\\000\\000\\000\\000\\000\\022\\182\\000\\000\\006$\\000\\000\\000\\000\\006\\136\\000\\230\\000\\000\\000\\000\\007\\174\\000\\0002\\210\\000\\000\\006\\136\\b\\196\\006\\136\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0008\\234\\000\\000\\005\\130\\004\\160\\000\\000>\\232\\005\\170\\027p\\000\\000\\000\\000\\000\\000\\0044\\000\\000\\000\\000\\000\\000\\000\\000\\004\\012\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0003\\024\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\004\\224\\000\\000\\000\\000\\000\\000\\004\\012\\005\\0163\\226\\004\\152\\006\\n\\016\\020\\000\\000\\007\\002\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000G\\000\\000\\000\\000\\000\\000\\000\\000\\005\\1924\\002\\000\\000\\000\\000\\004\\172\\006.4J\\000\\000\\000\\000\\000\\0004l\\004\\1644\\246\\000\\000\\004\\164\\000\\0005X\\004\\164\\000\\0005\\138#\\224\\005\\134\\005\\148\\000\\000\\000\\000,\\022\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\164\\000\\000\\000\\0005\\190\\000\\000\\004\\164>\\154\\000\\000\\004\\012\\000\\000\\000\\0005\\242\\000\\000\\004\\164\\0014\\000\\000\\000\\000\\004\\164\\004\\164\\000\\000\\000\\000\\004\\164\\000\\000\\000\\000$\\152\\000\\000\\000\\000\\000\\000\\000\\000\\004\\164$\\250\\000\\000\\000\\000\\004\\164\\000\\000\\001\\148\\005\\178\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\00098\\000\\000\\005\\134\\000\\000?\\026\\004\\012\\000\\000\\000\\000\\000\\000\\000\\000\\005\\192\\006F\\012\\176\\005\\242\\006\\b\\006\\012\\006\\194\\003X\\006\\200\\000\\144\\006\\168\\000\\000\\000\\000\\n\\138\\011*\\007\\024\\000\\158\\006F\\011\\134\\000\\000\\004\\128\\000\\023\\007v\\003T\\007\\160\\000\\000\\000\\000&\\196\\000\\0009@\\0074\\000\\000?\\\\\\004\\012?\\150\\004\\012\\000\\000\\003~\\004\\\\\\000\\000\\011\\158\\004\\128\\000\\000\\000\\000\\006p\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\018\\004\\128\\012\\182\\004\\128\\000\\000\\006d\\000\\000\\000\\000\\007\\006\\000\\000\\000\\000\\000\\000\\007\\220\\000\\000\\000\\000\\000\\000\\004\\128\\000\\000\\000\\000\\004\\128\\000\\000\\006F\\007\\006\\000\\000\\000?\\003<\\000\\000\\000?\\000\\000\\000\\000\\rb\\004\\128\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000?\\rv\\r\\204\\007\\176\\007T\\004\\1486&\\000\\000\\006\\186\\007n\\014\\030\\006\\254\\007x?\\238@\\020\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\164\\t\\212\\000\\000\\000\\000\\000\\000\\007\\002\\007\\214\\007\\140\\000?\\r\\234\\000\\000\\004\\128\\000\\000\\000\\000\\000\\000\\012\\142\\000\\000?\\234\\004\\012\\014h\\007\\006\\b\\130\\014\\156\\007z\\b\\132\\014\\230%\\004\\004\\164\\015P\\007\\170\\b\\184\\004\\012\\b\\194\\000\\000\\000\\000\\000\\000\\000\\000#\\224\\b\\218\\000\\000\\021N\\015\\154\\bJ\\b\\2506\\004\\004\\164\\016\\b\\b\\162\\t>@\\144\\000\\000@\\252\\000\\000\\000\\000\\016R\\006:\\t\\198\\000\\000\\000\\000\\t\\252@\\204\\000\\000\\004\\012)\\128\\000\\000\\004\\012A\\\"\\004\\012\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000A\\006\\000\\000\\000\\000\\000\\000\\004\\168\\016\\188\\000\\000\\000\\000\\000\\000\\000\\000%\\238AZ\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\180\\017\\006\\000\\000\\b\\206& \\b\\206&@\\b\\206\\000\\000A\\236\\000\\000&\\144\\b\\206\\017:\\002\\012\\017\\132\\000\\000\\000\\000&\\244\\b\\206'\\\\\\b\\206'\\186\\b\\206'\\220\\b\\206(\\016\\b\\206(~\\b\\206(\\220\\b\\206(\\228\\b\\206)6\\b\\206)\\134\\b\\206*\\006\\b\\206*v\\b\\206*\\204\\b\\206+0\\b\\206+z\\b\\206+\\156\\b\\206+\\206\\b\\206,l\\b\\206,\\198\\b\\206-\\026\\b\\206\\tV\\017\\1687\\b#\\224\\t\\186\\000\\000-@=\\180\\000\\000\\018v\\000\\000\\000\\000\\018\\170\\000\\000\\000\\000\\000\\000-~\\000\\000\\000\\000)\\128\\t\\218\\000\\000A\\142\\004\\012\\018\\222\\000\\000\\000\\000\\t\\134\\000\\000A\\162\\004\\012\\019F\\000\\000\\000\\000\\019z\\000\\000\\000\\000\\000\\000B\\026\\004\\012\\019\\224\\000\\000\\t<\\020J\\000\\0007\\022\\000\\000\\004\\1647x\\000\\000\\004\\1647\\130\\000\\000\\004\\164\\002\\026\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0007\\194\\004\\164\\000\\000\\001\\222\\005*\\000\\000\\000\\000\\000\\000\\b\\206\\020|\\000\\000\\000\\000\\000\\000\\020\\176\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\020\\228\\000\\000\\000\\000\\000\\000\\b\\206\\021\\022\\000\\000\\021\\184\\000\\000\\000\\000\\000\\000\\022\\026\\000\\000\\000\\000\\000\\000\\000\\000BD\\000\\000\\000\\000\\022\\128\\000\\000\\000\\000\\000\\000-\\154\\b\\206\\022\\212\\000\\000\\000\\000\\000\\000.6\\b\\206\\022\\226\\000\\000\\000\\000\\000\\000.D\\b\\206\\004\\218\\023\\182\\000\\000\\000\\000.f\\b\\206\\023\\216\\000\\000\\000\\000/,\\b\\206\\024X\\000\\000\\000\\000/6\\b\\206\\000\\000\\000\\000\\024z\\000\\000\\000\\000/\\144\\b\\206\\024\\172\\000\\000\\000\\000/\\224\\b\\206\\025N\\000\\000\\000\\0000\\000\\b\\206\\000\\0000\\208\\b\\206\\000\\000%T\\000\\000\\000\\000\\b\\206\\000\\000\\000\\000\\025t\\000\\000\\000\\000\\025\\164\\000\\000\\000\\000\\tz\\000\\000\\000\\000\\026\\\"\\000\\000\\026t\\000\\000\\000\\000\\000\\000#\\224\\n\\022\\000\\0009t\\t\\016\\006\\136\\027\\016\\000\\0009\\172\\000\\000\\000\\000\\000\\0009\\228\\000\\000\\000\\000\\027D\\000\\000\\027d\\000\\000\\000\\000\\000\\000\\000\\00002\\000\\000\\000\\000\\000\\0001\\006\\b\\2061&\\b\\206\\000\\000\\t<\\027\\254\\000\\000\\000\\000\\028j\\000\\0001r\\000\\000\\000\\000@\\020\\000\\000\\000\\000\\000\\000\\028\\206\\000\\000\\000\\000\\000\\000\\000\\000\\029\\004\\000\\000\\000\\000\\000\\000\\000\\000\\n\\176\\000\\000\\000\\000\\000\\00080\\000\\000\\004\\250\\000\\000\\000\\019\\000\\000\\nb\\000\\000\\005\\252\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\164\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\206\\000\\000\\n\\212\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\t^\\007\\204\\000?\\029$\\000\\000\\n0\\tb\\n\\196\\002\\204\\b\\006\\000?\\0158\\004\\128\\t\\172\\000?\\000\\000\\029\\244\\000\\000\\004$\\000\\000\\nV\\t~\\001\\232\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\150\\000\\198\\003X\\000\\000\\000\\000\\000\\000=\\128\\000\\000E|\\000\\000\\t\\190\\000\\000\\t\\210\\000\\000\\000\\000\\000\\000\\000\\000\\004\\156\\000\\000\\000\\000\\000\\000\\012.\\006\\136\\000\\000\\006\\136\\000\\012\\000\\000\\002P\\000\\000\\rr\\006\\136\\006\\136\\000\\000\\016x\\006\\136\\006\\136\\t\\218\\000\\000\\030\\020\\000\\000\\000\\000\\t\\228\\011\\144\\000\\000\\026\\238\\007\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\206\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\n\\220\\t\\236\\n\\228\\000?\\000\\000\\015\\196\\000\\000\\004\\128\\000\\000\\012&\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\030\\232\\000\\000\\b\\206\\000\\000\\000\\000\\018:\\000\\000\\004\\128\\000\\000\\019\\012\\000\\000\\004\\128\\000\\000\\019\\158\\004\\128\\000\\000\\000?\\000\\000\\t\\246\\012`\\001x\\000\\000\\011\\030\\011,\\n\\002\\011f\\011\\252\\021 \\004\\128\\b\\254\\000\\000\\n\\n\\011\\242\\012\\\"\\004\\206\\t.\\011\\250\\n\\024\\012@\\004\\216\\t4\\012\\n\\000\\000\\000\\000\\006\\024\\tH\\000\\000\\003\\132\\003$8\\012\\004\\164\\030F\\000\\000\\006\\162\\003n\\011\\200\\n*\\012\\232\\001\\244\\000\\000\\011\\240\\n2\\006\\016\\000\\000<$\\000\\000Bp\\004\\012\\000\\000\\012\\140\\012\\142\\000\\000\\t\\158\\000\\000\\004\\012\\0124\\nB\\007Z\\012V\\000\\251\\000\\000\\000\\000\\000\\000\\000\\000\\nT\\n4\\000\\000\\n\\166\\n`\\000\\000\\bX1\\132\\012l\\012\\136\\n\\174\\bJ\\n\\144\\000\\000\\n\\188\\bx\\011\\004\\000\\000\\012\\138\\012\\188\\n\\200\\012\\228\\011\\252\\021\\192\\004\\128\\000\\000\\n\\204\\rR\\000\\000\\b\\242\\000\\000\\011\\\\\\000\\000\\rV\\000\\000\\023\\132\\005N\\r$\\n\\206\\rb\\000\\000\\024\\020\\006\\170\\r<\\000\\000\\000\\000\\000\\012\\003\\146\\011\\170\\000\\000\\024H\\004\\128\\011\\172\\000\\000\\000\\022\\000\\000\\r\\n\\n\\228\\025|\\007\\130\\000\\000\\r*\\0112\\007\\200\\012V\\r0\\r>\\011R\\014\\154\\000\\000\\rl\\001\\246\\000\\000\\000\\000\\000\\000\\000\\000\\000\\211\\011X\\rFB\\136\\004\\012\\000\\000\\004$\\011~\\014*\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000B\\146\\007\\132\\000\\000\\011\\222\\014\\130\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\r\\234\\0126\\015\\020\\r\\210\\000\\000\\000\\000\\n\\162\\b\\240\\014\\028\\000\\000\\000\\000\\012P\\015J\\014\\000\\000\\000\\000\\000)\\210\\000\\000\\t\\244\\000\\0000\\1448\\006\\004\\012\\000\\000Ch\\012\\220\\000\\000C\\160\\000\\000\\000\\000\\000\\000\\007\\204\\000\\000\\000\\000\\012^\\014H\\012T\\015h\\014\\030\\000\\000\\000\\000C\\200\\012\\140\\014j\\000\\000\\000\\000\\000\\000<\\206\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\012\\210\\000\\000\\014\\132\\012V\\t\\220\\000\\000\\015|\\015.\\012\\248\\014\\142\\000\\000\\000\\000\\014\\148\\012d\\n\\012\\000\\000\\000\\000\\b\\2448d\\006\\140\\000\\000\\000\\000\\000\\000\\b\\250\\014b\\012j\\000\\000\\014f\\b\\250\\000\\000\\015J\\r\\000\\014\\176\\000\\000\\000\\000\\000\\000\\004\\012\\0005\\002\\024\\007\\192\\000\\000\\000\\000\\000\\000\\000\\000\\014\\130\\012\\220\\000\\000\\tF\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\012\\014p\\012\\222\\015\\216\\014\\146\\000\\000:\\b\\000\\169\\012\\236\\014f\\007d\\007\\252\\012\\246\\015\\026\\000\\000\\015\\208\\031\\146\\000\\000\\000\\000\\031\\178\\000\\000\\rr\\000\\000\\003D\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000D\\002\\004\\012\\000\\000\\015\\212\\031\\226\\000\\000\\000\\000 \\018\\000\\000\\001\\252\\012\\248\\015z\\000\\000\\000\\000:x<\\144\\015,\\000\\000D\\030\\004\\012 |\\000\\000\\000\\000 \\216\\000\\000\\000\\000\\r\\168\\000\\000\\002\\152\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000=Z\\000\\000\\000\\000:\\180=|\\0154\\000\\000Dd\\004\\012!\\128\\000\\000\\000\\000!\\194\\000\\000\\000\\000\\012\\254!\\232\\r\\190\\000\\000\\r\\004\\r\\006\\000m\\000:\\r \\n\\130\\r<\\015\\138\\\"L\\r\\194\\000\\000\\rL\\rh\\011b\\000\\000\\001\\224>8\\000\\000\\005\\192\\000\\000\\rn:\\208:\\236\\0020\\014n\\003\\134\\000\\000\\030&%T\\000\\000\\003\\152\\000\\000\\000\\000\\003\\152\\000\\000\\000\\000\\003\\152\\012X\\000\\000\\003\\214\\003\\152\\015\\144\\\"\\134\\r\\212\\000\\000\\003\\152\\000\\000\\000\\000DF\\000\\000\\000\\000\\000\\000\\003\\152\\000\\000\\000\\000\\014\\002\\000\\000\\005,\\t\\030\\014\\004\\000\\000\\r\\1344\\012\\014\\012\\000\\000\\000\\000\\000\\000\\000\\000\\014&\\000\\000\\000\\000\\007\\204\\000\\000\\003\\152D\\158\\000\\000\\005|\\003\\152;\\184\\000\\000\\014:\\014\\254\\r\\212\\016\\022\\014\\208\\000\\000;\\244\\014\\140\\015\\014\\000\\000\\000\\000\\000\\000 d\\005\\242\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\b\\180\\014\\148\\000\\000\\015\\030\\000\\000\\000\\000\\000\\000\\000\\000\\014\\160#\\134\\000\\000\\000\\000\\000\\000\\000\\000\\b\\180\\000\\000\\000\\000\\014\\166-\\208\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000?\\004\\128\\000\\000\\000\\000\\004\\164\\000\\000D\\210\\004\\012\\000\\000\\007\\222\\000\\000\\000\\000\\000\\000\\000\\000#B\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\015\\180\\002\\134\\0114\\014b\\001l\\r\\220\\000\\000\\004&\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\014\\130\\002$\\r\\238\\000\\000\\007H\\016\\022\\015\\208\\014\\176\\000\\000\\000\\000\\015\\196\\002\\148\\005\\204\\000\\000\\000\\000\\000\\000\\014&\\000\\000\\0140\\004\\144\\000\\000\\000\\000\\006\\136\\005\\156\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000E\\176\\000\\000\\000\\000\\b`\\007\\206\\000\\000\\000\\000EN\\004\\012\\004\\012\\000\\000EX\\004\\012\\t\\142\\000\\000\\000\\000\\000\\000\\004\\012\\000\\000\\000\\000\\n\\016\\015\\216\\014\\188\\000\\000\\000\\000\\015\\204\\001\\024\\003\\200\\000\\000\\000\\000\\000\\000\\000\\000\\tB\\016\\022\\nV\\015\\232\\014\\204\\000\\000\\000\\000\\015\\232\\001v\\005\\250\\000\\000\\000\\000\\000\\000\\000\\000\\004\\128\\000\\000\\014\\216\\000\\000\\000\\000\\000\\000\\\"\\244\\000\\000#\\146\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\018\\002\\000\\000\\000\\000\\000\\000\\007\\224\\000\\186\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004F\\000\\186\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\192\\000\\000\\000\\000\\000\\000>\\\\\\000\\000\\004\\012\\000\\000\\n\\198\\000\\000\\000\\000\\000\\000\\000D\\000\\000\\000\\000\\000\\000\\000\\177\\000\\000\\000\\000\\000\\000\\004\\254\\000\\000\\000?\\000\\000\\006z\\000\\000\\004\\128\\000\\000\\003>\\000\\000\\000\\000\\000\\0001\\164\\004\\164\\000\\000\\000\\000\\000\\017\\000\\000\\000\\000\\000\\000\\000\\000\\001\\164\\004\\202\\015$\\011 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\007H\\000\\000\\014\\218\\000\\000\\000\\000\\000\\000\\000\\000\\005\\020\\006\\186\\000\\166\\002L\\000\\000\\000\\000\\014\\230\\003\\242\\000\\000\\000\\000\\000\\000\\014\\240\\005\\152\\000\\000\\000\\000\\000\\000\\000\\000\"), (16, \"\\006E\\0007\\002,\\002-\\001e\\002\\001\\004\\143\\007\\n\\001\\031\\000\\238\\001\\216\\006\\166\\001k\\006\\213\\007\\030\\002-\\001e\\002n\\006F\\006\\224\\001\\240\\006H\\001\\016\\003\\184\\001\\244\\002o\\001\\023\\001\\016\\001\\023\\001\\026\\006I\\006V\\000;\\001\\023\\001\\026\\001\\\"\\001\\031\\006E\\002\\137\\002,\\002-\\001e\\000\\149\\007\\011\\006\\199\\001\\233\\000\\238\\000\\234\\005v\\003\\011\\000\\238\\000\\239\\006\\219\\002\\002\\002n\\006F\\006U\\002\\014\\006H\\006J\\000\\234\\001T\\002o\\000\\238\\001\\002\\001\\245\\004\\t\\006I\\006V\\003\\011\\002\\025\\000@\\001\\003\\004\\015\\004\\146\\002\\137\\001\\139\\000\\234\\006\\002\\001\\246\\000\\238\\000\\239\\007 \\000\\131\\006f\\000\\149\\005\\n\\002\\027\\000\\154\\000\\149\\000\\238\\006\\191\\000\\158\\001\\027\\003\\185\\006K\\006J\\001\\006\\005\\011\\002\\139\\006\\217\\0007\\005#\\006E\\006L\\000q\\001e\\006\\004\\006\\002\\0007\\001\\016\\0020\\001W\\002\\141\\000\\238\\000\\241\\001\\023\\001$\\0079\\004O\\000\\155\\007:\\006\\005\\007!\\006H\\002\\141\\000\\238\\006\\007\\006[\\001\\031\\007\\006\\0063\\006K\\006I\\000\\241\\004\\198\\002\\139\\006\\004\\001\\016\\006y\\004\\201\\006L\\002\\012\\006\\\\\\001\\023\\001$\\000\\241\\002\\028\\0020\\001\\214\\002\\141\\000\\238\\006\\005\\006O\\005}\\005~\\006\\226\\006\\007\\006Q\\004\\t\\000\\234\\006\\030\\006J\\000\\238\\000\\239\\006[\\007\\007\\001l\\006S\\001%\\005\\142\\002\\142\\001\\023\\002\\148\\005\\135\\004\\029\\000:\\001\\159\\001e\\002\\154\\006\\\\\\001\\139\\002\\144\\0007\\006T\\002\\026\\002,\\002-\\001e\\004\\200\\006O\\006\\002\\001\\031\\001\\016\\004\\200\\006Q\\001.\\001%\\006K\\001\\023\\001$\\002n\\002\\156\\004\\021\\000?\\006S\\000m\\006L\\002\\142\\002o\\002\\148\\006E\\006\\194\\002,\\002-\\001e\\002\\154\\000\\\\\\001\\139\\002\\144\\006\\004\\006T\\002\\137\\000\\149\\004\\024\\000\\159\\001\\233\\007<\\002n\\006F\\006U\\001\\016\\006H\\003\\196\\001e\\006\\005\\002o\\001\\023\\001$\\002\\156\\006\\007\\006I\\006V\\000`\\006\\023\\000d\\006N\\001\\016\\006E\\002\\137\\002,\\002-\\001e\\001\\023\\001\\026\\002\\006\\006O\\001\\016\\002\\014\\006\\208\\000\\134\\006Q\\002\\006\\001\\023\\001\\026\\002n\\006F\\006U\\003\\011\\006H\\006J\\006S\\000y\\002o\\006\\152\\001\\016\\0009\\000\\149\\006I\\006V\\000\\154\\001\\023\\001\\026\\002\\139\\000=\\004N\\002\\137\\006T\\002\\027\\002\\025\\001%\\000\\238\\003\\003\\001e\\001\\016\\0020\\004\\012\\002\\141\\000\\238\\0007\\001\\023\\001$\\000\\128\\006\\164\\0007\\000\\234\\006K\\006J\\000\\238\\000\\239\\002\\139\\006w\\004\\218\\004\\143\\006E\\006L\\000\\238\\004\\r\\001(\\003\\011\\006\\197\\006\\198\\0020\\000\\241\\002\\141\\000\\238\\001\\031\\002\\145\\005\\006\\0079\\003\\011\\000\\130\\007:\\000\\234\\005\\n\\006H\\000\\238\\001\\002\\004S\\006[\\005\\135\\004\\029\\005v\\006K\\006I\\001\\182\\005\\011\\002\\139\\002\\028\\005\\213\\005\\018\\002\\025\\006L\\001%\\006\\\\\\002\\142\\004\\t\\004@\\000\\174\\0020\\000\\137\\002\\141\\000\\238\\002\\154\\006O\\001\\139\\002\\144\\006\\197\\006\\198\\006Q\\001\\006\\000\\234\\001\\019\\006J\\000\\238\\000\\239\\006[\\000\\136\\001\\023\\006S\\006\\160\\006\\128\\002\\142\\001\\139\\002\\148\\000\\240\\002\\156\\005\\135\\004\\029\\003\\r\\002\\154\\006\\\\\\001\\139\\002\\144\\005\\206\\006T\\006\\130\\002,\\002-\\001e\\004y\\006O\\006\\002\\006\\150\\002\\026\\004\\143\\006Q\\005\\208\\000\\238\\006K\\005\\217\\000\\234\\002n\\002\\156\\000\\238\\000\\239\\006S\\000\\153\\006L\\002\\142\\002o\\002\\148\\006E\\000\\241\\002,\\002-\\001e\\002\\154\\001\\016\\001\\139\\002\\144\\006\\004\\006T\\002\\137\\001\\023\\001$\\005\\178\\000\\179\\007;\\002n\\006F\\006U\\006\\002\\006H\\003\\245\\004\\029\\006\\005\\002o\\005}\\005~\\002\\156\\006\\007\\006I\\006V\\000\\152\\006\\014\\000\\183\\006N\\000\\178\\006E\\002\\137\\002,\\002-\\001e\\005\\134\\000\\189\\002\\026\\006O\\005\\135\\004\\029\\000\\241\\006\\004\\006Q\\006\\140\\000\\186\\001\\139\\002n\\006F\\006U\\002\\160\\006H\\006J\\006S\\000\\184\\002o\\006]\\006\\005\\001%\\003\\232\\006I\\006V\\006\\007\\0007\\004\\017\\002\\139\\006\\011\\000\\188\\002\\137\\006T\\000\\149\\000\\241\\006\\142\\001\\233\\006\\134\\006\\135\\000\\193\\0020\\007\\022\\002\\141\\000\\238\\006\\134\\006\\135\\006\\136\\006\\137\\004\\020\\002\\014\\000\\194\\006K\\006J\\006\\136\\006\\137\\002\\139\\006Y\\006\\138\\004\\029\\006E\\006L\\006o\\000\\241\\002\\014\\006\\138\\004\\029\\000\\206\\0020\\000\\210\\002\\141\\000\\238\\007\\023\\002\\145\\005\\182\\0079\\003\\235\\002\\018\\007:\\000\\207\\002\\027\\006H\\001\\240\\000\\238\\003\\249\\006[\\001\\244\\000\\216\\001\\023\\006K\\006I\\002\\029\\000\\234\\002\\139\\002\\027\\000\\238\\001\\002\\000\\238\\006L\\003\\011\\006\\\\\\002\\142\\004P\\004)\\006!\\0020\\006\\242\\002\\141\\000\\238\\002\\154\\006O\\001\\139\\002\\144\\001\\251\\000\\241\\006Q\\000\\238\\000\\234\\000\\225\\006J\\000\\238\\000\\239\\006[\\004\\194\\000\\218\\006S\\000\\238\\001\\245\\002\\142\\001\\221\\002\\148\\000\\226\\002\\156\\004\\004\\004\\006\\004\\b\\002\\154\\006\\\\\\001\\139\\002\\144\\002\\028\\006T\\000\\241\\002,\\002-\\001e\\003\\011\\006O\\006\\002\\001\\031\\000\\241\\000\\229\\006Q\\000\\231\\002\\028\\006K\\000\\232\\000\\234\\002n\\002\\156\\000\\238\\000\\239\\006S\\000\\246\\006L\\002\\142\\002o\\002\\148\\006E\\006\\195\\002,\\002-\\001e\\002\\154\\001\\016\\001\\139\\002\\144\\006\\004\\006T\\002\\137\\001\\023\\001\\026\\007-\\007.\\007?\\002n\\0070\\000\\241\\006\\002\\006H\\001Y\\003\\011\\006\\005\\002o\\000\\241\\003\\236\\002\\156\\006\\007\\006I\\0072\\006\\196\\006\\b\\004n\\006N\\001\\n\\006E\\002\\137\\002,\\002-\\001e\\007A\\006\\t\\005\\027\\006O\\000\\241\\001\\236\\006\\131\\006\\004\\006Q\\000\\241\\0079\\001\\r\\002n\\007:\\003\\182\\001\\240\\006H\\006J\\006S\\001\\244\\002o\\001\\023\\006\\005\\005\\n\\001\\030\\006I\\007B\\006\\007\\005\\030\\001;\\002\\139\\006\\018\\006\\250\\002\\137\\006T\\005\\011\\003\\249\\006\\132\\003\\235\\005\\012\\001B\\001\\016\\0020\\005 \\002\\141\\000\\238\\006\\133\\001\\023\\001$\\006\\243\\006\\159\\004\\171\\003\\024\\006K\\006J\\000\\238\\001\\002\\002\\139\\007\\014\\001G\\001\\245\\006E\\006L\\005!\\004\\143\\002\\014\\003\\011\\000\\238\\001V\\0020\\004a\\002\\141\\000\\238\\001\\031\\002\\145\\004f\\0079\\003O\\001\\177\\007:\\000\\238\\001\\002\\006H\\0075\\003\\011\\004\\007\\004\\006\\004\\b\\000\\242\\003)\\006K\\006I\\007\\015\\000\\234\\002\\139\\002\\027\\000\\238\\001\\002\\000\\238\\006L\\001%\\006\\\\\\002\\142\\006z\\003\\205\\001\\\\\\0020\\001\\175\\002\\141\\000\\238\\002\\154\\006O\\001\\139\\002\\144\\003`\\001t\\006Q\\001\\239\\000\\234\\007F\\006J\\000\\238\\000\\239\\003\\235\\004}\\001e\\006S\\006\\160\\003\\235\\002\\142\\003\\183\\002\\148\\006\\251\\002\\156\\001\\139\\001~\\003\\012\\002\\154\\006\\\\\\001\\139\\002\\144\\001\\031\\006T\\003\\188\\002,\\002-\\001e\\003\\011\\006O\\006\\002\\001\\135\\000\\241\\000\\247\\006Q\\004\\183\\002\\028\\006K\\001\\134\\000\\234\\002n\\002\\156\\000\\238\\000\\239\\006S\\001\\181\\006L\\002\\142\\002o\\002\\148\\006E\\003\\011\\002,\\002-\\001e\\002\\154\\001\\016\\001\\139\\002\\144\\006\\004\\006T\\002\\137\\001\\023\\001$\\001E\\006\\162\\007D\\002n\\006F\\006c\\006\\002\\006H\\001)\\000\\234\\006\\005\\002o\\000\\238\\000\\239\\002\\156\\006\\007\\006I\\006V\\001\\193\\006$\\001C\\006N\\001\\016\\006E\\002\\137\\002,\\002-\\001e\\001\\023\\001$\\005\\\"\\006O\\000\\241\\0007\\006\\151\\006\\004\\006Q\\001\\239\\0079\\000\\234\\002n\\007:\\000\\238\\001\\002\\006H\\006J\\006S\\001\\198\\002o\\004%\\006\\005\\001%\\004k\\006I\\007=\\006\\007\\005\\030\\006\\209\\002\\139\\0067\\001\\016\\002\\137\\006T\\000\\241\\007\\018\\006\\132\\001\\023\\001$\\001]\\001`\\0020\\005 \\002\\141\\000\\238\\006\\133\\003\\011\\003\\183\\000\\149\\006\\160\\000\\181\\001\\233\\006K\\006J\\000\\241\\001\\031\\002\\139\\001u\\001 \\006\\196\\005\\253\\006L\\005!\\001\\253\\001\\216\\006E\\004\\030\\007\\019\\0020\\001\\023\\002\\141\\000\\238\\003\\249\\002\\145\\001\\240\\006\\147\\003\\235\\003\\217\\001\\244\\001\\203\\001\\023\\001\\016\\001\\\"\\0070\\006\\169\\006[\\006H\\001\\023\\001$\\006K\\001%\\003\\011\\001\\209\\002\\139\\000\\149\\006I\\001\\220\\001\\233\\006L\\002\\005\\006\\\\\\002\\142\\000\\241\\003g\\001\\226\\0020\\001\\228\\002\\141\\000\\238\\002\\154\\006O\\001\\139\\002\\144\\002\\014\\001\\243\\006Q\\004\\189\\001&\\007@\\001\\245\\000\\241\\005o\\004\\006\\004\\b\\006J\\006S\\001\\031\\001*\\002\\142\\001+\\002\\148\\001\\204\\002\\156\\001\\246\\001\\206\\002\\004\\002\\154\\006\\\\\\001\\139\\002\\144\\002\\015\\006T\\001\\016\\002\\027\\002\\000\\006\\235\\000\\238\\006O\\001\\023\\001$\\001\\023\\003\\210\\006Q\\001\\\"\\003\\011\\003\\011\\005\\171\\001\\016\\003\\206\\002\\156\\006K\\004#\\006S\\001\\023\\001$\\002\\142\\002&\\002\\148\\006E\\006L\\002,\\002-\\001e\\002\\154\\001\\213\\001\\139\\002\\144\\001\\016\\006T\\004t\\002\\014\\001\\016\\001\\239\\001\\023\\001$\\002n\\006F\\001\\023\\001\\026\\006H\\0071\\003\\011\\001\\031\\002o\\000\\241\\001 \\002\\156\\000\\241\\006I\\006_\\002)\\005R\\0027\\002\\028\\002F\\006+\\002\\137\\0029\\006N\\001>\\002\\027\\001\\031\\002\\014\\000\\238\\001 \\006\\173\\001%\\002'\\006O\\001\\\"\\006\\176\\006\\236\\002*\\006Q\\004\\206\\004\\239\\003\\249\\006J\\001\\016\\005S\\005\\148\\005T\\006.\\006S\\001\\023\\001$\\005v\\000\\241\\001\\\"\\003\\219\\005\\n\\002\\014\\002\\027\\001.\\001\\016\\000\\238\\001H\\0060\\003\\011\\006T\\001\\023\\001\\026\\005\\011\\006\\237\\004\\140\\004\\029\\005\\017\\0062\\006\\244\\001\\023\\005U\\005\\019\\002I\\006K\\001*\\001\\031\\006p\\002\\139\\003\\227\\0028\\002\\028\\002\\027\\006L\\0061\\000\\238\\005\\131\\004\\006\\004\\b\\006\\186\\0020\\000\\241\\002\\141\\000\\238\\001*\\006.\\000\\241\\002O\\001%\\005\\173\\001\\031\\001\\239\\001G\\001 \\006.\\001\\016\\005V\\006b\\002[\\006\\245\\0060\\001\\023\\001$\\002\\028\\001\\031\\005W\\005X\\004\\158\\005Y\\0060\\004\\210\\004\\029\\006\\\\\\001\\023\\001\\016\\001.\\006\\172\\001\\\"\\001\\016\\005$\\001\\023\\001$\\006O\\006\\246\\001\\023\\001$\\0061\\006Q\\005\\r\\006\\205\\004\\162\\005\\149\\002\\028\\000\\241\\005v\\0061\\001\\023\\006S\\003\\011\\002X\\002\\142\\006\\247\\002\\148\\005}\\005~\\003\\011\\005\\001\\001>\\002\\154\\000\\238\\001\\139\\002\\144\\000\\241\\006T\\001%\\005[\\002G\\002J\\005\\127\\005\\143\\005]\\005g\\001*\\005\\135\\004\\029\\002^\\001>\\002b\\001\\016\\003\\011\\005\\145\\002\\156\\003\\011\\001%\\001\\023\\001$\\005y\\005\\150\\002,\\002-\\001e\\001.\\003\\011\\002P\\001H\\005\\r\\005\\146\\002,\\002-\\001e\\006%\\004\\177\\001\\016\\002n\\002,\\002-\\001e\\001\\023\\001\\023\\001$\\001.\\002o\\000\\149\\001H\\005`\\001\\233\\001\\016\\0048\\005,\\002n\\003c\\002g\\001\\023\\001$\\002\\137\\004\\\\\\002c\\002o\\001\\031\\000\\241\\000\\241\\0057\\003\\249\\003\\162\\002{\\003\\011\\000\\149\\001%\\005j\\001\\233\\002\\137\\001\\016\\001\\031\\001\\216\\003d\\001 \\006g\\001\\023\\001$\\004b\\005}\\005~\\004g\\001\\240\\001>\\001\\\"\\000\\241\\001\\244\\003\\014\\001\\023\\002h\\001%\\004l\\002\\014\\0010\\005\\127\\005\\143\\002\\153\\003\\249\\001\\\"\\005\\135\\004\\029\\002\\204\\005s\\004\\029\\001%\\003\\218\\001\\031\\003\\224\\000m\\001 \\005\\139\\004\\006\\004\\b\\005\\r\\002\\139\\005v\\002\\208\\001.\\000\\241\\003\\231\\001H\\003\\239\\002\\027\\002/\\000m\\000\\238\\0020\\001\\245\\002\\141\\000\\238\\002\\139\\003~\\002\\224\\001\\\"\\004\\135\\0020\\006\\t\\002\\141\\000\\238\\003\\011\\0007\\001\\246\\0020\\001*\\002\\141\\000\\238\\006\\181\\004\\006\\004\\b\\002\\231\\005v\\003\\004\\000\\241\\004\\000\\002,\\002-\\001e\\006\\188\\002\\145\\001\\016\\003s\\003\\011\\003{\\004\\002\\000\\241\\001\\023\\001$\\004\\026\\000\\241\\002n\\000\\241\\003f\\004\\031\\001\\016\\002\\145\\003\\176\\0041\\002o\\001*\\001\\023\\001$\\004Q\\002\\028\\007\\002\\000\\241\\003\\011\\002\\142\\004W\\002\\148\\003\\186\\002\\137\\004^\\006\\202\\003\\208\\002\\154\\002\\142\\001\\139\\002\\144\\004d\\007*\\002-\\001e\\002\\142\\002\\143\\002\\148\\001\\139\\002\\144\\004w\\001\\016\\004\\148\\002\\154\\004|\\001\\139\\002\\144\\001\\023\\001$\\000\\241\\002\\156\\001%\\004\\139\\001\\031\\005}\\005~\\001 \\001\\216\\001>\\000\\241\\002\\n\\004\\147\\007\\004\\000\\241\\004\\151\\001%\\002\\156\\001\\240\\000\\241\\005\\127\\005\\143\\001\\244\\000\\241\\001\\023\\005\\135\\004\\029\\003\\011\\000\\241\\001.\\001\\016\\001\\\"\\002\\014\\003\\223\\000\\241\\002\\139\\001\\023\\001\\026\\000\\241\\004\\159\\005}\\005~\\003\\225\\001.\\001>\\000\\241\\001H\\0020\\005v\\002\\141\\000\\238\\001%\\003\\238\\004\\150\\000\\241\\005\\127\\005\\143\\004\\157\\000\\241\\0042\\005\\135\\004\\029\\002\\027\\001\\245\\004\\161\\000\\238\\000\\241\\002,\\002-\\001e\\004\\167\\003\\011\\004\\173\\004\\185\\004\\025\\000\\241\\001*\\001\\246\\001.\\002\\145\\005\\015\\001H\\002n\\000\\238\\004\\204\\002,\\002-\\001e\\001\\216\\005\\n\\002o\\002\\007\\007+\\004!\\002\\141\\000\\238\\006s\\004\\163\\001\\240\\005\\240\\002n\\005\\011\\001\\244\\002\\137\\001\\023\\005+\\001\\016\\002\\142\\002o\\002\\148\\003\\011\\003\\011\\001\\023\\001$\\004=\\002\\154\\000\\241\\001\\139\\002\\144\\0040\\000\\241\\002\\137\\002\\028\\004\\209\\004;\\005\\248\\001\\031\\000\\241\\000\\238\\003\\011\\002,\\002-\\001e\\000\\241\\001\\216\\000\\241\\000\\241\\001\\217\\002\\156\\004\\214\\003\\011\\004\\178\\004\\224\\001\\245\\001\\240\\002n\\001\\216\\000\\241\\001\\244\\001\\238\\001\\023\\003\\011\\004]\\002o\\005}\\005~\\001\\240\\001\\246\\001>\\004V\\001\\244\\004\\230\\001\\023\\004+\\002\\139\\001%\\002\\137\\001\\187\\001e\\006\\184\\006\\185\\006~\\004\\029\\004X\\005\\135\\004\\029\\0020\\004[\\002\\141\\000\\238\\004\\195\\004\\199\\002\\139\\002,\\002-\\001e\\000\\241\\001f\\002A\\001\\245\\001h\\001i\\001.\\004j\\0020\\001H\\002\\141\\000\\238\\002n\\004\\250\\003\\011\\001\\245\\000\\241\\001\\246\\001\\216\\000\\241\\002o\\001\\248\\002\\145\\004\\241\\005\\026\\004\\252\\004$\\001\\031\\001\\240\\001\\246\\005>\\004`\\001\\244\\002\\137\\001\\023\\005\\031\\002\\014\\003\\011\\000\\241\\004i\\002\\145\\002\\139\\001\\016\\003\\152\\003\\005\\003\\006\\004e\\004h\\001\\023\\001$\\002\\142\\004v\\002\\148\\0020\\001\\\"\\002\\141\\000\\238\\005\\014\\002\\154\\005\\000\\001\\139\\002\\144\\006\\016\\004R\\005\\021\\000\\238\\002\\027\\005&\\002\\142\\000\\238\\002\\148\\004{\\003\\011\\001\\245\\004\\134\\004\\133\\002\\154\\001\\127\\001\\139\\002\\144\\0050\\002\\156\\005I\\005_\\005G\\002\\145\\000\\241\\001\\246\\000\\241\\001n\\005i\\003\\011\\000\\238\\005u\\002\\139\\003\\011\\002,\\002-\\001e\\002\\156\\001\\216\\001%\\001\\031\\001\\250\\002\\014\\004\\138\\0020\\005O\\002\\141\\000\\238\\001\\240\\002n\\004\\149\\002\\142\\001\\244\\003\\030\\001\\023\\003\\155\\003\\160\\002o\\000\\241\\002\\154\\000\\241\\001\\139\\002\\144\\003\\216\\002\\028\\000\\241\\004\\011\\001\\016\\000\\241\\004x\\002\\137\\004\\160\\002\\027\\001\\023\\001$\\000\\238\\002\\145\\002,\\002-\\001e\\005\\\\\\000\\241\\002\\156\\000\\241\\000\\241\\004\\156\\004\\172\\001\\129\\005\\137\\005\\153\\003\\011\\000\\241\\002n\\001\\245\\000\\241\\001\\130\\005\\159\\001\\139\\001l\\005d\\002o\\005\\163\\005\\191\\005{\\002\\142\\005\\231\\002\\148\\001\\246\\006#\\005\\236\\003\\213\\004\\166\\002\\154\\002\\137\\001\\139\\002\\144\\004\\168\\003\\011\\002,\\002-\\001e\\004\\192\\006\\019\\004\\180\\001\\216\\004\\191\\001%\\002\\022\\003\\011\\004\\186\\003\\011\\002\\139\\002\\028\\002n\\001\\240\\002\\156\\005\\241\\004\\190\\001\\244\\003\\011\\001\\023\\002o\\001\\016\\0020\\006\\015\\002\\141\\000\\238\\003\\199\\001\\023\\001$\\004\\203\\000\\241\\000\\241\\001.\\002\\137\\002,\\002-\\001e\\005\\247\\000\\241\\005\\172\\005\\255\\003\\011\\003\\011\\000\\241\\000\\241\\004\\208\\003\\011\\000\\241\\005/\\002n\\000\\241\\000\\241\\006(\\002\\139\\002\\145\\004\\213\\004\\216\\002o\\001\\245\\003\\011\\002,\\002-\\001e\\003\\151\\000\\241\\0020\\005\\207\\002\\141\\000\\238\\003\\011\\002\\137\\001\\216\\001\\246\\004\\220\\002<\\002n\\004\\228\\005\\233\\000\\241\\005\\244\\001%\\001\\240\\002\\142\\002o\\002\\148\\001\\244\\000\\241\\001\\023\\006\\022\\003\\146\\002\\154\\006=\\001\\139\\002\\144\\002\\139\\006\\129\\002\\137\\002\\145\\001d\\001e\\000\\241\\004\\235\\004\\246\\000\\241\\006\\141\\005.\\0020\\004\\019\\002\\141\\000\\238\\003\\011\\006\\\"\\006&\\002\\156\\003\\011\\000\\241\\006*\\005'\\001f\\001v\\003\\011\\001h\\001i\\003\\011\\005(\\002\\142\\001\\245\\003\\030\\003\\011\\006/\\005-\\002\\139\\006\\155\\002\\154\\003\\011\\001\\139\\002\\144\\006\\157\\002\\145\\006;\\001\\246\\003\\142\\003\\011\\0020\\0051\\002\\141\\000\\238\\0052\\003\\011\\003\\011\\002,\\002-\\001e\\005Q\\000\\241\\003\\011\\002\\156\\002\\139\\000\\241\\005J\\003\\011\\001w\\005K\\001x\\002L\\002n\\002\\142\\000\\241\\002\\148\\0020\\005P\\002\\141\\000\\238\\002o\\002\\154\\002\\145\\001\\139\\002\\144\\005f\\003\\135\\006B\\005b\\005c\\005e\\006P\\005\\144\\002\\137\\002,\\002-\\001e\\006W\\005t\\005x\\006`\\001\\127\\000\\241\\005z\\002\\156\\006\\146\\005|\\000\\241\\002\\145\\002n\\002\\142\\006\\190\\002\\148\\001n\\005\\136\\005\\152\\000\\238\\002o\\002\\154\\006\\204\\001\\139\\002\\144\\005\\154\\003x\\003\\145\\006\\216\\0073\\005\\155\\005\\160\\005\\164\\002\\137\\005\\168\\007>\\005\\186\\005\\193\\005\\197\\002\\142\\007C\\002\\148\\005\\221\\005\\242\\002\\156\\006\\n\\006\\020\\002\\154\\001\\216\\001\\139\\002\\144\\003\\229\\002,\\002-\\001e\\006D\\006>\\002\\139\\001\\240\\001d\\001e\\006?\\001\\244\\006C\\001\\023\\006R\\006|\\002n\\006\\144\\0020\\002\\156\\002\\141\\000\\238\\006\\145\\006\\149\\002o\\001\\129\\006\\189\\006\\193\\001f\\001g\\003p\\001h\\001i\\001\\130\\006\\203\\001\\139\\001l\\002\\137\\002,\\002-\\001e\\006\\207\\007%\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\001\\245\\002n\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\002o\\000\\000\\000\\000\\000\\000\\001\\031\\001\\246\\001\\216\\000\\000\\000\\000\\0046\\003h\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\001\\240\\002\\142\\000\\000\\002\\148\\001\\244\\000\\000\\001\\023\\000\\000\\000\\000\\002\\154\\002\\145\\001\\139\\002\\144\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001m\\000\\000\\002n\\000\\000\\000\\000\\002\\156\\0020\\000\\000\\002\\141\\000\\238\\002o\\002\\142\\001n\\002\\148\\000\\000\\000\\238\\002\\134\\000\\000\\001\\245\\002\\154\\000\\000\\001\\139\\002\\144\\002\\137\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\002\\139\\001\\246\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\002n\\000\\000\\000\\000\\002\\156\\0020\\000\\000\\002\\141\\000\\238\\002o\\000\\000\\000\\000\\002,\\002-\\001e\\002\\147\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\001\\016\\000\\000\\002n\\002\\142\\000\\000\\002\\148\\001\\023\\001$\\000\\000\\001\\129\\002o\\002\\154\\002\\145\\001\\139\\002\\144\\000\\000\\002\\162\\001\\138\\000\\000\\001\\139\\001l\\002\\139\\000\\000\\002\\137\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\002\\156\\002\\141\\000\\238\\000\\000\\000\\000\\002n\\002\\142\\000\\000\\003\\030\\002\\205\\001e\\000\\000\\000\\000\\002o\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\002\\161\\000\\000\\000\\000\\000\\000\\000\\000\\002\\139\\001%\\002\\137\\000\\000\\000\\000\\002\\240\\001v\\002\\145\\001h\\001i\\000\\000\\000\\000\\0020\\002\\156\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\139\\005R\\004\\023\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\002\\148\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\002\\154\\002\\145\\001\\139\\002\\144\\002\\245\\003\\005\\003\\006\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005S\\006\\228\\005T\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\002\\156\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\002\\142\\000\\000\\002\\148\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\002\\154\\001\\127\\001\\139\\002\\144\\000\\000\\000\\000\\005U\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\002n\\002\\156\\000\\000\\000\\000\\002\\154\\002\\145\\001\\139\\002\\144\\002o\\000\\000\\000\\000\\002,\\002-\\001e\\002\\213\\000\\000\\000\\000\\000\\000\\000\\000\\005V\\000\\000\\002\\137\\000\\000\\000\\000\\003\\t\\003\\n\\002n\\002\\156\\005W\\005X\\000\\000\\005Y\\000\\000\\002\\142\\002o\\002\\148\\000\\000\\002,\\002-\\001e\\002\\216\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\001\\129\\002n\\000\\000\\005\\149\\001\\216\\000\\000\\000\\000\\004E\\001\\130\\002o\\001\\139\\001l\\000\\000\\002\\156\\001\\240\\002\\228\\000\\000\\000\\000\\001\\244\\000\\000\\001\\023\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\005[\\006\\230\\000\\000\\000\\000\\002\\139\\005]\\005g\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\005\\145\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\002\\139\\005\\146\\001\\245\\000\\000\\002o\\000\\000\\000\\000\\002,\\002-\\001e\\002\\235\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\001\\246\\002\\137\\002\\145\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\000\\000\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\238\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\002\\137\\002\\145\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\000\\000\\001\\216\\000\\000\\002\\154\\004I\\001\\139\\002\\144\\002,\\002-\\001e\\000\\000\\001\\240\\000\\000\\000\\000\\000\\000\\001\\244\\000\\000\\001\\023\\000\\000\\002\\145\\000\\000\\002\\142\\002n\\002\\148\\000\\000\\000\\000\\002\\156\\002\\139\\000\\000\\002\\154\\002o\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\002\\244\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\137\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\002\\156\\002\\139\\000\\000\\002\\154\\001\\245\\001\\139\\002\\144\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\001\\246\\002\\145\\000\\000\\000\\000\\001\\216\\002n\\000\\000\\004L\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\002o\\001\\240\\002,\\002-\\001e\\001\\244\\002\\247\\001\\023\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\002\\145\\000\\000\\002\\142\\002n\\002\\148\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\002\\154\\002o\\001\\139\\002\\144\\002,\\002-\\001e\\003\\017\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\002\\142\\002n\\002\\148\\000\\000\\001\\245\\002\\156\\000\\000\\000\\000\\002\\154\\002o\\001\\139\\002\\144\\002,\\002-\\001e\\003\\021\\000\\000\\000\\000\\001\\246\\000\\000\\000\\000\\000\\000\\002\\137\\002\\145\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\002\\156\\002\\139\\000\\000\\000\\000\\002o\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\003\\027\\002\\141\\000\\238\\002\\137\\000\\000\\000\\000\\002\\142\\002n\\002\\148\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\002\\154\\002o\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\001d\\001e\\000\\000\\0020\\003 \\002\\141\\000\\238\\002\\137\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\156\\002\\139\\000\\000\\000\\000\\001f\\002\\218\\000\\000\\001h\\001i\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\002,\\002-\\001e\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\002\\145\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\002n\\002\\139\\002\\156\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\002o\\001\\216\\000\\000\\000\\000\\004Z\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\003\\\"\\001\\240\\002\\145\\002\\137\\002\\142\\001\\244\\002\\148\\001\\023\\000\\000\\002\\156\\000\\000\\001m\\002\\154\\000\\000\\001\\139\\002\\144\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\002\\145\\000\\000\\000\\000\\002\\142\\002n\\003\\030\\000\\000\\000\\000\\002\\156\\000\\000\\000\\000\\002\\154\\002o\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\000\\000\\001\\245\\000\\000\\000\\000\\003&\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\002\\142\\000\\000\\003\\030\\003\\129\\000\\000\\001\\246\\002\\156\\000\\000\\002\\154\\002\\139\\001\\139\\002\\144\\002,\\002-\\001e\\000\\000\\001\\216\\000\\000\\000\\000\\004\\170\\000\\000\\0020\\003\\132\\002\\141\\000\\238\\000\\000\\001\\240\\002n\\001\\129\\000\\000\\001\\244\\002\\156\\001\\023\\000\\000\\000\\000\\002o\\001\\138\\000\\000\\001\\139\\001l\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003.\\000\\000\\001\\031\\002\\137\\000\\000\\001 \\000\\000\\000\\000\\002\\145\\002,\\002-\\001e\\000\\000\\002\\139\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\0020\\001\\245\\002\\141\\000\\238\\001\\\"\\000\\000\\002n\\002o\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\003\\030\\002o\\001\\246\\000\\000\\0034\\000\\000\\002\\154\\002\\137\\001\\139\\002\\144\\000\\000\\003:\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\002\\156\\000\\000\\000\\000\\005R\\000\\000\\000\\000\\000\\000\\001*\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\003\\030\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\005S\\006\\210\\005T\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\002\\139\\000\\000\\002\\145\\000\\000\\001\\023\\001$\\000\\000\\002\\139\\000\\000\\000\\000\\002\\156\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002,\\002-\\001e\\0020\\000\\000\\002\\141\\000\\238\\005U\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\002n\\003\\030\\002,\\002-\\001e\\000\\000\\000\\000\\002\\154\\002o\\001\\139\\002\\144\\000\\000\\000\\000\\002\\145\\003A\\000\\000\\000\\000\\002n\\000\\000\\0011\\002\\145\\002\\137\\000\\000\\000\\000\\000\\000\\002o\\001%\\005V\\000\\000\\000\\000\\002\\156\\003F\\000\\000\\000\\000\\000\\000\\000\\000\\005W\\005X\\002\\137\\005Y\\000\\000\\002\\142\\000\\000\\003\\030\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\002\\154\\003\\030\\001\\139\\002\\144\\001.\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\001\\216\\000\\000\\005\\149\\004\\182\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\001\\240\\000\\000\\002\\156\\000\\000\\001\\244\\000\\000\\001\\023\\000\\000\\000\\000\\002\\156\\000\\000\\002n\\002\\139\\002,\\002-\\001e\\005[\\000\\000\\000\\000\\002o\\000\\000\\005]\\005g\\000\\000\\0020\\003K\\002\\141\\000\\238\\002n\\002\\139\\000\\000\\005\\145\\002\\137\\000\\000\\000\\000\\000\\000\\002o\\000\\000\\002,\\002-\\001e\\0020\\000\\000\\002\\141\\000\\238\\001\\245\\003R\\005\\146\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\001\\246\\000\\000\\002o\\001\\216\\000\\000\\000\\000\\004\\188\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003W\\001\\240\\002\\145\\002\\137\\000\\000\\001\\244\\000\\000\\001\\023\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\001\\216\\000\\000\\000\\000\\004\\197\\002\\154\\002\\139\\001\\139\\002\\144\\000\\000\\000\\000\\001\\240\\000\\000\\000\\000\\002\\142\\001\\244\\002\\148\\001\\023\\0020\\000\\000\\002\\141\\000\\238\\002\\154\\002\\139\\001\\139\\002\\144\\000\\000\\000\\000\\002\\156\\000\\000\\001\\245\\000\\000\\002,\\002-\\001e\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\246\\002\\156\\000\\000\\002n\\002\\139\\000\\000\\002\\145\\002,\\002-\\001e\\000\\000\\002o\\001\\245\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\003\\\\\\002n\\002\\145\\002\\137\\000\\000\\001\\246\\000\\000\\000\\000\\000\\000\\002o\\002,\\002-\\001e\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\000\\000\\003k\\000\\000\\002\\154\\002\\137\\001\\139\\002\\144\\002n\\000\\000\\002\\145\\000\\000\\000\\000\\002\\142\\000\\000\\003\\030\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\003n\\002\\156\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\003\\030\\000\\000\\000\\000\\000\\000\\002\\156\\000\\000\\002\\154\\002\\139\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\002\\156\\000\\000\\002n\\000\\000\\001\\216\\000\\000\\000\\000\\004\\205\\000\\000\\0020\\002o\\002\\141\\000\\238\\000\\000\\001\\240\\000\\000\\003t\\000\\000\\001\\244\\000\\000\\001\\023\\002\\139\\002\\145\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\002o\\003\\030\\000\\000\\000\\000\\000\\000\\000\\000\\003v\\002\\154\\001\\245\\001\\139\\002\\144\\000\\000\\000\\000\\002\\137\\002\\145\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\003\\030\\000\\000\\001\\246\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\002\\156\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\205\\001e\\000\\000\\002\\142\\000\\000\\003\\030\\0020\\000\\000\\002\\141\\000\\238\\002\\156\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\002,\\002-\\001e\\000\\000\\002\\240\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\002\\156\\002\\139\\000\\000\\000\\000\\002\\145\\002o\\000\\000\\000\\000\\002,\\002-\\001e\\003\\128\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\002,\\002-\\001e\\000\\000\\002\\245\\003\\005\\003\\006\\002o\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\003\\137\\001\\031\\002n\\002\\154\\001 \\001\\139\\002\\144\\002\\137\\002\\145\\000\\000\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\140\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\000\\000\\001\\127\\002\\156\\000\\000\\001\\\"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\001n\\002\\148\\000\\000\\000\\238\\000\\000\\002\\139\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\002\\156\\002\\139\\000\\000\\003\\t\\004\\\"\\000\\000\\001*\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\0020\\000\\000\\002\\141\\000\\238\\002\\139\\000\\000\\002\\145\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\154\\000\\000\\000\\000\\0020\\001\\129\\002\\141\\000\\238\\002\\137\\000\\000\\000\\000\\001\\016\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\001\\023\\001$\\000\\000\\002\\145\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\002,\\002-\\001e\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\002o\\002\\148\\000\\000\\000\\000\\002\\156\\000\\000\\003\\157\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\002\\137\\001>\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\002\\139\\001%\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\002,\\002-\\001e\\002\\156\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\002\\156\\000\\000\\001.\\000\\000\\002o\\001?\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\003\\167\\000\\000\\000\\000\\002\\137\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\002,\\002-\\001e\\000\\000\\002\\139\\000\\000\\000\\000\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\0020\\003\\172\\002\\141\\000\\238\\002\\137\\000\\000\\002\\142\\002o\\002\\148\\000\\000\\000\\000\\000\\000\\000\\000\\003\\221\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\002\\156\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\139\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\002\\156\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\002,\\002-\\001e\\000\\000\\000\\000\\002\\145\\002\\142\\002o\\003\\030\\002,\\002-\\001e\\000\\000\\003\\234\\002\\154\\002n\\001\\139\\002\\144\\000\\000\\000\\000\\002\\137\\002\\145\\000\\000\\002o\\000\\000\\002,\\002-\\001e\\000\\000\\004\\028\\000\\000\\000\\000\\003c\\002\\142\\000\\000\\003\\030\\002\\137\\002\\156\\000\\000\\000\\000\\002n\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\002o\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\004r\\000\\000\\006\\006\\002\\154\\000\\000\\001\\139\\002\\144\\002\\137\\000\\000\\000\\000\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\002\\156\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\139\\000\\000\\000\\000\\000\\000\\001\\\"\\000\\000\\000\\000\\000\\000\\000\\000\\002/\\001d\\001e\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\139\\000\\000\\000\\000\\002\\145\\000\\000\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\001*\\000\\000\\000\\000\\000\\000\\004?\\000\\000\\000\\000\\002\\142\\003f\\002\\148\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\002\\145\\000\\000\\000\\000\\002\\142\\001w\\002\\148\\001x\\002L\\000\\000\\000\\000\\001\\016\\002\\154\\002\\142\\001\\139\\002\\144\\000\\000\\001\\023\\001$\\002\\156\\000\\000\\002\\143\\000\\000\\001\\139\\002\\144\\000\\000\\002,\\002-\\001e\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\000\\000\\002\\156\\000\\000\\002\\154\\001\\127\\001\\139\\002\\144\\002n\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\002o\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\005\\167\\000\\000\\002n\\000\\000\\000\\000\\002\\156\\003\\145\\002\\137\\001>\\000\\000\\002o\\002,\\002-\\001e\\000\\000\\001%\\005\\170\\000\\000\\000\\000\\005\\022\\000\\000\\000\\000\\005\\025\\002\\137\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002o\\002,\\002-\\001e\\000\\000\\000\\000\\005\\185\\000\\000\\001.\\000\\000\\000\\000\\001H\\000\\000\\002\\137\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\000\\000\\001\\129\\000\\000\\000\\000\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\001\\130\\005\\188\\001\\139\\001l\\000\\000\\002\\139\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\006E\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\139\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\006F\\000\\000\\000\\000\\006H\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\002n\\006I\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\002o\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\005\\201\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\137\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\000\\000\\002\\139\\006J\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\154\\002n\\001\\139\\002\\144\\002\\145\\000\\000\\000\\000\\000\\000\\002\\142\\002o\\002\\148\\000\\000\\000\\000\\000\\000\\000\\000\\005\\204\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\006K\\002\\137\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\006L\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\002\\139\\000\\000\\002\\156\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\006M\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\000\\000\\000\\000\\002\\156\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\006N\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006O\\000\\000\\002\\145\\000\\000\\002\\139\\006Q\\002n\\000\\000\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002o\\006S\\0020\\000\\000\\002\\141\\000\\238\\005\\225\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\002\\137\\000\\000\\000\\000\\002\\142\\006T\\002\\148\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\002n\\001\\139\\002\\144\\000\\000\\002,\\002-\\001e\\000\\000\\002o\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\005\\228\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\002\\137\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\232\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\002\\148\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\205\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\240\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\002\\139\\000\\000\\002\\205\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\002\\240\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\245\\003\\005\\003\\006\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\002\\245\\003\\005\\003\\006\\000\\000\\000\\000\\001\\127\\002\\156\\002n\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\000\\000\\000\\000\\002o\\002\\154\\001n\\001\\139\\002\\144\\000\\238\\006\\220\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\002\\137\\002\\148\\000\\000\\000\\000\\001d\\001e\\001\\127\\002\\154\\000\\000\\001\\139\\002\\144\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\003\\t\\005\\243\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\006E\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\006v\\000\\000\\001\\129\\000\\000\\003\\t\\006\\021\\006F\\000\\000\\000\\000\\006H\\001\\130\\002n\\001\\139\\001l\\002\\139\\000\\000\\000\\000\\000\\000\\006I\\002o\\001w\\000\\000\\001x\\002L\\000\\000\\006\\222\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\001\\129\\002\\137\\000\\000\\000\\000\\000\\000\\001d\\001e\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\000\\000\\000\\000\\000\\000\\000\\000\\006J\\000\\000\\001d\\001e\\000\\000\\000\\000\\001\\127\\000\\000\\000\\000\\001f\\001v\\002\\145\\001h\\001i\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\003\\145\\000\\000\\000\\000\\001\\184\\000\\000\\000\\000\\000\\000\\006K\\000\\000\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\000\\000\\006L\\002\\139\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\001w\\000\\000\\001x\\001\\143\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\001w\\000\\000\\001x\\001\\172\\006X\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\129\\000m\\000\\000\\001d\\001e\\000\\000\\006N\\001\\127\\001\\130\\000\\000\\001\\139\\001l\\002\\145\\000\\000\\000\\000\\000\\000\\006O\\000\\000\\000\\000\\001n\\001\\127\\006Q\\000\\238\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\000\\000\\006S\\001n\\001\\169\\000\\000\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\002\\148\\000\\000\\000\\000\\000\\000\\000\\000\\006T\\002\\154\\000\\000\\001\\139\\002\\144\\001d\\001e\\000\\000\\000\\000\\000\\000\\001d\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001w\\000\\000\\001x\\001\\172\\000\\000\\002\\156\\001f\\001v\\000\\000\\001h\\001i\\001f\\001v\\001\\129\\001h\\001i\\001\\174\\000\\000\\001d\\001e\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\000\\000\\001\\129\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\001\\127\\001\\130\\000\\000\\001\\139\\001l\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\001w\\000\\000\\001x\\001\\172\\003c\\001w\\000\\000\\001x\\002L\\000\\000\\000\\000\\000\\000\\000\\000\\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\\031\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\000\\000\\001w\\001\\127\\001x\\002T\\000\\000\\000\\000\\001\\127\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\001n\\000\\000\\001\\\"\\000\\238\\000\\000\\000\\000\\001\\129\\000\\000\\002,\\002-\\001e\\003\\141\\003\\252\\000\\000\\001\\130\\001\\127\\001\\139\\001l\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\006\\154\\001n\\002/\\000\\000\\000\\238\\002o\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\137\\000\\000\\000\\000\\001*\\002n\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\001\\129\\002o\\002W\\000\\000\\000\\000\\001\\129\\000\\000\\000\\000\\001\\130\\002n\\001\\139\\001l\\000\\000\\001\\130\\002\\137\\001\\139\\001l\\002o\\000\\000\\000\\000\\000\\000\\003e\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\023\\001$\\002\\137\\000\\000\\001\\129\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\000\\000\\002\\142\\000\\000\\000\\000\\000\\000\\002n\\002\\139\\000\\000\\000\\000\\002\\143\\000\\000\\001\\139\\002\\144\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\001\\031\\000\\000\\002\\137\\001 \\000\\000\\000\\000\\001>\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001%\\000\\000\\000\\000\\002,\\002-\\001e\\0020\\000\\000\\002\\141\\000\\238\\002\\139\\000\\000\\000\\000\\002\\145\\001\\\"\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002o\\001.\\000\\000\\000\\000\\004\\003\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\002\\137\\000\\000\\002\\142\\000\\000\\003\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\002\\139\\001\\139\\002\\144\\000\\000\\002\\145\\002,\\002-\\001e\\000\\000\\001*\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\142\\000\\000\\002\\150\\000\\000\\002n\\000\\000\\002\\156\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\002o\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\002\\152\\000\\000\\000\\000\\000\\000\\000\\000\\001\\016\\002\\154\\002\\137\\001\\139\\002\\144\\002\\145\\001\\023\\001$\\002\\156\\000\\000\\000\\000\\002\\139\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\002\\156\\002\\141\\000\\238\\000\\000\\002n\\000\\000\\002,\\002-\\001e\\002\\142\\000\\000\\002\\157\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\002n\\000\\000\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\001>\\002o\\000\\000\\002\\145\\002,\\002-\\001e\\001%\\000\\000\\000\\000\\000\\000\\002\\139\\002\\156\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002o\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\002\\164\\001.\\000\\000\\000\\000\\001\\225\\000\\000\\002\\154\\002\\137\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\002\\139\\002,\\002-\\001e\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002n\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002o\\002\\142\\000\\000\\002\\166\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\154\\000\\000\\001\\139\\002\\144\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\139\\002\\145\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\002,\\002-\\001e\\0020\\002\\156\\002\\141\\000\\238\\000\\000\\000\\000\\002\\145\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\002o\\002\\142\\000\\000\\002\\168\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\002\\137\\000\\000\\000\\000\\002\\145\\002\\137\\002\\142\\000\\000\\002\\170\\000\\000\\002,\\002-\\001e\\000\\000\\002\\154\\002\\139\\001\\139\\002\\144\\000\\000\\000\\000\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\002\\142\\002o\\002\\172\\000\\000\\000\\000\\002\\156\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\002\\145\\000\\000\\000\\000\\002\\139\\002\\156\\000\\000\\002n\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002o\\0020\\000\\000\\002\\141\\000\\238\\0020\\000\\000\\002\\141\\000\\238\\001\\\"\\000\\000\\000\\000\\000\\000\\002\\137\\002\\142\\000\\000\\002\\174\\000\\000\\000\\000\\002\\229\\000\\000\\000\\000\\002\\154\\001\\031\\001\\139\\002\\144\\005;\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\002\\139\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\002\\156\\0020\\000\\000\\002\\141\\000\\238\\001\\\"\\000\\000\\000\\000\\000\\000\\001*\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\002\\176\\002o\\002\\142\\000\\000\\002\\178\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\002\\154\\002\\139\\001\\139\\002\\144\\002\\137\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\001\\023\\001$\\002\\156\\000\\000\\000\\000\\005=\\002\\156\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\002\\180\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\002\\145\\000\\000\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\023\\005@\\002\\137\\000\\000\\000\\000\\001>\\002\\156\\002\\139\\000\\000\\002,\\002-\\001e\\001%\\000\\000\\000\\000\\002\\142\\002x\\002\\182\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\154\\002n\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001H\\000\\000\\000\\000\\002\\137\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\000\\000\\005A\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\002\\139\\000\\000\\005\\011\\000\\000\\005F\\000\\000\\005C\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\0020\\000\\000\\002\\141\\000\\238\\002\\142\\001.\\002\\184\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\139\\002\\145\\000\\000\\000\\000\\002\\156\\002n\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\0020\\002o\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\002\\142\\002o\\002\\186\\002,\\002-\\001e\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\002\\137\\002\\145\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\002\\156\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\002\\137\\001d\\001e\\000\\000\\002\\142\\000\\000\\002\\188\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\001f\\001\\137\\000\\000\\001h\\001i\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\156\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\002\\142\\000\\000\\002\\190\\000\\000\\002n\\000\\000\\000\\000\\002\\139\\002\\154\\002\\145\\001\\139\\002\\144\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\002\\137\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\002\\156\\000\\000\\000\\000\\002,\\002-\\001e\\002\\142\\000\\000\\002\\192\\000\\000\\000\\000\\000\\000\\001m\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\002n\\000\\000\\002\\145\\000\\000\\000\\000\\002\\142\\001n\\002\\194\\002o\\000\\238\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\002\\156\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\002\\142\\000\\000\\002\\196\\000\\000\\000\\000\\000\\000\\002\\156\\002\\139\\002\\154\\000\\000\\001\\139\\002\\144\\002n\\000\\000\\000\\000\\000\\000\\000\\000\\001d\\001e\\0020\\002o\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\002\\214\\000\\000\\000\\000\\000\\000\\000\\000\\002\\156\\000\\000\\002\\137\\002\\217\\000\\000\\001\\129\\001f\\002\\218\\000\\000\\001h\\001i\\000\\000\\000\\000\\001\\138\\000\\000\\001\\139\\001l\\001d\\001e\\000\\000\\002\\145\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\002\\214\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\0020\\002\\217\\002\\141\\000\\238\\001f\\002\\218\\000\\000\\001h\\001i\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\002\\142\\000\\000\\002\\198\\000\\000\\000\\000\\002o\\000\\000\\006E\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\002\\145\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006F\\000\\000\\0020\\006H\\002\\141\\000\\238\\002\\156\\000\\000\\000\\000\\001m\\000\\000\\000\\000\\006I\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\001n\\002\\200\\000\\000\\000\\238\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\002\\145\\002,\\002-\\001e\\000\\000\\000\\000\\001m\\006J\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002n\\002\\156\\001n\\000\\000\\002\\139\\000\\238\\002\\219\\002n\\002o\\002,\\002-\\001e\\002\\142\\000\\000\\002\\202\\002o\\0020\\000\\000\\002\\141\\000\\238\\002\\154\\002\\137\\001\\139\\002\\144\\002n\\000\\000\\002\\221\\006K\\002\\137\\000\\000\\000\\000\\001\\129\\002o\\000\\000\\000\\000\\000\\000\\006L\\002\\219\\000\\000\\001\\138\\000\\000\\001\\139\\001l\\002\\156\\000\\000\\002\\137\\000\\000\\000\\000\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\220\\000\\000\\000\\000\\006a\\000\\000\\001\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\138\\000\\000\\001\\139\\001l\\000\\000\\006N\\002\\142\\000\\000\\0032\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\002\\154\\006O\\001\\139\\002\\144\\000\\000\\002\\139\\006Q\\000\\000\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\006S\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\002\\139\\002\\156\\002,\\002-\\001e\\000\\000\\000\\000\\002,\\002-\\001e\\006T\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\002n\\000\\000\\000\\000\\002\\145\\000\\000\\002n\\000\\000\\000\\000\\002o\\000\\000\\002\\145\\000\\000\\000\\000\\002o\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\002\\145\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\0038\\000\\000\\002,\\002-\\001e\\002\\142\\002\\154\\003>\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\002n\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\003D\\002o\\000\\000\\000\\000\\000\\000\\002\\156\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\002\\156\\000\\000\\002\\137\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\000\\000\\002\\156\\002\\139\\000\\000\\000\\000\\002n\\002,\\002-\\001e\\0020\\000\\000\\002\\141\\000\\238\\002o\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\000\\000\\000\\000\\000\\000\\002\\137\\000\\000\\000\\000\\002o\\000\\000\\000\\000\\001d\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\145\\002\\137\\000\\000\\000\\000\\000\\000\\002\\145\\002\\139\\000\\000\\000\\000\\000\\000\\000\\000\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\003I\\000\\000\\000\\000\\002\\142\\000\\000\\003N\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\001\\031\\002\\139\\000\\000\\005;\\000\\000\\002\\145\\000\\000\\000\\000\\000\\000\\001w\\000\\000\\001x\\002L\\0020\\002\\156\\002\\141\\000\\238\\002\\139\\000\\000\\002\\156\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\001\\\"\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\002\\142\\000\\000\\003U\\000\\000\\000\\000\\000\\000\\002n\\000\\000\\002\\154\\001\\127\\001\\139\\002\\144\\002\\145\\000\\000\\002o\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\000\\000\\002\\137\\002\\145\\000\\000\\000\\000\\002\\156\\003\\144\\002n\\002,\\002-\\001e\\000\\000\\000\\000\\005=\\002\\142\\002o\\003Z\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\002n\\001\\139\\002\\144\\000\\000\\000\\000\\002\\137\\000\\000\\002\\142\\002o\\003_\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\001\\016\\002\\137\\002\\156\\000\\000\\001\\187\\001e\\001\\023\\005@\\000\\000\\000\\000\\005R\\000\\000\\001\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\156\\002\\139\\001\\130\\000\\000\\001\\139\\001l\\001f\\002A\\000\\000\\001h\\001i\\001d\\001e\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\005S\\000\\000\\005T\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\139\\000\\000\\000\\000\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\000\\000\\000\\000\\0020\\005A\\002\\141\\000\\238\\002\\139\\002\\145\\000\\000\\000\\000\\003\\152\\003\\005\\003\\006\\005U\\000\\000\\005\\011\\000\\000\\005E\\0020\\005C\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\000\\000\\002\\145\\002\\142\\001w\\003b\\001x\\007\\026\\000\\000\\007\\028\\000\\000\\002\\154\\001\\127\\001\\139\\002\\144\\000\\000\\005V\\000\\000\\002\\145\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\005W\\005X\\000\\238\\005Y\\000\\000\\002\\142\\000\\000\\003\\148\\000\\000\\002\\156\\000\\000\\000\\000\\001\\127\\002\\154\\000\\000\\001\\139\\002\\144\\001d\\001e\\000\\000\\000\\000\\002\\142\\000\\000\\003\\150\\001n\\000\\000\\005\\147\\000\\238\\003\\159\\002\\154\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\002\\156\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\005[\\0012\\002\\156\\000\\000\\000\\000\\005]\\005g\\000\\000\\000\\000\\001\\129\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\005\\145\\0012\\001\\130\\000\\000\\001\\139\\001l\\0013\\001\\\"\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\001Q\\000\\000\\001w\\005\\146\\001x\\006j\\001\\129\\000\\000\\0013\\001\\\"\\000\\000\\000\\000\\000\\000\\000\\000\\001\\130\\001O\\001\\139\\001l\\000\\000\\000\\000\\000\\000\\000\\000\\001\\031\\001\\\"\\000\\000\\001 \\000\\000\\000\\000\\0012\\000\\000\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\001\\127\\000\\000\\0012\\000\\000\\001*\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\0013\\001\\\"\\000\\238\\000\\000\\000\\000\\000\\000\\001*\\0014\\0018\\0013\\001\\\"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001M\\000\\000\\000\\000\\000\\000\\001*\\001\\016\\000\\000\\0018\\000\\000\\000\\000\\000\\000\\001\\023\\001$\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\023\\001$\\000\\000\\000\\000\\001*\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\001*\\001\\023\\001$\\000\\000\\001\\129\\000\\000\\000\\000\\000\\000\\0018\\000\\000\\000\\000\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\000\\000\\0018\\001>\\000\\000\\000\\000\\001\\016\\001d\\001e\\000\\000\\001%\\000\\000\\001\\023\\001$\\001F\\001\\016\\000\\000\\000\\000\\001>\\000\\000\\000\\000\\001\\023\\001$\\001d\\001e\\001%\\000\\000\\001f\\001v\\001F\\001h\\001i\\001-\\000\\000\\000\\000\\001\\031\\000\\000\\001.\\001 \\001%\\001H\\000\\000\\000\\000\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001H\\000\\000\\000\\000\\001>\\001d\\001e\\000\\000\\001\\\"\\000\\000\\000\\000\\001%\\001.\\001>\\000\\000\\001F\\001w\\000\\000\\001x\\001\\176\\001%\\000\\000\\001d\\001e\\001F\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\001w\\000\\000\\001x\\001\\164\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001H\\001f\\001v\\000\\000\\001h\\001i\\001.\\000\\000\\001\\127\\001H\\000\\000\\000\\000\\001*\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\001\\127\\000\\000\\000\\000\\001w\\000\\000\\001x\\001\\161\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\000\\000\\001\\016\\000\\000\\001w\\000\\000\\001x\\001z\\001\\023\\001$\\001d\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\127\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001f\\001v\\001n\\001h\\001i\\000\\238\\000\\000\\001\\127\\000\\000\\000\\000\\001\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\130\\001n\\001\\139\\001l\\000\\238\\000\\000\\001>\\000\\000\\001\\129\\000\\000\\000\\000\\001d\\001e\\001%\\000\\000\\000\\000\\001\\130\\005\\022\\001\\139\\001l\\006)\\000\\000\\000\\000\\000\\000\\000\\000\\001w\\000\\000\\001x\\001}\\000\\000\\000\\000\\001f\\001v\\000\\000\\001h\\001i\\001d\\001e\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001H\\001\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\001f\\001v\\001\\127\\001h\\001i\\001\\129\\001d\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\130\\001n\\001\\139\\001l\\000\\238\\001w\\000\\000\\001x\\001\\128\\000\\000\\000\\000\\000\\000\\000\\000\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\001d\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001d\\001e\\001w\\000\\000\\001x\\001\\160\\000\\000\\000\\000\\000\\000\\000\\000\\001\\127\\001f\\001v\\000\\000\\001h\\001i\\002,\\002-\\001e\\000\\000\\001f\\001v\\001n\\001h\\001i\\000\\238\\000\\000\\000\\000\\001w\\000\\000\\001x\\001\\148\\000\\000\\001\\129\\000\\000\\001\\127\\000\\000\\000\\000\\000\\000\\003\\180\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\000\\000\\003\\189\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\000\\000\\000\\000\\001w\\000\\000\\001x\\001\\156\\000\\000\\000\\000\\000\\000\\001\\127\\000\\000\\001w\\000\\000\\001x\\002d\\000\\000\\000\\000\\003\\202\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\129\\000\\000\\000\\000\\000\\000\\000\\000\\001\\127\\000\\000\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\000\\000\\000\\000\\001\\127\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\001\\129\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\002/\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\003\\193\\000\\000\\002\\141\\000\\238\\001\\002\\001d\\001e\\000\\000\\001\\129\\000\\000\\000\\000\\000\\000\\001d\\001e\\002\\236\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\000\\000\\000\\000\\002\\239\\000\\000\\000\\000\\001f\\002\\218\\000\\000\\001h\\001i\\000\\000\\000\\000\\001f\\001v\\001\\129\\001h\\001i\\003\\183\\000\\000\\000\\000\\000\\000\\000\\000\\001\\130\\001\\129\\001\\139\\001l\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\001d\\001e\\000\\000\\000\\000\\000\\000\\001d\\001e\\002\\143\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\000\\000\\001w\\000\\000\\001x\\002\\250\\000\\000\\000\\000\\001f\\001v\\000\\000\\001h\\001i\\001f\\001v\\000\\000\\001h\\001i\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001d\\001e\\000\\000\\001m\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\127\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\001f\\001v\\001n\\001h\\001i\\000\\238\\001w\\000\\000\\001x\\002\\253\\000\\000\\001w\\000\\000\\001x\\003\\000\\000\\000\\000\\000\\001d\\001e\\000\\000\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\001I\\000\\000\\000\\000\\002\\219\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\001f\\001v\\001\\127\\001h\\001i\\000\\000\\001w\\001\\127\\001x\\003\\b\\001K\\001\\\"\\000\\000\\000\\000\\001n\\000\\000\\005\\004\\000\\238\\001\\129\\001n\\003\\180\\000\\000\\000\\238\\000\\000\\000\\000\\001\\129\\001\\138\\003\\189\\001\\139\\001l\\000\\000\\001\\031\\000\\000\\001\\130\\001 \\001\\139\\001l\\001I\\000\\000\\001\\127\\000\\000\\000\\000\\000\\000\\001w\\000\\000\\001x\\004p\\000\\000\\000\\000\\000\\000\\003\\190\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\001*\\001K\\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\\0018\\001\\129\\000\\000\\001\\127\\000\\000\\000\\000\\001\\129\\000\\000\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\001\\016\\001\\130\\001n\\001\\139\\001l\\000\\238\\001\\023\\001$\\002/\\000\\000\\000\\000\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\001*\\0012\\000\\000\\003\\193\\000\\000\\002\\141\\000\\238\\001\\002\\001\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\130\\0018\\001\\139\\001l\\000\\000\\0017\\001\\\"\\000\\000\\000\\000\\000\\000\\000\\000\\001d\\001e\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\001>\\001\\023\\001$\\001\\031\\000\\000\\003\\183\\001 \\001%\\000\\000\\004(\\001\\129\\005:\\001f\\002\\218\\000\\000\\001h\\001i\\000\\000\\001\\130\\000\\000\\001\\139\\001l\\001d\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\001\\\"\\000\\000\\001*\\000\\000\\001.\\000\\000\\002\\143\\001H\\001\\139\\002\\144\\000\\000\\000\\000\\001f\\002\\218\\000\\000\\001h\\001i\\001>\\000\\000\\0018\\001d\\001e\\000\\000\\000\\000\\001%\\000\\000\\000\\000\\000\\000\\001F\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\023\\001$\\001f\\002\\218\\000\\000\\001h\\001i\\001*\\000\\000\\000\\000\\001d\\001e\\000\\000\\001.\\000\\000\\000\\000\\001H\\000\\000\\000\\000\\000\\000\\001m\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001d\\001e\\001f\\002\\218\\001n\\001h\\001i\\000\\238\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\023\\001$\\000\\000\\001>\\000\\000\\001f\\002\\218\\001m\\001h\\001i\\001%\\000\\000\\000\\000\\000\\000\\001F\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\002\\219\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001m\\000\\000\\001.\\000\\000\\000\\000\\001H\\001d\\001e\\000\\000\\000\\000\\000\\000\\001>\\001n\\000\\000\\001\\129\\000\\238\\000\\000\\000\\000\\001%\\003\\129\\000\\000\\000\\000\\001\\138\\005\\205\\001\\139\\001l\\001f\\002\\218\\001m\\001h\\001i\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001d\\001e\\003\\131\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\001\\129\\001.\\001m\\003\\129\\001\\227\\000\\000\\001d\\001e\\001\\138\\005\\229\\001\\139\\001l\\001f\\002\\218\\001n\\001h\\001i\\000\\238\\000\\000\\000\\000\\001d\\001e\\003\\130\\000\\000\\000\\000\\000\\000\\001f\\002\\218\\001\\129\\001h\\001i\\003\\129\\000\\000\\000\\000\\000\\000\\000\\000\\001\\138\\000\\000\\001\\139\\001l\\001f\\002\\218\\000\\000\\001h\\001i\\000\\000\\000\\000\\000\\000\\000\\000\\0068\\003\\134\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\129\\000\\000\\001m\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\138\\000\\000\\001\\139\\001l\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\001\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\138\\000\\000\\001\\139\\001l\\000\\000\\000\\000\\001m\\000\\000\\000\\000\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\006:\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\001m\\000\\238\\000\\000\\002\\219\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\000\\000\\001m\\000\\238\\000\\000\\001\\\"\\000\\000\\000\\000\\001d\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\001n\\004\\127\\001\\129\\000\\238\\000\\000\\000\\000\\000\\000\\002\\219\\000\\000\\000\\000\\001\\138\\000\\000\\001\\139\\001l\\001f\\002\\218\\006\\215\\001h\\001i\\000\\000\\000\\000\\006\\000\\000\\000\\000\\000\\001d\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\129\\000\\000\\000\\000\\006\\000\\001*\\000\\000\\000\\000\\000\\000\\001\\138\\000\\000\\001\\139\\001l\\001f\\002\\218\\001\\129\\001h\\001i\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\138\\001\\031\\001\\139\\001l\\001 \\000\\000\\001\\129\\000\\000\\000\\000\\001d\\001e\\000\\000\\001\\016\\006\\r\\001\\138\\000\\000\\001\\139\\001l\\001\\023\\001$\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\012\\001\\\"\\001f\\002\\218\\000\\000\\001h\\001i\\000\\000\\000\\000\\001m\\000\\000\\004\\127\\000\\000\\000\\000\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\004\\130\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001>\\000\\000\\001m\\000\\000\\000\\000\\001\\\"\\000\\000\\001%\\000\\000\\001*\\000\\000\\004\\136\\005R\\000\\000\\001n\\004\\127\\000\\000\\000\\238\\001\\\"\\0068\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\127\\000\\000\\004\\249\\000\\000\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001H\\000\\000\\001\\016\\005S\\001m\\005T\\005\\202\\001\\129\\001\\023\\001$\\000\\000\\000\\000\\0068\\001*\\000\\000\\001\\138\\001n\\001\\139\\001l\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001*\\000\\000\\000\\000\\0069\\000\\000\\000\\000\\000\\000\\000\\000\\005U\\000\\000\\000\\000\\001\\129\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\001\\138\\000\\000\\001\\139\\001l\\001\\023\\001$\\003\\133\\000\\000\\000\\000\\001>\\001\\031\\001\\016\\000\\000\\001 \\006A\\000\\000\\001%\\001\\023\\001$\\000\\000\\004\\136\\000\\000\\000\\000\\000\\000\\005V\\000\\000\\000\\000\\001\\031\\000\\000\\001\\031\\001 \\001\\129\\001 \\005W\\005X\\000\\000\\005Y\\001\\\"\\000\\000\\001\\138\\000\\000\\001\\139\\001l\\001.\\000\\000\\000\\000\\001H\\004\\127\\001d\\001e\\001>\\000\\000\\000\\000\\000\\000\\001\\\"\\000\\000\\001\\\"\\001%\\000\\000\\005Z\\000\\000\\004\\136\\005\\216\\001>\\004\\127\\000\\000\\003\\252\\000\\000\\001f\\002\\211\\001%\\001h\\001i\\000\\000\\004\\136\\000\\000\\000\\000\\000\\000\\001\\031\\005\\226\\003\\255\\001 \\001*\\005[\\001.\\000\\000\\000\\000\\001H\\005]\\005g\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\001.\\005\\145\\001*\\001H\\001*\\000\\000\\000\\000\\000\\000\\001\\\"\\000\\000\\000\\000\\000\\000\\000\\000\\005\\004\\000\\000\\001\\016\\000\\000\\005\\146\\000\\000\\000\\000\\004.\\001\\023\\001$\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\001\\023\\001$\\001\\023\\001$\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\001m\\000\\000\\000\\000\\000\\000\\001\\\"\\001\\031\\001*\\000\\000\\001 \\005\\251\\000\\000\\000\\000\\001n\\000\\000\\000\\000\\000\\238\\000\\000\\000\\000\\000\\000\\000\\000\\001>\\000\\000\\001\\\"\\000\\000\\000\\000\\000\\000\\001\\031\\001%\\000\\000\\001 \\000\\000\\004\\136\\001\\\"\\000\\000\\000\\000\\000\\000\\001\\016\\001>\\000\\000\\001>\\000\\000\\000\\000\\001\\023\\001$\\001%\\000\\000\\001%\\002/\\004\\136\\001*\\000\\000\\000\\000\\000\\000\\001\\\"\\001.\\000\\000\\000\\000\\001H\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\006\\254\\000\\000\\001\\031\\000\\000\\001*\\001 \\000\\000\\000\\000\\001.\\001\\129\\001.\\001H\\000\\000\\004\\003\\001*\\000\\000\\001\\016\\001\\138\\000\\000\\001\\139\\001l\\000\\000\\001\\023\\001$\\000\\000\\001>\\000\\000\\001\\031\\000\\000\\001\\\"\\001 \\000\\000\\001%\\000\\000\\001\\016\\001*\\005\\t\\001<\\000\\000\\000\\000\\001\\023\\001$\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\023\\001$\\000\\000\\000\\000\\001\\\"\\000\\000\\002\\142\\000\\000\\000\\000\\001.\\001\\031\\000\\000\\001H\\001 \\002\\143\\001\\016\\001\\139\\002\\144\\001>\\000\\000\\000\\000\\001\\023\\001$\\000\\000\\001*\\001%\\000\\000\\000\\000\\000\\000\\005\\t\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001>\\001\\\"\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\001%\\000\\000\\000\\000\\001>\\006\\255\\000\\000\\001*\\000\\000\\000\\000\\001.\\001%\\001\\016\\001H\\000\\000\\001X\\000\\000\\000\\000\\001\\023\\001$\\000\\000\\000\\000\\000\\000\\000\\000\\001\\\"\\001>\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001H\\001%\\002,\\002-\\001e\\001\\151\\001\\016\\001.\\001\\031\\001*\\001H\\001 \\001\\023\\001$\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\003\\197\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001H\\000\\000\\001>\\000\\000\\001\\\"\\000\\000\\000\\000\\001*\\001\\016\\001%\\000\\000\\000\\000\\000\\000\\002.\\001\\023\\001$\\000\\000\\000\\000\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\000\\000\\000\\000\\001>\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001%\\000\\000\\001.\\001\\016\\001\\192\\001D\\000\\000\\000\\000\\000\\000\\001\\023\\001$\\000\\000\\001\\\"\\000\\000\\000\\000\\001*\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001>\\001.\\000\\000\\000\\000\\001H\\000\\000\\000\\000\\001%\\002/\\000\\000\\000\\000\\001\\230\\000\\000\\000\\000\\000\\000\\002i\\000\\000\\000\\000\\000\\000\\001\\016\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\001\\023\\001$\\002/\\000\\000\\001>\\001\\031\\001*\\000\\000\\001 \\001.\\000\\000\\001%\\001H\\000\\000\\0020\\001\\232\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\001\\\"\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\001.\\000\\000\\000\\000\\001H\\001\\023\\001$\\002k\\000\\000\\001>\\000\\000\\001\\031\\002\\129\\000\\000\\001 \\000\\000\\001%\\000\\000\\002\\142\\000\\000\\002C\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\143\\002/\\001\\139\\002\\144\\000\\000\\002,\\002-\\001e\\000\\000\\000\\000\\000\\000\\002\\142\\001\\\"\\0020\\001*\\002\\141\\000\\238\\001.\\000\\000\\002\\143\\001H\\001\\139\\002\\144\\000\\000\\000\\000\\001>\\000\\000\\000\\000\\002\\140\\000\\000\\000\\000\\000\\000\\001%\\000\\000\\000\\000\\000\\000\\002V\\000\\000\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\001\\031\\001\\023\\001$\\001 \\000\\000\\000\\000\\002/\\000\\000\\001*\\000\\000\\001.\\002/\\000\\000\\001H\\000\\000\\000\\000\\000\\000\\001\\\"\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\0020\\002\\142\\002\\141\\000\\238\\001\\\"\\000\\000\\002,\\002-\\001e\\002\\143\\000\\000\\001\\139\\002\\144\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\023\\001$\\000\\000\\001>\\000\\000\\000\\000\\000\\000\\000\\000\\002\\155\\002/\\001%\\000\\000\\000\\000\\000\\000\\002u\\000\\000\\001\\031\\000\\000\\001*\\001 \\000\\000\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\000\\000\\000\\000\\001*\\002,\\002-\\001e\\000\\000\\000\\000\\002\\142\\000\\000\\000\\000\\001.\\000\\000\\002\\142\\001H\\000\\000\\002\\143\\001\\\"\\001\\139\\002\\144\\001>\\002\\143\\001\\016\\001\\139\\002\\144\\000\\000\\003+\\001%\\001\\023\\001$\\000\\000\\002z\\001\\016\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\001\\023\\001$\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\001\\031\\000\\000\\000\\000\\001 \\001.\\002\\142\\002/\\001H\\000\\000\\000\\000\\001\\\"\\000\\000\\001*\\002\\143\\000\\000\\001\\139\\002\\144\\000\\000\\0020\\000\\000\\002\\141\\000\\238\\001\\\"\\000\\000\\001>\\000\\000\\000\\000\\001\\\"\\000\\000\\000\\000\\000\\000\\001%\\000\\000\\000\\000\\001>\\002\\226\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001%\\001\\016\\001\\031\\000\\000\\002\\233\\001 \\000\\000\\001\\023\\001$\\002/\\000\\000\\000\\000\\000\\000\\000\\000\\001*\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001H\\0020\\000\\000\\002\\141\\000\\238\\000\\000\\001*\\001.\\000\\000\\001\\\"\\001H\\001*\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\016\\002\\143\\001\\031\\001\\139\\002\\144\\001 \\001\\023\\001$\\000\\000\\001>\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\001%\\001\\016\\001\\023\\001$\\002\\242\\000\\000\\001\\031\\001\\023\\001$\\005;\\000\\000\\000\\000\\000\\000\\001\\\"\\001*\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\002\\142\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001.\\000\\000\\002\\143\\001H\\001\\139\\002\\144\\001\\\"\\001\\031\\000\\000\\001>\\005;\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001%\\001\\016\\000\\000\\000\\000\\004\\129\\001>\\000\\000\\001\\023\\001$\\000\\000\\001>\\001\\031\\001%\\000\\000\\005;\\001*\\004\\226\\001%\\001\\\"\\000\\000\\000\\000\\004\\238\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001H\\000\\000\\000\\000\\000\\000\\000\\000\\005=\\000\\000\\000\\000\\001\\\"\\001.\\001\\031\\000\\000\\001H\\001 \\001.\\001\\016\\000\\000\\001H\\000\\000\\000\\000\\000\\000\\001\\023\\001$\\001>\\001\\031\\000\\000\\000\\000\\001 \\000\\000\\000\\000\\001%\\000\\000\\000\\000\\005=\\005\\b\\001\\016\\000\\000\\001\\\"\\000\\000\\000\\000\\000\\000\\001\\023\\005@\\000\\000\\001\\031\\000\\000\\000\\000\\005;\\000\\000\\000\\000\\000\\000\\001\\\"\\000\\000\\005=\\000\\000\\000\\000\\000\\000\\001.\\000\\000\\001\\031\\001H\\000\\000\\001 \\001\\016\\000\\000\\000\\000\\000\\000\\001>\\000\\000\\001\\023\\005@\\001\\\"\\000\\000\\000\\000\\001%\\000\\000\\000\\000\\000\\000\\005\\024\\000\\000\\000\\000\\000\\000\\001*\\001\\016\\000\\000\\000\\000\\001\\\"\\000\\000\\001\\031\\001\\023\\005@\\005;\\000\\000\\000\\000\\005A\\000\\000\\001*\\000\\000\\000\\000\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001H\\000\\000\\005\\011\\000\\000\\005D\\000\\000\\005C\\000\\000\\001\\016\\000\\000\\001\\031\\001\\\"\\005=\\001 \\001\\023\\001$\\000\\000\\001.\\005A\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\001*\\001\\023\\001$\\005\\011\\000\\000\\005B\\000\\000\\005C\\000\\000\\000\\000\\001\\\"\\005A\\000\\000\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001\\023\\005@\\005\\011\\000\\000\\005N\\000\\000\\005C\\000\\000\\005=\\001\\016\\000\\000\\000\\000\\001>\\000\\000\\000\\000\\001\\023\\001$\\001.\\000\\000\\001%\\000\\000\\000\\000\\000\\000\\005\\181\\001\\031\\000\\000\\001>\\001 \\000\\000\\001\\031\\000\\000\\000\\000\\001 \\001%\\001*\\000\\000\\000\\000\\005\\199\\001\\016\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\023\\005@\\001.\\001\\031\\000\\000\\001H\\001 \\001\\\"\\000\\000\\005A\\000\\000\\000\\000\\001\\\"\\000\\000\\000\\000\\000\\000\\001.\\001>\\000\\000\\001H\\001\\016\\005\\011\\000\\000\\006\\027\\001%\\005C\\001\\023\\001$\\005\\223\\001\\031\\001\\\"\\000\\000\\001 \\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\\001.\\001*\\005A\\001H\\000\\000\\001\\\"\\001*\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\005\\011\\000\\000\\0065\\000\\000\\005C\\000\\000\\000\\000\\001>\\000\\000\\000\\000\\001*\\000\\000\\000\\000\\000\\000\\001%\\001.\\000\\000\\001\\016\\006m\\000\\000\\000\\000\\000\\000\\001\\016\\001\\023\\001$\\000\\000\\000\\000\\000\\000\\001\\023\\001$\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001*\\000\\000\\000\\000\\000\\000\\001\\016\\001.\\000\\000\\000\\000\\001H\\000\\000\\001\\023\\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\\000\\000\\000\\000\\000\\001\\016\\000\\000\\000\\000\\001>\\000\\000\\000\\000\\001\\023\\001$\\001>\\000\\000\\001%\\000\\000\\000\\000\\000\\000\\006\\175\\001%\\000\\000\\000\\000\\000\\000\\006\\179\\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\\001%\\000\\000\\000\\000\\000\\000\\001.\\000\\000\\000\\000\\001H\\000\\000\\001.\\000\\000\\000\\000\\001H\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\168\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001%\\001.\\000\\000\\000\\000\\003\\254\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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.\"))\n \n and semantic_action =\n [|\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3763 \"parsing/parser.mly\"\n ( \"+\" )\n# 1380 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3764 \"parsing/parser.mly\"\n ( \"+.\" )\n# 1405 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = \n# 3316 \"parsing/parser.mly\"\n ( _1 )\n# 1430 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = tyvar;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_tyvar_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_tyvar_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let tyvar : (Asttypes.label) = Obj.magic tyvar in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_ty_ in\n let _endpos = _endpos_tyvar_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 = \n# 3319 \"parsing/parser.mly\"\n ( Ptyp_alias(ty, tyvar) )\n# 1477 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_tyvar_, _startpos_ty_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 1486 \"parsing/parser.ml\"\n \n in\n \n# 3321 \"parsing/parser.mly\"\n ( _1 )\n# 1492 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let body : (Parsetree.pattern * Parsetree.expression * bool) = Obj.magic body in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (let_binding) = let attrs2 =\n let _1 = _1_inlined2 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 1540 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined2_ in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 1549 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2567 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n mklb ~loc:_sloc false body attrs\n )\n# 1561 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3647 \"parsing/parser.mly\"\n ( _1 )\n# 1586 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3648 \"parsing/parser.mly\"\n ( Lident _1 )\n# 1611 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.core_type) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.core_type) = \n# 3377 \"parsing/parser.mly\"\n ( _2 )\n# 1650 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined3 : (Parsetree.module_type) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.core_type) = let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3437 \"parsing/parser.mly\"\n ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in\n let descr = Ptyp_package (lid, cstrs) in\n mktyp ~loc:_sloc ~attrs descr )\n# 1717 \"parsing/parser.ml\"\n \n in\n let _3 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 1727 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 1733 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3379 \"parsing/parser.mly\"\n ( wrap_typ_attrs ~loc:_sloc (reloc_typ ~loc:_sloc _4) _3 )\n# 1742 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Asttypes.label) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 = \n# 3382 \"parsing/parser.mly\"\n ( Ptyp_var _2 )\n# 1775 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 1784 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 1790 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 = \n# 3384 \"parsing/parser.mly\"\n ( Ptyp_any )\n# 1816 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 1824 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 1830 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let tid =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 1861 \"parsing/parser.ml\"\n \n in\n let tys = \n# 3429 \"parsing/parser.mly\"\n ( [] )\n# 1867 \"parsing/parser.ml\"\n in\n \n# 3387 \"parsing/parser.mly\"\n ( Ptyp_constr(tid, tys) )\n# 1872 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 1881 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 1887 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_ty_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let tid =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 1925 \"parsing/parser.ml\"\n \n in\n let tys = \n# 3431 \"parsing/parser.mly\"\n ( [ty] )\n# 1931 \"parsing/parser.ml\"\n in\n \n# 3387 \"parsing/parser.mly\"\n ( Ptyp_constr(tid, tys) )\n# 1936 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos_ty_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 1946 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 1952 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _3 : unit = Obj.magic _3 in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let tid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 2005 \"parsing/parser.ml\"\n \n in\n let tys =\n let tys =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 2013 \"parsing/parser.ml\"\n in\n \n# 1049 \"parsing/parser.mly\"\n ( xs )\n# 2018 \"parsing/parser.ml\"\n \n in\n \n# 3433 \"parsing/parser.mly\"\n ( tys )\n# 2024 \"parsing/parser.ml\"\n \n in\n \n# 3387 \"parsing/parser.mly\"\n ( Ptyp_constr(tid, tys) )\n# 2030 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2040 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2046 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.object_field list * Asttypes.closed_flag) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 = \n# 3389 \"parsing/parser.mly\"\n ( let (f, c) = _2 in Ptyp_object (f, c) )\n# 2086 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2095 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2101 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 = \n# 3391 \"parsing/parser.mly\"\n ( Ptyp_object ([], Closed) )\n# 2134 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2143 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2149 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _2 : unit = Obj.magic _2 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__2_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let cid =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 2187 \"parsing/parser.ml\"\n \n in\n let tys = \n# 3429 \"parsing/parser.mly\"\n ( [] )\n# 2193 \"parsing/parser.ml\"\n in\n \n# 3395 \"parsing/parser.mly\"\n ( Ptyp_class(cid, tys) )\n# 2198 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2208 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2214 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _2 : unit = Obj.magic _2 in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_ty_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let cid =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 2259 \"parsing/parser.ml\"\n \n in\n let tys = \n# 3431 \"parsing/parser.mly\"\n ( [ty] )\n# 2265 \"parsing/parser.ml\"\n in\n \n# 3395 \"parsing/parser.mly\"\n ( Ptyp_class(cid, tys) )\n# 2270 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos_ty_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2280 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2286 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _3 : unit = Obj.magic _3 in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let cid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 2346 \"parsing/parser.ml\"\n \n in\n let tys =\n let tys =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 2354 \"parsing/parser.ml\"\n in\n \n# 1049 \"parsing/parser.mly\"\n ( xs )\n# 2359 \"parsing/parser.ml\"\n \n in\n \n# 3433 \"parsing/parser.mly\"\n ( tys )\n# 2365 \"parsing/parser.ml\"\n \n in\n \n# 3395 \"parsing/parser.mly\"\n ( Ptyp_class(cid, tys) )\n# 2371 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2381 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2387 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.row_field) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 = \n# 3398 \"parsing/parser.mly\"\n ( Ptyp_variant([_2], Closed, None) )\n# 2427 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2436 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2442 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let xs : (Parsetree.row_field list) = Obj.magic xs in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let _3 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 2492 \"parsing/parser.ml\"\n in\n \n# 1021 \"parsing/parser.mly\"\n ( xs )\n# 2497 \"parsing/parser.ml\"\n \n in\n \n# 3443 \"parsing/parser.mly\"\n ( _1 )\n# 2503 \"parsing/parser.ml\"\n \n in\n \n# 3400 \"parsing/parser.mly\"\n ( Ptyp_variant(_3, Closed, None) )\n# 2509 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2519 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2525 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let xs : (Parsetree.row_field list) = Obj.magic xs in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.row_field) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let _4 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 2582 \"parsing/parser.ml\"\n in\n \n# 1021 \"parsing/parser.mly\"\n ( xs )\n# 2587 \"parsing/parser.ml\"\n \n in\n \n# 3443 \"parsing/parser.mly\"\n ( _1 )\n# 2593 \"parsing/parser.ml\"\n \n in\n \n# 3402 \"parsing/parser.mly\"\n ( Ptyp_variant(_2 :: _4, Closed, None) )\n# 2599 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2609 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2615 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let xs : (Parsetree.row_field list) = Obj.magic xs in\n let _2 : (unit option) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let _3 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 2665 \"parsing/parser.ml\"\n in\n \n# 1021 \"parsing/parser.mly\"\n ( xs )\n# 2670 \"parsing/parser.ml\"\n \n in\n \n# 3443 \"parsing/parser.mly\"\n ( _1 )\n# 2676 \"parsing/parser.ml\"\n \n in\n \n# 3404 \"parsing/parser.mly\"\n ( Ptyp_variant(_3, Open, None) )\n# 2682 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2692 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2698 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 = \n# 3406 \"parsing/parser.mly\"\n ( Ptyp_variant([], Open, None) )\n# 2731 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2740 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2746 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let xs : (Parsetree.row_field list) = Obj.magic xs in\n let _2 : (unit option) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let _3 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 2796 \"parsing/parser.ml\"\n in\n \n# 1021 \"parsing/parser.mly\"\n ( xs )\n# 2801 \"parsing/parser.ml\"\n \n in\n \n# 3443 \"parsing/parser.mly\"\n ( _1 )\n# 2807 \"parsing/parser.ml\"\n \n in\n \n# 3408 \"parsing/parser.mly\"\n ( Ptyp_variant(_3, Closed, Some []) )\n# 2813 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2823 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2829 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _6 : unit = Obj.magic _6 in\n let xs_inlined1 : (Asttypes.label list) = Obj.magic xs_inlined1 in\n let _4 : unit = Obj.magic _4 in\n let xs : (Parsetree.row_field list) = Obj.magic xs in\n let _2 : (unit option) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__6_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let _5 =\n let xs = xs_inlined1 in\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 2894 \"parsing/parser.ml\"\n in\n \n# 989 \"parsing/parser.mly\"\n ( xs )\n# 2899 \"parsing/parser.ml\"\n \n in\n \n# 3471 \"parsing/parser.mly\"\n ( _1 )\n# 2905 \"parsing/parser.ml\"\n \n in\n let _3 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 2913 \"parsing/parser.ml\"\n in\n \n# 1021 \"parsing/parser.mly\"\n ( xs )\n# 2918 \"parsing/parser.ml\"\n \n in\n \n# 3443 \"parsing/parser.mly\"\n ( _1 )\n# 2924 \"parsing/parser.ml\"\n \n in\n \n# 3410 \"parsing/parser.mly\"\n ( Ptyp_variant(_3, Closed, Some _5) )\n# 2930 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__6_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2940 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2946 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.extension) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 = \n# 3412 \"parsing/parser.mly\"\n ( Ptyp_extension _1 )\n# 2972 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 2980 \"parsing/parser.ml\"\n \n in\n \n# 3414 \"parsing/parser.mly\"\n ( _1 )\n# 2986 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (string) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string Asttypes.loc) = let _1 =\n let _1 = \n# 3830 \"parsing/parser.mly\"\n ( _1 )\n# 3012 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 917 \"parsing/parser.mly\"\n ( mkloc _1 (make_loc _sloc) )\n# 3020 \"parsing/parser.ml\"\n \n in\n \n# 3832 \"parsing/parser.mly\"\n ( _1 )\n# 3026 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (string Asttypes.loc) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (string) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (string Asttypes.loc) = let _1 =\n let _1 = \n# 3831 \"parsing/parser.mly\"\n ( _1 ^ \".\" ^ _3.txt )\n# 3066 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 917 \"parsing/parser.mly\"\n ( mkloc _1 (make_loc _sloc) )\n# 3075 \"parsing/parser.ml\"\n \n in\n \n# 3832 \"parsing/parser.mly\"\n ( _1 )\n# 3081 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.payload) = Obj.magic _3 in\n let _2 : (string Asttypes.loc) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.attribute) = let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3836 \"parsing/parser.mly\"\n ( Attr.mk ~loc:(make_loc _sloc) _2 _3 )\n# 3130 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.class_expr) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.class_expr) = \n# 1872 \"parsing/parser.mly\"\n ( _1 )\n# 3155 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.class_expr) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.class_expr) = let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 3196 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1874 \"parsing/parser.mly\"\n ( wrap_class_attrs ~loc:_sloc _3 _2 )\n# 3205 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.class_expr) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (let_bindings) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.class_expr) = let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1876 \"parsing/parser.mly\"\n ( class_of_let_bindings ~loc:_sloc _1 _3 )\n# 3247 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : (Parsetree.class_expr) = Obj.magic _7 in\n let _6 : unit = Obj.magic _6 in\n let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.class_expr) = let _5 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 3312 \"parsing/parser.ml\"\n \n in\n let _endpos__5_ = _endpos__1_inlined2_ in\n let _4 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 3321 \"parsing/parser.ml\"\n \n in\n let _3 = \n# 3755 \"parsing/parser.mly\"\n ( Fresh )\n# 3327 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__7_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1878 \"parsing/parser.mly\"\n ( let loc = (_startpos__2_, _endpos__5_) in\n let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in\n mkclass ~loc:_sloc ~attrs:_4 (Pcl_open(od, _7)) )\n# 3337 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : (Parsetree.class_expr) = Obj.magic _7 in\n let _6 : unit = Obj.magic _6 in\n let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.class_expr) = let _5 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 3409 \"parsing/parser.ml\"\n \n in\n let _endpos__5_ = _endpos__1_inlined3_ in\n let _4 =\n let _1 = _1_inlined2 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 3418 \"parsing/parser.ml\"\n \n in\n let _3 = \n# 3756 \"parsing/parser.mly\"\n ( Override )\n# 3424 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__7_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1878 \"parsing/parser.mly\"\n ( let loc = (_startpos__2_, _endpos__5_) in\n let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in\n mkclass ~loc:_sloc ~attrs:_4 (Pcl_open(od, _7)) )\n# 3434 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.attribute) = Obj.magic _2 in\n let _1 : (Parsetree.class_expr) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.class_expr) = \n# 1882 \"parsing/parser.mly\"\n ( Cl.attr _1 _2 )\n# 3466 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : ((Asttypes.arg_label * Parsetree.expression) list) = Obj.magic xs in\n let _1 : (Parsetree.class_expr) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.class_expr) = let _1 =\n let _1 =\n let _2 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 3501 \"parsing/parser.ml\"\n in\n \n# 989 \"parsing/parser.mly\"\n ( xs )\n# 3506 \"parsing/parser.ml\"\n \n in\n \n# 1885 \"parsing/parser.mly\"\n ( Pcl_apply(_1, _2) )\n# 3512 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_xs_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 940 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc _1 )\n# 3522 \"parsing/parser.ml\"\n \n in\n \n# 1888 \"parsing/parser.mly\"\n ( _1 )\n# 3528 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.extension) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.class_expr) = let _1 =\n let _1 = \n# 1887 \"parsing/parser.mly\"\n ( Pcl_extension _1 )\n# 3554 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 940 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc _1 )\n# 3562 \"parsing/parser.ml\"\n \n in\n \n# 1888 \"parsing/parser.mly\"\n ( _1 )\n# 3568 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = self;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_self_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_self_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let self : (string Asttypes.loc option) = Obj.magic self in\n let _4 : (Parsetree.class_expr) = Obj.magic _4 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.class_field) = let _6 =\n let _1 = _1_inlined2 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 3623 \"parsing/parser.ml\"\n \n in\n let _endpos__6_ = _endpos__1_inlined2_ in\n let _3 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 3632 \"parsing/parser.ml\"\n \n in\n let _2 = \n# 3755 \"parsing/parser.mly\"\n ( Fresh )\n# 3638 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__6_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1937 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n mkcf ~loc:_sloc (Pcf_inherit (_2, _4, self)) ~attrs:(_3@_6) ~docs )\n# 3647 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = self;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_self_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_self_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let self : (string Asttypes.loc option) = Obj.magic self in\n let _4 : (Parsetree.class_expr) = Obj.magic _4 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.class_field) = let _6 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 3709 \"parsing/parser.ml\"\n \n in\n let _endpos__6_ = _endpos__1_inlined3_ in\n let _3 =\n let _1 = _1_inlined2 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 3718 \"parsing/parser.ml\"\n \n in\n let _2 = \n# 3756 \"parsing/parser.mly\"\n ( Override )\n# 3724 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__6_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1937 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n mkcf ~loc:_sloc (Pcf_inherit (_2, _4, self)) ~attrs:(_3@_6) ~docs )\n# 3733 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : ((Asttypes.label Asttypes.loc * Asttypes.mutable_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.class_field) = let _3 =\n let _1 = _1_inlined1 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 3776 \"parsing/parser.ml\"\n \n in\n let _endpos__3_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1940 \"parsing/parser.mly\"\n ( let v, attrs = _2 in\n let docs = symbol_docs _sloc in\n mkcf ~loc:_sloc (Pcf_val v) ~attrs:(attrs@_3) ~docs )\n# 3788 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : ((Asttypes.label Asttypes.loc * Asttypes.private_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.class_field) = let _3 =\n let _1 = _1_inlined1 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 3831 \"parsing/parser.ml\"\n \n in\n let _endpos__3_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1944 \"parsing/parser.mly\"\n ( let meth, attrs = _2 in\n let docs = symbol_docs _sloc in\n mkcf ~loc:_sloc (Pcf_method meth) ~attrs:(attrs@_3) ~docs )\n# 3843 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _3 : (Parsetree.core_type * Parsetree.core_type) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.class_field) = let _4 =\n let _1 = _1_inlined2 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 3891 \"parsing/parser.ml\"\n \n in\n let _endpos__4_ = _endpos__1_inlined2_ in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 3900 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1948 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n mkcf ~loc:_sloc (Pcf_constraint _3) ~attrs:(_2@_4) ~docs )\n# 3910 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.class_field) = let _4 =\n let _1 = _1_inlined2 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 3958 \"parsing/parser.ml\"\n \n in\n let _endpos__4_ = _endpos__1_inlined2_ in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 3967 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1951 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n mkcf ~loc:_sloc (Pcf_initializer _3) ~attrs:(_2@_4) ~docs )\n# 3977 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : (Parsetree.extension) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.class_field) = let _2 =\n let _1 = _1_inlined1 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 4011 \"parsing/parser.ml\"\n \n in\n let _endpos__2_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1954 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n mkcf ~loc:_sloc (Pcf_extension _1) ~attrs:_2 ~docs )\n# 4022 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.attribute) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.class_field) = let _1 =\n let _1 = \n# 1957 \"parsing/parser.mly\"\n ( Pcf_attribute _1 )\n# 4048 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 938 \"parsing/parser.mly\"\n ( mkcf ~loc:_sloc _1 )\n# 4056 \"parsing/parser.ml\"\n \n in\n \n# 1958 \"parsing/parser.mly\"\n ( _1 )\n# 4062 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.class_expr) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.class_expr) = \n# 1852 \"parsing/parser.mly\"\n ( _2 )\n# 4094 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : (Parsetree.class_expr) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.class_type) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.class_expr) = let _1 =\n let _1 = \n# 1855 \"parsing/parser.mly\"\n ( Pcl_constraint(_4, _2) )\n# 4141 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 940 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc _1 )\n# 4150 \"parsing/parser.ml\"\n \n in\n \n# 1858 \"parsing/parser.mly\"\n ( _1 )\n# 4156 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.class_expr) = Obj.magic _2 in\n let _1 : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.class_expr) = let _1 =\n let _1 = \n# 1857 \"parsing/parser.mly\"\n ( let (l,o,p) = _1 in Pcl_fun(l, o, p, _2) )\n# 4189 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 940 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc _1 )\n# 4198 \"parsing/parser.ml\"\n \n in\n \n# 1858 \"parsing/parser.mly\"\n ( _1 )\n# 4204 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e : (Parsetree.class_expr) = Obj.magic e in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_e_ in\n let _v : (Parsetree.class_expr) = let _1 =\n let _1 = \n# 1913 \"parsing/parser.mly\"\n ( let (l,o,p) = _1 in Pcl_fun(l, o, p, e) )\n# 4244 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos_e_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 940 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc _1 )\n# 4253 \"parsing/parser.ml\"\n \n in\n \n# 1914 \"parsing/parser.mly\"\n ( _1 )\n# 4259 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let e : (Parsetree.class_expr) = Obj.magic e in\n let _1 : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_e_ in\n let _v : (Parsetree.class_expr) = let _1 =\n let _1 = \n# 1913 \"parsing/parser.mly\"\n ( let (l,o,p) = _1 in Pcl_fun(l, o, p, e) )\n# 4292 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos_e_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 940 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc _1 )\n# 4301 \"parsing/parser.ml\"\n \n in\n \n# 1914 \"parsing/parser.mly\"\n ( _1 )\n# 4307 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3637 \"parsing/parser.mly\"\n ( _1 )\n# 4332 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1922 \"parsing/parser.mly\"\n ( reloc_pat ~loc:_sloc _2 )\n# 4374 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.core_type) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 = \n# 1924 \"parsing/parser.mly\"\n ( Ppat_constraint(_2, _4) )\n# 4428 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 4437 \"parsing/parser.ml\"\n \n in\n \n# 1925 \"parsing/parser.mly\"\n ( _1 )\n# 4443 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.pattern) = let _endpos = _endpos__0_ in\n let _symbolstartpos = _endpos in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1927 \"parsing/parser.mly\"\n ( ghpat ~loc:_sloc Ppat_any )\n# 4464 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.core_type) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.core_type) = \n# 2052 \"parsing/parser.mly\"\n ( _2 )\n# 4503 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 = \n# 2053 \"parsing/parser.mly\"\n ( Ptyp_any )\n# 4522 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__0_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _endpos in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 4531 \"parsing/parser.ml\"\n \n in\n \n# 2054 \"parsing/parser.mly\"\n ( _1 )\n# 4537 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _3 : (Parsetree.class_type) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.class_type_field) = let _4 =\n let _1 = _1_inlined2 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 4585 \"parsing/parser.ml\"\n \n in\n let _endpos__4_ = _endpos__1_inlined2_ in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 4594 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2062 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n mkctf ~loc:_sloc (Pctf_inherit _3) ~attrs:(_2@_4) ~docs )\n# 4604 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = flags;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_flags_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_flags_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _3 : unit = Obj.magic _3 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 4664 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let flags : (Asttypes.mutable_flag * Asttypes.virtual_flag) = Obj.magic flags in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.class_type_field) = let _4 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 4677 \"parsing/parser.ml\"\n \n in\n let _endpos__4_ = _endpos__1_inlined3_ in\n let _3 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let label =\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 4687 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 4695 \"parsing/parser.ml\"\n \n in\n \n# 2087 \"parsing/parser.mly\"\n (\n let mut, virt = flags in\n label, mut, virt, ty\n )\n# 4704 \"parsing/parser.ml\"\n \n in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 4712 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2065 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n mkctf ~loc:_sloc (Pctf_val _3) ~attrs:(_2@_4) ~docs )\n# 4722 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let _1_inlined3 : (Parsetree.core_type) = Obj.magic _1_inlined3 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 4782 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let _3 : (Asttypes.private_flag * Asttypes.virtual_flag) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined4_ in\n let _v : (Parsetree.class_type_field) = let _7 =\n let _1 = _1_inlined4 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 4795 \"parsing/parser.ml\"\n \n in\n let _endpos__7_ = _endpos__1_inlined4_ in\n let _6 =\n let _1 = _1_inlined3 in\n \n# 3282 \"parsing/parser.mly\"\n ( _1 )\n# 4804 \"parsing/parser.ml\"\n \n in\n let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 4812 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 4820 \"parsing/parser.ml\"\n \n in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 4828 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__7_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2069 \"parsing/parser.mly\"\n ( let (p, v) = _3 in\n let docs = symbol_docs _sloc in\n mkctf ~loc:_sloc (Pctf_method (_4, p, v, _6)) ~attrs:(_2@_7) ~docs )\n# 4839 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _3 : (Parsetree.core_type * Parsetree.core_type) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.class_type_field) = let _4 =\n let _1 = _1_inlined2 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 4887 \"parsing/parser.ml\"\n \n in\n let _endpos__4_ = _endpos__1_inlined2_ in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 4896 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2073 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n mkctf ~loc:_sloc (Pctf_constraint _3) ~attrs:(_2@_4) ~docs )\n# 4906 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : (Parsetree.extension) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.class_type_field) = let _2 =\n let _1 = _1_inlined1 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 4940 \"parsing/parser.ml\"\n \n in\n let _endpos__2_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2076 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n mkctf ~loc:_sloc (Pctf_extension _1) ~attrs:_2 ~docs )\n# 4951 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.attribute) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.class_type_field) = let _1 =\n let _1 = \n# 2079 \"parsing/parser.mly\"\n ( Pctf_attribute _1 )\n# 4977 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 936 \"parsing/parser.mly\"\n ( mkctf ~loc:_sloc _1 )\n# 4985 \"parsing/parser.ml\"\n \n in\n \n# 2080 \"parsing/parser.mly\"\n ( _1 )\n# 4991 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.class_type) = let _1 =\n let _1 =\n let cid =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 5022 \"parsing/parser.ml\"\n \n in\n let tys =\n let tys = \n# 2038 \"parsing/parser.mly\"\n ( [] )\n# 5029 \"parsing/parser.ml\"\n in\n \n# 2044 \"parsing/parser.mly\"\n ( tys )\n# 5034 \"parsing/parser.ml\"\n \n in\n \n# 2021 \"parsing/parser.mly\"\n ( Pcty_constr (cid, tys) )\n# 5040 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 934 \"parsing/parser.mly\"\n ( mkcty ~loc:_sloc _1 )\n# 5049 \"parsing/parser.ml\"\n \n in\n \n# 2024 \"parsing/parser.mly\"\n ( _1 )\n# 5055 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _3 : unit = Obj.magic _3 in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.class_type) = let _1 =\n let _1 =\n let cid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 5108 \"parsing/parser.ml\"\n \n in\n let tys =\n let tys =\n let params =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 5117 \"parsing/parser.ml\"\n in\n \n# 1021 \"parsing/parser.mly\"\n ( xs )\n# 5122 \"parsing/parser.ml\"\n \n in\n \n# 2040 \"parsing/parser.mly\"\n ( params )\n# 5128 \"parsing/parser.ml\"\n \n in\n \n# 2044 \"parsing/parser.mly\"\n ( tys )\n# 5134 \"parsing/parser.ml\"\n \n in\n \n# 2021 \"parsing/parser.mly\"\n ( Pcty_constr (cid, tys) )\n# 5140 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 934 \"parsing/parser.mly\"\n ( mkcty ~loc:_sloc _1 )\n# 5150 \"parsing/parser.ml\"\n \n in\n \n# 2024 \"parsing/parser.mly\"\n ( _1 )\n# 5156 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.extension) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.class_type) = let _1 =\n let _1 = \n# 2023 \"parsing/parser.mly\"\n ( Pcty_extension _1 )\n# 5182 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 934 \"parsing/parser.mly\"\n ( mkcty ~loc:_sloc _1 )\n# 5190 \"parsing/parser.ml\"\n \n in\n \n# 2024 \"parsing/parser.mly\"\n ( _1 )\n# 5196 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let xss : (Parsetree.class_type_field list list) = Obj.magic xss in\n let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.class_type) = let _3 =\n let _1 = _1_inlined2 in\n let _2 =\n let _1 =\n let _1 = \n# 260 \"\"\n ( List.flatten xss )\n# 5253 \"parsing/parser.ml\"\n in\n \n# 2058 \"parsing/parser.mly\"\n ( _1 )\n# 5258 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 882 \"parsing/parser.mly\"\n ( extra_csig _startpos _endpos _1 )\n# 5267 \"parsing/parser.ml\"\n \n in\n \n# 2048 \"parsing/parser.mly\"\n ( Csig.mk _1 _2 )\n# 5273 \"parsing/parser.ml\"\n \n in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 5281 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2026 \"parsing/parser.mly\"\n ( mkcty ~loc:_sloc ~attrs:_2 (Pcty_signature _3) )\n# 5290 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let xss : (Parsetree.class_type_field list list) = Obj.magic xss in\n let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.class_type) = let _3 =\n let _1 = _1_inlined2 in\n let _2 =\n let _1 =\n let _1 = \n# 260 \"\"\n ( List.flatten xss )\n# 5347 \"parsing/parser.ml\"\n in\n \n# 2058 \"parsing/parser.mly\"\n ( _1 )\n# 5352 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 882 \"parsing/parser.mly\"\n ( extra_csig _startpos _endpos _1 )\n# 5361 \"parsing/parser.ml\"\n \n in\n \n# 2048 \"parsing/parser.mly\"\n ( Csig.mk _1 _2 )\n# 5367 \"parsing/parser.ml\"\n \n in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 5375 \"parsing/parser.ml\"\n \n in\n let _loc__4_ = (_startpos__4_, _endpos__4_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2028 \"parsing/parser.mly\"\n ( unclosed \"object\" _loc__1_ \"end\" _loc__4_ )\n# 5383 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.attribute) = Obj.magic _2 in\n let _1 : (Parsetree.class_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.class_type) = \n# 2030 \"parsing/parser.mly\"\n ( Cty.attr _1 _2 )\n# 5415 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : (Parsetree.class_type) = Obj.magic _7 in\n let _6 : unit = Obj.magic _6 in\n let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.class_type) = let _5 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 5480 \"parsing/parser.ml\"\n \n in\n let _endpos__5_ = _endpos__1_inlined2_ in\n let _4 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 5489 \"parsing/parser.ml\"\n \n in\n let _3 = \n# 3755 \"parsing/parser.mly\"\n ( Fresh )\n# 5495 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__7_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2032 \"parsing/parser.mly\"\n ( let loc = (_startpos__2_, _endpos__5_) in\n let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in\n mkcty ~loc:_sloc ~attrs:_4 (Pcty_open(od, _7)) )\n# 5505 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : (Parsetree.class_type) = Obj.magic _7 in\n let _6 : unit = Obj.magic _6 in\n let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.class_type) = let _5 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 5577 \"parsing/parser.ml\"\n \n in\n let _endpos__5_ = _endpos__1_inlined3_ in\n let _4 =\n let _1 = _1_inlined2 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 5586 \"parsing/parser.ml\"\n \n in\n let _3 = \n# 3756 \"parsing/parser.mly\"\n ( Override )\n# 5592 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__7_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2032 \"parsing/parser.mly\"\n ( let loc = (_startpos__2_, _endpos__5_) in\n let od = Opn.mk ~override:_3 ~loc:(make_loc loc) _5 in\n mkcty ~loc:_sloc ~attrs:_4 (Pcty_open(od, _7)) )\n# 5602 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.class_expr) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.class_expr) = \n# 1892 \"parsing/parser.mly\"\n ( _2 )\n# 5641 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.class_expr) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.class_expr) = let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1894 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__3_ )\n# 5682 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.class_expr) = let _1 =\n let _1 =\n let cid =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 5713 \"parsing/parser.ml\"\n \n in\n let tys =\n let tys = \n# 2038 \"parsing/parser.mly\"\n ( [] )\n# 5720 \"parsing/parser.ml\"\n in\n \n# 2044 \"parsing/parser.mly\"\n ( tys )\n# 5725 \"parsing/parser.ml\"\n \n in\n \n# 1897 \"parsing/parser.mly\"\n ( Pcl_constr(cid, tys) )\n# 5731 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 940 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc _1 )\n# 5740 \"parsing/parser.ml\"\n \n in\n \n# 1904 \"parsing/parser.mly\"\n ( _1 )\n# 5746 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _3 : unit = Obj.magic _3 in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.class_expr) = let _1 =\n let _1 =\n let cid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 5799 \"parsing/parser.ml\"\n \n in\n let tys =\n let tys =\n let params =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 5808 \"parsing/parser.ml\"\n in\n \n# 1021 \"parsing/parser.mly\"\n ( xs )\n# 5813 \"parsing/parser.ml\"\n \n in\n \n# 2040 \"parsing/parser.mly\"\n ( params )\n# 5819 \"parsing/parser.ml\"\n \n in\n \n# 2044 \"parsing/parser.mly\"\n ( tys )\n# 5825 \"parsing/parser.ml\"\n \n in\n \n# 1897 \"parsing/parser.mly\"\n ( Pcl_constr(cid, tys) )\n# 5831 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 940 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc _1 )\n# 5841 \"parsing/parser.ml\"\n \n in\n \n# 1904 \"parsing/parser.mly\"\n ( _1 )\n# 5847 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let xss : (Parsetree.class_field list list) = Obj.magic xss in\n let _1_inlined2 : (Parsetree.pattern) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.class_expr) = let _1 =\n let _1 =\n let _3 =\n let _1 = _1_inlined2 in\n let _2 =\n let _1 =\n let _1 = \n# 260 \"\"\n ( List.flatten xss )\n# 5906 \"parsing/parser.ml\"\n in\n \n# 1931 \"parsing/parser.mly\"\n ( _1 )\n# 5911 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 881 \"parsing/parser.mly\"\n ( extra_cstr _startpos _endpos _1 )\n# 5920 \"parsing/parser.ml\"\n \n in\n \n# 1918 \"parsing/parser.mly\"\n ( Cstr.mk _1 _2 )\n# 5926 \"parsing/parser.ml\"\n \n in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 5934 \"parsing/parser.ml\"\n \n in\n let _loc__4_ = (_startpos__4_, _endpos__4_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1899 \"parsing/parser.mly\"\n ( unclosed \"object\" _loc__1_ \"end\" _loc__4_ )\n# 5942 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 940 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc _1 )\n# 5952 \"parsing/parser.ml\"\n \n in\n \n# 1904 \"parsing/parser.mly\"\n ( _1 )\n# 5958 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.class_type) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.class_expr) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.class_expr) = let _1 =\n let _1 = \n# 1901 \"parsing/parser.mly\"\n ( Pcl_constraint(_2, _4) )\n# 6012 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 940 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc _1 )\n# 6021 \"parsing/parser.ml\"\n \n in\n \n# 1904 \"parsing/parser.mly\"\n ( _1 )\n# 6027 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.class_type) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.class_expr) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.class_expr) = let _1 =\n let _1 =\n let _loc__5_ = (_startpos__5_, _endpos__5_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1903 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__5_ )\n# 6084 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 940 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc _1 )\n# 6094 \"parsing/parser.ml\"\n \n in\n \n# 1904 \"parsing/parser.mly\"\n ( _1 )\n# 6100 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let xss : (Parsetree.class_field list list) = Obj.magic xss in\n let _1_inlined2 : (Parsetree.pattern) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.class_expr) = let _3 =\n let _1 = _1_inlined2 in\n let _2 =\n let _1 =\n let _1 = \n# 260 \"\"\n ( List.flatten xss )\n# 6157 \"parsing/parser.ml\"\n in\n \n# 1931 \"parsing/parser.mly\"\n ( _1 )\n# 6162 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 881 \"parsing/parser.mly\"\n ( extra_cstr _startpos _endpos _1 )\n# 6171 \"parsing/parser.ml\"\n \n in\n \n# 1918 \"parsing/parser.mly\"\n ( Cstr.mk _1 _2 )\n# 6177 \"parsing/parser.ml\"\n \n in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 6185 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1906 \"parsing/parser.mly\"\n ( mkclass ~loc:_sloc ~attrs:_2 (Pcl_structure _3) )\n# 6194 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.class_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.class_type) = \n# 2009 \"parsing/parser.mly\"\n ( _1 )\n# 6219 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = codomain;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = domain;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_domain_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_domain_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = label;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_label_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_label_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let codomain : (Parsetree.class_type) = Obj.magic codomain in\n let _3 : unit = Obj.magic _3 in\n let domain : (Parsetree.core_type) = Obj.magic domain in\n let label : (string) = Obj.magic label in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_label_ in\n let _endpos = _endpos_codomain_ in\n let _v : (Parsetree.class_type) = let _1 =\n let _1 =\n let label = \n# 3345 \"parsing/parser.mly\"\n ( Optional label )\n# 6267 \"parsing/parser.ml\"\n in\n \n# 2015 \"parsing/parser.mly\"\n ( Pcty_arrow(label, domain, codomain) )\n# 6272 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 934 \"parsing/parser.mly\"\n ( mkcty ~loc:_sloc _1 )\n# 6282 \"parsing/parser.ml\"\n \n in\n \n# 2016 \"parsing/parser.mly\"\n ( _1 )\n# 6288 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = codomain;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = domain;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_domain_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_domain_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = label;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_label_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_label_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let codomain : (Parsetree.class_type) = Obj.magic codomain in\n let _3 : unit = Obj.magic _3 in\n let domain : (Parsetree.core_type) = Obj.magic domain in\n let _2 : unit = Obj.magic _2 in\n let label : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 6337 \"parsing/parser.ml\"\n ) = Obj.magic label in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_label_ in\n let _endpos = _endpos_codomain_ in\n let _v : (Parsetree.class_type) = let _1 =\n let _1 =\n let label = \n# 3347 \"parsing/parser.mly\"\n ( Labelled label )\n# 6347 \"parsing/parser.ml\"\n in\n \n# 2015 \"parsing/parser.mly\"\n ( Pcty_arrow(label, domain, codomain) )\n# 6352 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 934 \"parsing/parser.mly\"\n ( mkcty ~loc:_sloc _1 )\n# 6362 \"parsing/parser.ml\"\n \n in\n \n# 2016 \"parsing/parser.mly\"\n ( _1 )\n# 6368 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = codomain;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = domain;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_domain_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_domain_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let codomain : (Parsetree.class_type) = Obj.magic codomain in\n let _3 : unit = Obj.magic _3 in\n let domain : (Parsetree.core_type) = Obj.magic domain in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_domain_ in\n let _endpos = _endpos_codomain_ in\n let _v : (Parsetree.class_type) = let _1 =\n let _1 =\n let label = \n# 3349 \"parsing/parser.mly\"\n ( Nolabel )\n# 6409 \"parsing/parser.ml\"\n in\n \n# 2015 \"parsing/parser.mly\"\n ( Pcty_arrow(label, domain, codomain) )\n# 6414 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_domain_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 934 \"parsing/parser.mly\"\n ( mkcty ~loc:_sloc _1 )\n# 6424 \"parsing/parser.ml\"\n \n in\n \n# 2016 \"parsing/parser.mly\"\n ( _1 )\n# 6430 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = bs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_bs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_bs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = csig;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_csig_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_csig_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _8;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__8_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__8_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = virt;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_virt_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_virt_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let bs : (Parsetree.class_type_declaration list) = Obj.magic bs in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let csig : (Parsetree.class_type) = Obj.magic csig in\n let _8 : unit = Obj.magic _8 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 6515 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let virt : (Asttypes.virtual_flag) = Obj.magic virt in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_bs_ in\n let _v : (string Asttypes.loc option * Parsetree.class_type_declaration list) = let _1 =\n let a =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 6533 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 6545 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 6553 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2154 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n ext,\n Ci.mk id csig ~virt ~params ~attrs ~loc ~docs\n )\n# 6568 \"parsing/parser.ml\"\n \n in\n \n# 1118 \"parsing/parser.mly\"\n ( let (x, b) = a in x, b :: bs )\n# 6574 \"parsing/parser.ml\"\n \n in\n \n# 2142 \"parsing/parser.mly\"\n ( _1 )\n# 6580 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3634 \"parsing/parser.mly\"\n ( _1 )\n# 6605 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 691 \"parsing/parser.mly\"\n (string * char option)\n# 6626 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.constant) = \n# 3517 \"parsing/parser.mly\"\n ( let (n, m) = _1 in Pconst_integer (n, m) )\n# 6634 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 650 \"parsing/parser.mly\"\n (char)\n# 6655 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.constant) = \n# 3518 \"parsing/parser.mly\"\n ( Pconst_char _1 )\n# 6663 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 743 \"parsing/parser.mly\"\n (string * Location.t * string option)\n# 6684 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.constant) = \n# 3519 \"parsing/parser.mly\"\n ( let (s, strloc, d) = _1 in Pconst_string (s, strloc, d) )\n# 6692 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 670 \"parsing/parser.mly\"\n (string * char option)\n# 6713 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.constant) = \n# 3520 \"parsing/parser.mly\"\n ( let (f, m) = _1 in Pconst_float (f, m) )\n# 6721 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.label) = \n# 3591 \"parsing/parser.mly\"\n ( \"[]\" )\n# 6753 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.label) = \n# 3592 \"parsing/parser.mly\"\n ( \"()\" )\n# 6785 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3593 \"parsing/parser.mly\"\n ( \"false\" )\n# 6810 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3594 \"parsing/parser.mly\"\n ( \"true\" )\n# 6835 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 756 \"parsing/parser.mly\"\n (string)\n# 6856 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3597 \"parsing/parser.mly\"\n ( _1 )\n# 6864 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Asttypes.label) = let _1 = \n# 3588 \"parsing/parser.mly\"\n ( \"::\" )\n# 6903 \"parsing/parser.ml\"\n in\n \n# 3598 \"parsing/parser.mly\"\n ( _1 )\n# 6908 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3599 \"parsing/parser.mly\"\n ( _1 )\n# 6933 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3602 \"parsing/parser.mly\"\n ( _1 )\n# 6958 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2_inlined1 : unit = Obj.magic _2_inlined1 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Longident.t) = let _3 = \n# 3588 \"parsing/parser.mly\"\n ( \"::\" )\n# 7011 \"parsing/parser.ml\"\n in\n \n# 3603 \"parsing/parser.mly\"\n ( Ldot(_1,_3) )\n# 7016 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Longident.t) = let _1 = \n# 3588 \"parsing/parser.mly\"\n ( \"::\" )\n# 7055 \"parsing/parser.ml\"\n in\n \n# 3604 \"parsing/parser.mly\"\n ( Lident _1 )\n# 7060 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3605 \"parsing/parser.mly\"\n ( Lident _1 )\n# 7085 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.core_type) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.core_type * Parsetree.core_type) = \n# 2098 \"parsing/parser.mly\"\n ( _1, _3 )\n# 7124 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.constructor_arguments) = let tys =\n let xs =\n let xs = \n# 1005 \"parsing/parser.mly\"\n ( [ x ] )\n# 7151 \"parsing/parser.ml\"\n in\n \n# 253 \"\"\n ( List.rev xs )\n# 7156 \"parsing/parser.ml\"\n \n in\n \n# 1025 \"parsing/parser.mly\"\n ( xs )\n# 7162 \"parsing/parser.ml\"\n \n in\n \n# 3148 \"parsing/parser.mly\"\n ( Pcstr_tuple tys )\n# 7168 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _2 : unit = Obj.magic _2 in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.constructor_arguments) = let tys =\n let xs =\n let xs = \n# 1009 \"parsing/parser.mly\"\n ( x :: xs )\n# 7209 \"parsing/parser.ml\"\n in\n \n# 253 \"\"\n ( List.rev xs )\n# 7214 \"parsing/parser.ml\"\n \n in\n \n# 1025 \"parsing/parser.mly\"\n ( xs )\n# 7220 \"parsing/parser.ml\"\n \n in\n \n# 3148 \"parsing/parser.mly\"\n ( Pcstr_tuple tys )\n# 7226 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.label_declaration list) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.constructor_arguments) = \n# 3150 \"parsing/parser.mly\"\n ( Pcstr_record _2 )\n# 7265 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.constructor_declaration list) = \n# 3064 \"parsing/parser.mly\"\n ( [] )\n# 7290 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let xs : (Parsetree.constructor_declaration list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.constructor_declaration list) = let cs = \n# 1110 \"parsing/parser.mly\"\n ( List.rev xs )\n# 7315 \"parsing/parser.ml\"\n in\n \n# 3066 \"parsing/parser.mly\"\n ( cs )\n# 7320 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = let _1 = \n# 3307 \"parsing/parser.mly\"\n ( _1 )\n# 7345 \"parsing/parser.ml\"\n in\n \n# 3297 \"parsing/parser.mly\"\n ( _1 )\n# 7350 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.attribute) = Obj.magic _2 in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.core_type) = \n# 3299 \"parsing/parser.mly\"\n ( Typ.attr _1 _2 )\n# 7382 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.direction_flag) = \n# 3700 \"parsing/parser.mly\"\n ( Upto )\n# 7407 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.direction_flag) = \n# 3701 \"parsing/parser.mly\"\n ( Downto )\n# 7432 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.expression) = \n# 2265 \"parsing/parser.mly\"\n ( _1 )\n# 7457 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : (Parsetree.expression) = Obj.magic _7 in\n let _6 : unit = Obj.magic _6 in\n let _5 : (Parsetree.module_expr) = Obj.magic _5 in\n let _1_inlined3 : (string option) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.expression) = let _1 =\n let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 7537 \"parsing/parser.ml\"\n \n in\n let _3 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 7547 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 7553 \"parsing/parser.ml\"\n \n in\n \n# 2298 \"parsing/parser.mly\"\n ( Pexp_letmodule(_4, _5, _7), _3 )\n# 7559 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__7_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 7570 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _6 : (Parsetree.expression) = Obj.magic _6 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let _2_inlined1 : (Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option) = Obj.magic _2_inlined1 in\n let _1_inlined3 : (Asttypes.label) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__6_ in\n let _v : (Parsetree.expression) = let _1 =\n let _4 =\n let (_endpos__1_inlined1_, _endpos__1_, _startpos__1_, _1_inlined1, _2, _1) = (_endpos__1_inlined4_, _endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined4, _2_inlined1, _1_inlined3) in\n let _3 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 7657 \"parsing/parser.ml\"\n \n in\n let _endpos__3_ = _endpos__1_inlined1_ in\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 7668 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3128 \"parsing/parser.mly\"\n ( let vars, args, res = _2 in\n Te.decl _1 ~vars ~args ?res ~attrs:_3 ~loc:(make_loc _sloc) )\n# 7678 \"parsing/parser.ml\"\n \n in\n let _3 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 7688 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 7694 \"parsing/parser.ml\"\n \n in\n \n# 2300 \"parsing/parser.mly\"\n ( Pexp_letexception(_4, _6), _3 )\n# 7700 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__6_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 7711 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : (Parsetree.expression) = Obj.magic _7 in\n let _6 : unit = Obj.magic _6 in\n let _5 : (Parsetree.module_expr) = Obj.magic _5 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.expression) = let _1 =\n let _4 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 7783 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 7789 \"parsing/parser.ml\"\n \n in\n let _3 = \n# 3755 \"parsing/parser.mly\"\n ( Fresh )\n# 7795 \"parsing/parser.ml\"\n in\n \n# 2302 \"parsing/parser.mly\"\n ( let open_loc = make_loc (_startpos__2_, _endpos__5_) in\n let od = Opn.mk _5 ~override:_3 ~loc:open_loc in\n Pexp_open(od, _7), _4 )\n# 7802 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__7_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 7813 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : (Parsetree.expression) = Obj.magic _7 in\n let _6 : unit = Obj.magic _6 in\n let _5 : (Parsetree.module_expr) = Obj.magic _5 in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (string Asttypes.loc option) = Obj.magic _1_inlined2 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.expression) = let _1 =\n let _4 =\n let (_1_inlined1, _1) = (_1_inlined3, _1_inlined2) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 7892 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 7898 \"parsing/parser.ml\"\n \n in\n let _3 = \n# 3756 \"parsing/parser.mly\"\n ( Override )\n# 7904 \"parsing/parser.ml\"\n in\n \n# 2302 \"parsing/parser.mly\"\n ( let open_loc = make_loc (_startpos__2_, _endpos__5_) in\n let od = Opn.mk _5 ~override:_3 ~loc:open_loc in\n Pexp_open(od, _7), _4 )\n# 7911 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__7_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 7922 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.case list) = Obj.magic xs in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.expression) = let _1 =\n let _3 =\n let xs =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 7971 \"parsing/parser.ml\"\n in\n \n# 1082 \"parsing/parser.mly\"\n ( xs )\n# 7976 \"parsing/parser.ml\"\n \n in\n \n# 2611 \"parsing/parser.mly\"\n ( xs )\n# 7982 \"parsing/parser.ml\"\n \n in\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 7992 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 7998 \"parsing/parser.ml\"\n \n in\n \n# 2306 \"parsing/parser.mly\"\n ( Pexp_function _3, _2 )\n# 8004 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_xs_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 8015 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _3 : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.expression) = let _1 =\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 8073 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 8079 \"parsing/parser.ml\"\n \n in\n \n# 2308 \"parsing/parser.mly\"\n ( let (l,o,p) = _3 in\n Pexp_fun(l, o, p, _4), _2 )\n# 8086 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 8097 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : (Parsetree.expression) = Obj.magic _7 in\n let _6 : unit = Obj.magic _6 in\n let xs : (string Asttypes.loc list) = Obj.magic xs in\n let _4 : unit = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.expression) = let _1 =\n let _5 = \n# 2495 \"parsing/parser.mly\"\n ( xs )\n# 8172 \"parsing/parser.ml\"\n in\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 8181 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 8187 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__7_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2311 \"parsing/parser.mly\"\n ( (mk_newtypes ~loc:_sloc _5 _7).pexp_desc, _2 )\n# 8196 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__7_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 8207 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.case list) = Obj.magic xs in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.expression) = let _1 =\n let _5 =\n let xs =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 8270 \"parsing/parser.ml\"\n in\n \n# 1082 \"parsing/parser.mly\"\n ( xs )\n# 8275 \"parsing/parser.ml\"\n \n in\n \n# 2611 \"parsing/parser.mly\"\n ( xs )\n# 8281 \"parsing/parser.ml\"\n \n in\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 8291 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 8297 \"parsing/parser.ml\"\n \n in\n \n# 2313 \"parsing/parser.mly\"\n ( Pexp_match(_3, _5), _2 )\n# 8303 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_xs_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 8314 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.case list) = Obj.magic xs in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.expression) = let _1 =\n let _5 =\n let xs =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 8377 \"parsing/parser.ml\"\n in\n \n# 1082 \"parsing/parser.mly\"\n ( xs )\n# 8382 \"parsing/parser.ml\"\n \n in\n \n# 2611 \"parsing/parser.mly\"\n ( xs )\n# 8388 \"parsing/parser.ml\"\n \n in\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 8398 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 8404 \"parsing/parser.ml\"\n \n in\n \n# 2315 \"parsing/parser.mly\"\n ( Pexp_try(_3, _5), _2 )\n# 8410 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_xs_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 8421 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 8486 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 8492 \"parsing/parser.ml\"\n \n in\n \n# 2317 \"parsing/parser.mly\"\n ( syntax_error() )\n# 8498 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 8509 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : (Parsetree.expression) = Obj.magic _7 in\n let _6 : unit = Obj.magic _6 in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.expression) = let _1 =\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 8588 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 8594 \"parsing/parser.ml\"\n \n in\n \n# 2319 \"parsing/parser.mly\"\n ( Pexp_ifthenelse(_3, _5, Some _7), _2 )\n# 8600 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__7_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 8611 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 8676 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 8682 \"parsing/parser.ml\"\n \n in\n \n# 2321 \"parsing/parser.mly\"\n ( Pexp_ifthenelse(_3, _5, None), _2 )\n# 8688 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 8699 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _6 : unit = Obj.magic _6 in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__6_ in\n let _v : (Parsetree.expression) = let _1 =\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 8771 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 8777 \"parsing/parser.ml\"\n \n in\n \n# 2323 \"parsing/parser.mly\"\n ( Pexp_while(_3, _5), _2 )\n# 8783 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__6_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 8794 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _10;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__10_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__10_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _9;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__9_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__9_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _8;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__8_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__8_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _10 : unit = Obj.magic _10 in\n let _9 : (Parsetree.expression) = Obj.magic _9 in\n let _8 : unit = Obj.magic _8 in\n let _7 : (Parsetree.expression) = Obj.magic _7 in\n let _6 : (Asttypes.direction_flag) = Obj.magic _6 in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__10_ in\n let _v : (Parsetree.expression) = let _1 =\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 8894 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 8900 \"parsing/parser.ml\"\n \n in\n \n# 2326 \"parsing/parser.mly\"\n ( Pexp_for(_3, _5, _7, _6, _9), _2 )\n# 8906 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__10_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 8917 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 8968 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 8974 \"parsing/parser.ml\"\n \n in\n \n# 2328 \"parsing/parser.mly\"\n ( Pexp_assert _3, _2 )\n# 8980 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 8991 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 9042 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 9048 \"parsing/parser.ml\"\n \n in\n \n# 2330 \"parsing/parser.mly\"\n ( Pexp_lazy _3, _2 )\n# 9054 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2267 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 9065 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : ((Asttypes.arg_label * Parsetree.expression) list) = Obj.magic xs in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _2 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 9100 \"parsing/parser.ml\"\n in\n \n# 989 \"parsing/parser.mly\"\n ( xs )\n# 9105 \"parsing/parser.ml\"\n \n in\n \n# 2334 \"parsing/parser.mly\"\n ( Pexp_apply(_1, _2) )\n# 9111 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_xs_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9121 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9127 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let xs : (Parsetree.expression list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _1 =\n let es =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 9156 \"parsing/parser.ml\"\n in\n \n# 1049 \"parsing/parser.mly\"\n ( xs )\n# 9161 \"parsing/parser.ml\"\n \n in\n \n# 2638 \"parsing/parser.mly\"\n ( es )\n# 9167 \"parsing/parser.ml\"\n \n in\n \n# 2336 \"parsing/parser.mly\"\n ( Pexp_tuple(_1) )\n# 9173 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_xs_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9183 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9189 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 9227 \"parsing/parser.ml\"\n \n in\n \n# 2338 \"parsing/parser.mly\"\n ( Pexp_construct(_1, Some _2) )\n# 9233 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9243 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9249 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 = \n# 2340 \"parsing/parser.mly\"\n ( Pexp_variant(_1, Some _2) )\n# 9282 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9291 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9297 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = op;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_op_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_op_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let op : (\n# 681 \"parsing/parser.mly\"\n (string)\n# 9331 \"parsing/parser.ml\"\n ) = Obj.magic op in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3561 \"parsing/parser.mly\"\n ( op )\n# 9343 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 9352 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 9358 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9368 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9374 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = op;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_op_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_op_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let op : (\n# 682 \"parsing/parser.mly\"\n (string)\n# 9408 \"parsing/parser.ml\"\n ) = Obj.magic op in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3562 \"parsing/parser.mly\"\n ( op )\n# 9420 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 9429 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 9435 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9445 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9451 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = op;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_op_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_op_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let op : (\n# 683 \"parsing/parser.mly\"\n (string)\n# 9485 \"parsing/parser.ml\"\n ) = Obj.magic op in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3563 \"parsing/parser.mly\"\n ( op )\n# 9497 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 9506 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 9512 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9522 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9528 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = op;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_op_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_op_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let op : (\n# 684 \"parsing/parser.mly\"\n (string)\n# 9562 \"parsing/parser.ml\"\n ) = Obj.magic op in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3564 \"parsing/parser.mly\"\n ( op )\n# 9574 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 9583 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 9589 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9599 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9605 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = op;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_op_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_op_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let op : (\n# 685 \"parsing/parser.mly\"\n (string)\n# 9639 \"parsing/parser.ml\"\n ) = Obj.magic op in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3565 \"parsing/parser.mly\"\n ( op )\n# 9651 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_op_, _startpos_op_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 9660 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 9666 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9676 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9682 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3566 \"parsing/parser.mly\"\n (\"+\")\n# 9724 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 9732 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 9738 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9748 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9754 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3567 \"parsing/parser.mly\"\n (\"+.\")\n# 9796 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 9804 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 9810 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9820 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9826 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3568 \"parsing/parser.mly\"\n (\"+=\")\n# 9868 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 9876 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 9882 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9892 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9898 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3569 \"parsing/parser.mly\"\n (\"-\")\n# 9940 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 9948 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 9954 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 9964 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 9970 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3570 \"parsing/parser.mly\"\n (\"-.\")\n# 10012 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 10020 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 10026 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10036 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10042 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3571 \"parsing/parser.mly\"\n (\"*\")\n# 10084 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 10092 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 10098 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10108 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10114 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3572 \"parsing/parser.mly\"\n (\"%\")\n# 10156 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 10164 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 10170 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10180 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10186 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3573 \"parsing/parser.mly\"\n (\"=\")\n# 10228 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 10236 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 10242 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10252 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10258 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3574 \"parsing/parser.mly\"\n (\"<\")\n# 10300 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 10308 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 10314 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10324 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10330 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3575 \"parsing/parser.mly\"\n (\">\")\n# 10372 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 10380 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 10386 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10396 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10402 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3576 \"parsing/parser.mly\"\n (\"or\")\n# 10444 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 10452 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 10458 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10468 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10474 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3577 \"parsing/parser.mly\"\n (\"||\")\n# 10516 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 10524 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 10530 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10540 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10546 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3578 \"parsing/parser.mly\"\n (\"&\")\n# 10588 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 10596 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 10602 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10612 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10618 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3579 \"parsing/parser.mly\"\n (\"&&\")\n# 10660 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 10668 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 10674 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10684 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10690 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let e2 : (Parsetree.expression) = Obj.magic e2 in\n let _1 : unit = Obj.magic _1 in\n let e1 : (Parsetree.expression) = Obj.magic e1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e1_ in\n let _endpos = _endpos_e2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let op =\n let _1 = \n# 3580 \"parsing/parser.mly\"\n (\":=\")\n# 10732 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 10740 \"parsing/parser.ml\"\n \n in\n \n# 2342 \"parsing/parser.mly\"\n ( mkinfix e1 op e2 )\n# 10746 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_e2_, _startpos_e1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10756 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10762 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : (string) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2344 \"parsing/parser.mly\"\n ( mkuminus ~oploc:_loc__1_ _1 _2 )\n# 10797 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10807 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10813 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : (string) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2346 \"parsing/parser.mly\"\n ( mkuplus ~oploc:_loc__1_ _1 _2 )\n# 10848 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 10858 \"parsing/parser.ml\"\n \n in\n \n# 2270 \"parsing/parser.mly\"\n ( _1 )\n# 10864 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (let_bindings) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2272 \"parsing/parser.mly\"\n ( expr_of_let_bindings ~loc:_sloc _1 _3 )\n# 10906 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = bindings;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_bindings_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_bindings_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let body : (Parsetree.expression) = Obj.magic body in\n let _3 : unit = Obj.magic _3 in\n let bindings : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = Obj.magic bindings in\n let _1 : (\n# 687 \"parsing/parser.mly\"\n (string)\n# 10948 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_body_ in\n let _v : (Parsetree.expression) = let pbop_op =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 10960 \"parsing/parser.ml\"\n \n in\n let _startpos_pbop_op_ = _startpos__1_ in\n let _endpos = _endpos_body_ in\n let _symbolstartpos = _startpos_pbop_op_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2274 \"parsing/parser.mly\"\n ( let (pbop_pat, pbop_exp, rev_ands) = bindings in\n let ands = List.rev rev_ands in\n let pbop_loc = make_loc _sloc in\n let let_ = {pbop_op; pbop_pat; pbop_exp; pbop_loc} in\n mkexp ~loc:_sloc (Pexp_letop{ let_; ands; body}) )\n# 10974 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _loc__2_ = (_startpos__2_, _endpos__2_) in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2280 \"parsing/parser.mly\"\n ( mkexp_cons ~loc:_sloc _loc__2_ (ghexp ~loc:_sloc (Pexp_tuple[_1;_3])) )\n# 11017 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 11052 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 11061 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 11069 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2282 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc (Pexp_setinstvar(_1, _3)) )\n# 11078 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _3 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 11136 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2284 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc (Pexp_setfield(_1, _3, _5)) )\n# 11145 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_v_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_v_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = i;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_i_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_i_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let v : (Parsetree.expression) = Obj.magic v in\n let _1 : unit = Obj.magic _1 in\n let _5 : unit = Obj.magic _5 in\n let i : (Parsetree.expression) = Obj.magic i in\n let _3 : unit = Obj.magic _3 in\n let d : unit = Obj.magic d in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos_v_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2285 \"parsing/parser.mly\"\n (Some v)\n# 11213 \"parsing/parser.ml\"\n in\n \n# 2245 \"parsing/parser.mly\"\n ( array, d, Paren, i, r )\n# 11218 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2286 \"parsing/parser.mly\"\n ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 )\n# 11228 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_v_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_v_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = i;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_i_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_i_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let v : (Parsetree.expression) = Obj.magic v in\n let _1 : unit = Obj.magic _1 in\n let _5 : unit = Obj.magic _5 in\n let i : (Parsetree.expression) = Obj.magic i in\n let _3 : unit = Obj.magic _3 in\n let d : unit = Obj.magic d in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos_v_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2285 \"parsing/parser.mly\"\n (Some v)\n# 11296 \"parsing/parser.ml\"\n in\n \n# 2247 \"parsing/parser.mly\"\n ( array, d, Brace, i, r )\n# 11301 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2286 \"parsing/parser.mly\"\n ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 )\n# 11311 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_v_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_v_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = i;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_i_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_i_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let v : (Parsetree.expression) = Obj.magic v in\n let _1 : unit = Obj.magic _1 in\n let _5 : unit = Obj.magic _5 in\n let i : (Parsetree.expression) = Obj.magic i in\n let _3 : unit = Obj.magic _3 in\n let d : unit = Obj.magic d in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos_v_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2285 \"parsing/parser.mly\"\n (Some v)\n# 11379 \"parsing/parser.ml\"\n in\n \n# 2249 \"parsing/parser.mly\"\n ( array, d, Bracket, i, r )\n# 11384 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2286 \"parsing/parser.mly\"\n ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 )\n# 11394 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_v_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_v_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let v : (Parsetree.expression) = Obj.magic v in\n let _1 : unit = Obj.magic _1 in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 11456 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos_v_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2287 \"parsing/parser.mly\"\n (Some v)\n# 11466 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 11471 \"parsing/parser.ml\"\n in\n let d =\n let _1 = \n# 124 \"\"\n ( None )\n# 11477 \"parsing/parser.ml\"\n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 11482 \"parsing/parser.ml\"\n \n in\n \n# 2245 \"parsing/parser.mly\"\n ( array, d, Paren, i, r )\n# 11488 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2288 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 11498 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_v_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_v_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let v : (Parsetree.expression) = Obj.magic v in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 11572 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos_v_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2287 \"parsing/parser.mly\"\n (Some v)\n# 11584 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 11589 \"parsing/parser.ml\"\n in\n let d =\n let _1 =\n let _2 = _2_inlined1 in\n let x = \n# 2261 \"parsing/parser.mly\"\n (_2)\n# 11597 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 11602 \"parsing/parser.ml\"\n \n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 11608 \"parsing/parser.ml\"\n \n in\n \n# 2245 \"parsing/parser.mly\"\n ( array, d, Paren, i, r )\n# 11614 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2288 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 11624 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_v_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_v_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let v : (Parsetree.expression) = Obj.magic v in\n let _1 : unit = Obj.magic _1 in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 11686 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos_v_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2287 \"parsing/parser.mly\"\n (Some v)\n# 11696 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 11701 \"parsing/parser.ml\"\n in\n let d =\n let _1 = \n# 124 \"\"\n ( None )\n# 11707 \"parsing/parser.ml\"\n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 11712 \"parsing/parser.ml\"\n \n in\n \n# 2247 \"parsing/parser.mly\"\n ( array, d, Brace, i, r )\n# 11718 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2288 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 11728 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_v_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_v_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let v : (Parsetree.expression) = Obj.magic v in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 11802 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos_v_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2287 \"parsing/parser.mly\"\n (Some v)\n# 11814 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 11819 \"parsing/parser.ml\"\n in\n let d =\n let _1 =\n let _2 = _2_inlined1 in\n let x = \n# 2261 \"parsing/parser.mly\"\n (_2)\n# 11827 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 11832 \"parsing/parser.ml\"\n \n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 11838 \"parsing/parser.ml\"\n \n in\n \n# 2247 \"parsing/parser.mly\"\n ( array, d, Brace, i, r )\n# 11844 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2288 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 11854 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_v_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_v_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let v : (Parsetree.expression) = Obj.magic v in\n let _1 : unit = Obj.magic _1 in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 11916 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos_v_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2287 \"parsing/parser.mly\"\n (Some v)\n# 11926 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 11931 \"parsing/parser.ml\"\n in\n let d =\n let _1 = \n# 124 \"\"\n ( None )\n# 11937 \"parsing/parser.ml\"\n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 11942 \"parsing/parser.ml\"\n \n in\n \n# 2249 \"parsing/parser.mly\"\n ( array, d, Bracket, i, r )\n# 11948 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2288 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 11958 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_v_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_v_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let v : (Parsetree.expression) = Obj.magic v in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 12032 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos_v_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2287 \"parsing/parser.mly\"\n (Some v)\n# 12044 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 12049 \"parsing/parser.ml\"\n in\n let d =\n let _1 =\n let _2 = _2_inlined1 in\n let x = \n# 2261 \"parsing/parser.mly\"\n (_2)\n# 12057 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 12062 \"parsing/parser.ml\"\n \n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 12068 \"parsing/parser.ml\"\n \n in\n \n# 2249 \"parsing/parser.mly\"\n ( array, d, Bracket, i, r )\n# 12074 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_v_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2288 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 12084 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.attribute) = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = \n# 2290 \"parsing/parser.mly\"\n ( Exp.attr _1 _2 )\n# 12116 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.expression) = let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2293 \"parsing/parser.mly\"\n ( not_expecting _loc__1_ \"wildcard \\\"_\\\"\" )\n# 12142 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (string Asttypes.loc option) = \n# 3856 \"parsing/parser.mly\"\n ( None )\n# 12160 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (string Asttypes.loc) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (string Asttypes.loc option) = \n# 3857 \"parsing/parser.mly\"\n ( Some _2 )\n# 12192 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.payload) = Obj.magic _3 in\n let _2 : (string Asttypes.loc) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.extension) = \n# 3869 \"parsing/parser.mly\"\n ( (_2, _3) )\n# 12238 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 745 \"parsing/parser.mly\"\n (string * Location.t * string * Location.t * string option)\n# 12259 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.extension) = let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3871 \"parsing/parser.mly\"\n ( mk_quotedext ~loc:_sloc _1 )\n# 12270 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in\n let _3 : unit = Obj.magic _3 in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.extension_constructor) = let attrs =\n let _1 = _1_inlined3 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 12325 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs_ = _endpos__1_inlined3_ in\n let lid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 12337 \"parsing/parser.ml\"\n \n in\n let cid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 12348 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3217 \"parsing/parser.mly\"\n ( let info = symbol_info _endpos in\n Te.rebind cid lid ~attrs ~loc:(make_loc _sloc) ~info )\n# 12358 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _3 : unit = Obj.magic _3 in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.extension_constructor) = let attrs =\n let _1 = _1_inlined2 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 12406 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs_ = _endpos__1_inlined2_ in\n let lid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 12418 \"parsing/parser.ml\"\n \n in\n let cid =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 12428 \"parsing/parser.ml\"\n \n in\n let _startpos_cid_ = _startpos__1_ in\n let _1 = \n# 3674 \"parsing/parser.mly\"\n ( () )\n# 12435 \"parsing/parser.ml\"\n in\n let _endpos = _endpos_attrs_ in\n let _symbolstartpos = _startpos_cid_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3217 \"parsing/parser.mly\"\n ( let info = symbol_info _endpos in\n Te.rebind cid lid ~attrs ~loc:(make_loc _sloc) ~info )\n# 12444 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.payload) = Obj.magic _3 in\n let _2 : (string Asttypes.loc) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.attribute) = let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3844 \"parsing/parser.mly\"\n ( mark_symbol_docs _sloc;\n Attr.mk ~loc:(make_loc _sloc) _2 _3 )\n# 12494 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = let params = \n# 2038 \"parsing/parser.mly\"\n ( [] )\n# 12512 \"parsing/parser.ml\"\n in\n \n# 1863 \"parsing/parser.mly\"\n ( params )\n# 12517 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let xs : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = let params =\n let params =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 12558 \"parsing/parser.ml\"\n in\n \n# 1021 \"parsing/parser.mly\"\n ( xs )\n# 12563 \"parsing/parser.ml\"\n \n in\n \n# 2040 \"parsing/parser.mly\"\n ( params )\n# 12569 \"parsing/parser.ml\"\n \n in\n \n# 1863 \"parsing/parser.mly\"\n ( params )\n# 12575 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.expression) = \n# 2597 \"parsing/parser.mly\"\n ( _1 )\n# 12600 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2599 \"parsing/parser.mly\"\n ( mkexp_constraint ~loc:_sloc _3 _1 )\n# 12642 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = \n# 2623 \"parsing/parser.mly\"\n ( _2 )\n# 12674 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.core_type) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 = \n# 2625 \"parsing/parser.mly\"\n ( Pexp_constraint (_4, _2) )\n# 12721 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 12730 \"parsing/parser.ml\"\n \n in\n \n# 2626 \"parsing/parser.mly\"\n ( _1 )\n# 12736 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = let _endpos = _endpos__2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2629 \"parsing/parser.mly\"\n (\n let (l,o,p) = _1 in\n ghexp ~loc:_sloc (Pexp_fun(l, o, p, _2))\n )\n# 12774 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let xs : (string Asttypes.loc list) = Obj.magic xs in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _3 = \n# 2495 \"parsing/parser.mly\"\n ( xs )\n# 12827 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2634 \"parsing/parser.mly\"\n ( mk_newtypes ~loc:_sloc _3 _5 )\n# 12835 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_ty_ in\n let _endpos = _endpos_ty_ in\n let _v : (Parsetree.core_type) = \n# 3333 \"parsing/parser.mly\"\n ( ty )\n# 12860 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = codomain;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = label;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_label_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_label_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let codomain : (Parsetree.core_type) = Obj.magic codomain in\n let _3 : unit = Obj.magic _3 in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let label : (string) = Obj.magic label in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_label_ in\n let _endpos = _endpos_codomain_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let domain = \n# 885 \"parsing/parser.mly\"\n ( extra_rhs_core_type _1 ~pos:_endpos__1_ )\n# 12908 \"parsing/parser.ml\"\n in\n let label = \n# 3345 \"parsing/parser.mly\"\n ( Optional label )\n# 12913 \"parsing/parser.ml\"\n in\n \n# 3339 \"parsing/parser.mly\"\n ( Ptyp_arrow(label, domain, codomain) )\n# 12918 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 12928 \"parsing/parser.ml\"\n \n in\n \n# 3341 \"parsing/parser.mly\"\n ( _1 )\n# 12934 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = codomain;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = label;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_label_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_label_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let codomain : (Parsetree.core_type) = Obj.magic codomain in\n let _3 : unit = Obj.magic _3 in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _2 : unit = Obj.magic _2 in\n let label : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 12983 \"parsing/parser.ml\"\n ) = Obj.magic label in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_label_ in\n let _endpos = _endpos_codomain_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let domain = \n# 885 \"parsing/parser.mly\"\n ( extra_rhs_core_type _1 ~pos:_endpos__1_ )\n# 12993 \"parsing/parser.ml\"\n in\n let label = \n# 3347 \"parsing/parser.mly\"\n ( Labelled label )\n# 12998 \"parsing/parser.ml\"\n in\n \n# 3339 \"parsing/parser.mly\"\n ( Ptyp_arrow(label, domain, codomain) )\n# 13003 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_codomain_, _startpos_label_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 13013 \"parsing/parser.ml\"\n \n in\n \n# 3341 \"parsing/parser.mly\"\n ( _1 )\n# 13019 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = codomain;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_codomain_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let codomain : (Parsetree.core_type) = Obj.magic codomain in\n let _3 : unit = Obj.magic _3 in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_codomain_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let domain = \n# 885 \"parsing/parser.mly\"\n ( extra_rhs_core_type _1 ~pos:_endpos__1_ )\n# 13060 \"parsing/parser.ml\"\n in\n let label = \n# 3349 \"parsing/parser.mly\"\n ( Nolabel )\n# 13065 \"parsing/parser.ml\"\n in\n \n# 3339 \"parsing/parser.mly\"\n ( Ptyp_arrow(label, domain, codomain) )\n# 13070 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_codomain_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 13080 \"parsing/parser.ml\"\n \n in\n \n# 3341 \"parsing/parser.mly\"\n ( _1 )\n# 13086 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Lexing.position * Parsetree.functor_parameter) = let _startpos = _startpos__1_ in\n \n# 1275 \"parsing/parser.mly\"\n ( _startpos, Unit )\n# 13119 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = mty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_mty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_mty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let mty : (Parsetree.module_type) = Obj.magic mty in\n let _3 : unit = Obj.magic _3 in\n let _1_inlined1 : (string option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Lexing.position * Parsetree.functor_parameter) = let x =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 13177 \"parsing/parser.ml\"\n \n in\n let _startpos = _startpos__1_ in\n \n# 1278 \"parsing/parser.mly\"\n ( _startpos, Named (x, mty) )\n# 13184 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option) = \n# 3132 \"parsing/parser.mly\"\n ( ([],Pcstr_tuple [],None) )\n# 13203 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.constructor_arguments) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option) = \n# 3133 \"parsing/parser.mly\"\n ( ([],_2,None) )\n# 13236 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : (Parsetree.core_type) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.constructor_arguments) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option) = \n# 3135 \"parsing/parser.mly\"\n ( ([],_2,Some _4) )\n# 13283 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _6 : (Parsetree.core_type) = Obj.magic _6 in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.constructor_arguments) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let xs : (Asttypes.label Asttypes.loc list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__6_ in\n let _v : (Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option) = let _2 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 13346 \"parsing/parser.ml\"\n in\n \n# 989 \"parsing/parser.mly\"\n ( xs )\n# 13351 \"parsing/parser.ml\"\n \n in\n \n# 3268 \"parsing/parser.mly\"\n ( _1 )\n# 13357 \"parsing/parser.ml\"\n \n in\n \n# 3138 \"parsing/parser.mly\"\n ( (_2,_4,Some _6) )\n# 13363 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.core_type) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option) = \n# 3140 \"parsing/parser.mly\"\n ( ([],Pcstr_tuple [],Some _2) )\n# 13396 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : (Parsetree.core_type) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let xs : (Asttypes.label Asttypes.loc list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option) = let _2 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 13445 \"parsing/parser.ml\"\n in\n \n# 989 \"parsing/parser.mly\"\n ( xs )\n# 13450 \"parsing/parser.ml\"\n \n in\n \n# 3268 \"parsing/parser.mly\"\n ( _1 )\n# 13456 \"parsing/parser.ml\"\n \n in\n \n# 3142 \"parsing/parser.mly\"\n ( (_2,Pcstr_tuple [],Some _4) )\n# 13462 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = vars_args_res;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_vars_args_res_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_vars_args_res_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let vars_args_res : (Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option) = Obj.magic vars_args_res in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Ast_helper.str * Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option * Parsetree.attributes * Location.t *\n Docstrings.info) = let attrs =\n let _1 = _1_inlined2 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 13513 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs_ = _endpos__1_inlined2_ in\n let cid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 13525 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3080 \"parsing/parser.mly\"\n (\n let vars, args, res = vars_args_res in\n let info = symbol_info _endpos in\n let loc = make_loc _sloc in\n cid, vars, args, res, attrs, loc, info\n )\n# 13539 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = vars_args_res;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_vars_args_res_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_vars_args_res_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let vars_args_res : (Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option) = Obj.magic vars_args_res in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Ast_helper.str * Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option * Parsetree.attributes * Location.t *\n Docstrings.info) = let attrs =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 13583 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs_ = _endpos__1_inlined1_ in\n let cid =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 13594 \"parsing/parser.ml\"\n \n in\n let _startpos_cid_ = _startpos__1_ in\n let _1 = \n# 3674 \"parsing/parser.mly\"\n ( () )\n# 13601 \"parsing/parser.ml\"\n in\n let _endpos = _endpos_attrs_ in\n let _symbolstartpos = _startpos_cid_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3080 \"parsing/parser.mly\"\n (\n let vars, args, res = vars_args_res in\n let info = symbol_info _endpos in\n let loc = make_loc _sloc in\n cid, vars, args, res, attrs, loc, info\n )\n# 13614 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let xs : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = Obj.magic xs in\n let _2 : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic _2 in\n let _1_inlined3 : unit = Obj.magic _1_inlined3 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 13687 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined4_ in\n let _v : ((Asttypes.rec_flag * string Asttypes.loc option) *\n Parsetree.type_declaration) = let attrs2 =\n let _1 = _1_inlined4 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 13702 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined4_ in\n let cstrs =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 13711 \"parsing/parser.ml\"\n in\n \n# 971 \"parsing/parser.mly\"\n ( xs )\n# 13716 \"parsing/parser.ml\"\n \n in\n \n# 2985 \"parsing/parser.mly\"\n ( _1 )\n# 13722 \"parsing/parser.ml\"\n \n in\n let kind_priv_manifest = \n# 3020 \"parsing/parser.mly\"\n ( _2 )\n# 13728 \"parsing/parser.ml\"\n in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 13738 \"parsing/parser.ml\"\n \n in\n let flag = \n# 3694 \"parsing/parser.mly\"\n ( Recursive )\n# 13744 \"parsing/parser.ml\"\n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 13751 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2957 \"parsing/parser.mly\"\n (\n let (kind, priv, manifest) = kind_priv_manifest in\n let docs = symbol_docs _sloc in\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n (flag, ext),\n Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs\n )\n# 13767 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined5 : (Parsetree.attributes) = Obj.magic _1_inlined5 in\n let xs : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = Obj.magic xs in\n let _2 : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic _2 in\n let _1_inlined4 : unit = Obj.magic _1_inlined4 in\n let _1_inlined3 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 13846 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined3 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let _1_inlined2 : unit = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined5_ in\n let _v : ((Asttypes.rec_flag * string Asttypes.loc option) *\n Parsetree.type_declaration) = let attrs2 =\n let _1 = _1_inlined5 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 13862 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined5_ in\n let cstrs =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 13871 \"parsing/parser.ml\"\n in\n \n# 971 \"parsing/parser.mly\"\n ( xs )\n# 13876 \"parsing/parser.ml\"\n \n in\n \n# 2985 \"parsing/parser.mly\"\n ( _1 )\n# 13882 \"parsing/parser.ml\"\n \n in\n let kind_priv_manifest = \n# 3020 \"parsing/parser.mly\"\n ( _2 )\n# 13888 \"parsing/parser.ml\"\n in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 13898 \"parsing/parser.ml\"\n \n in\n let flag =\n let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined2_, _startpos__1_inlined2_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n let _loc = (_startpos, _endpos) in\n \n# 3696 \"parsing/parser.mly\"\n ( not_expecting _loc \"nonrec flag\" )\n# 13909 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 13917 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2957 \"parsing/parser.mly\"\n (\n let (kind, priv, manifest) = kind_priv_manifest in\n let docs = symbol_docs _sloc in\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n (flag, ext),\n Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs\n )\n# 13933 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = kind_priv_manifest;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_kind_priv_manifest_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_kind_priv_manifest_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let xs : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = Obj.magic xs in\n let kind_priv_manifest : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic kind_priv_manifest in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 13999 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : ((Asttypes.rec_flag * string Asttypes.loc option) *\n Parsetree.type_declaration) = let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 14014 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let cstrs =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 14023 \"parsing/parser.ml\"\n in\n \n# 971 \"parsing/parser.mly\"\n ( xs )\n# 14028 \"parsing/parser.ml\"\n \n in\n \n# 2985 \"parsing/parser.mly\"\n ( _1 )\n# 14034 \"parsing/parser.ml\"\n \n in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 14045 \"parsing/parser.ml\"\n \n in\n let flag = \n# 3690 \"parsing/parser.mly\"\n ( Recursive )\n# 14051 \"parsing/parser.ml\"\n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 14058 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2957 \"parsing/parser.mly\"\n (\n let (kind, priv, manifest) = kind_priv_manifest in\n let docs = symbol_docs _sloc in\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n (flag, ext),\n Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs\n )\n# 14074 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = kind_priv_manifest;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_kind_priv_manifest_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_kind_priv_manifest_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let xs : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = Obj.magic xs in\n let kind_priv_manifest : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic kind_priv_manifest in\n let _1_inlined3 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 14146 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined3 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let _1_inlined2 : unit = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined4_ in\n let _v : ((Asttypes.rec_flag * string Asttypes.loc option) *\n Parsetree.type_declaration) = let attrs2 =\n let _1 = _1_inlined4 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 14162 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined4_ in\n let cstrs =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 14171 \"parsing/parser.ml\"\n in\n \n# 971 \"parsing/parser.mly\"\n ( xs )\n# 14176 \"parsing/parser.ml\"\n \n in\n \n# 2985 \"parsing/parser.mly\"\n ( _1 )\n# 14182 \"parsing/parser.ml\"\n \n in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 14193 \"parsing/parser.ml\"\n \n in\n let flag = \n# 3691 \"parsing/parser.mly\"\n ( Nonrecursive )\n# 14199 \"parsing/parser.ml\"\n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 14206 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2957 \"parsing/parser.mly\"\n (\n let (kind, priv, manifest) = kind_priv_manifest in\n let docs = symbol_docs _sloc in\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n (flag, ext),\n Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs\n )\n# 14222 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 756 \"parsing/parser.mly\"\n (string)\n# 14243 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3533 \"parsing/parser.mly\"\n ( _1 )\n# 14251 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 14272 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3534 \"parsing/parser.mly\"\n ( _1 )\n# 14280 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.structure) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.structure) = \n# 1142 \"parsing/parser.mly\"\n ( _1 )\n# 14312 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (string) = \n# 3583 \"parsing/parser.mly\"\n ( \"\" )\n# 14330 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (string) = \n# 3584 \"parsing/parser.mly\"\n ( \";..\" )\n# 14362 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.signature) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.signature) = \n# 1149 \"parsing/parser.mly\"\n ( _1 )\n# 14394 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.payload) = Obj.magic _3 in\n let _2 : (string Asttypes.loc) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.extension) = \n# 3874 \"parsing/parser.mly\"\n ( (_2, _3) )\n# 14440 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 747 \"parsing/parser.mly\"\n (string * Location.t * string * Location.t * string option)\n# 14461 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.extension) = let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3876 \"parsing/parser.mly\"\n ( mk_quotedext ~loc:_sloc _1 )\n# 14472 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in\n let _3 : unit = Obj.magic _3 in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 14520 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _1 : (Asttypes.mutable_flag) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.label_declaration) = let _5 =\n let _1 = _1_inlined3 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 14531 \"parsing/parser.ml\"\n \n in\n let _endpos__5_ = _endpos__1_inlined3_ in\n let _4 =\n let _1 = _1_inlined2 in\n \n# 3286 \"parsing/parser.mly\"\n ( _1 )\n# 14540 \"parsing/parser.ml\"\n \n in\n let _2 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 14548 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 14556 \"parsing/parser.ml\"\n \n in\n let _startpos__2_ = _startpos__1_inlined1_ in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = if _startpos__1_ != _endpos__1_ then\n _startpos__1_\n else\n _startpos__2_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3159 \"parsing/parser.mly\"\n ( let info = symbol_info _endpos in\n Type.field _2 _4 ~mut:_1 ~attrs:_5 ~loc:(make_loc _sloc) ~info )\n# 14570 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let _6 : unit = Obj.magic _6 in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in\n let _3 : unit = Obj.magic _3 in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 14632 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _1 : (Asttypes.mutable_flag) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined4_ in\n let _v : (Parsetree.label_declaration) = let _7 =\n let _1 = _1_inlined4 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 14643 \"parsing/parser.ml\"\n \n in\n let _endpos__7_ = _endpos__1_inlined4_ in\n let _5 =\n let _1 = _1_inlined3 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 14652 \"parsing/parser.ml\"\n \n in\n let _endpos__5_ = _endpos__1_inlined3_ in\n let _4 =\n let _1 = _1_inlined2 in\n \n# 3286 \"parsing/parser.mly\"\n ( _1 )\n# 14661 \"parsing/parser.ml\"\n \n in\n let _2 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 14669 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 14677 \"parsing/parser.ml\"\n \n in\n let _startpos__2_ = _startpos__1_inlined1_ in\n let _endpos = _endpos__7_ in\n let _symbolstartpos = if _startpos__1_ != _endpos__1_ then\n _startpos__1_\n else\n _startpos__2_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3164 \"parsing/parser.mly\"\n ( let info =\n match rhs_info _endpos__5_ with\n | Some _ as info_before_semi -> info_before_semi\n | None -> symbol_info _endpos\n in\n Type.field _2 _4 ~mut:_1 ~attrs:(_5 @ _7) ~loc:(make_loc _sloc) ~info )\n# 14695 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.label_declaration) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.label_declaration list) = \n# 3153 \"parsing/parser.mly\"\n ( [_1] )\n# 14720 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.label_declaration) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.label_declaration list) = \n# 3154 \"parsing/parser.mly\"\n ( [_1] )\n# 14745 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.label_declaration list) = Obj.magic _2 in\n let _1 : (Parsetree.label_declaration) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.label_declaration list) = \n# 3155 \"parsing/parser.mly\"\n ( _1 :: _2 )\n# 14777 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 14798 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string * Parsetree.pattern) = let x =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 14811 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2233 \"parsing/parser.mly\"\n ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) )\n# 14820 \"parsing/parser.ml\"\n \n in\n \n# 2225 \"parsing/parser.mly\"\n ( x )\n# 14826 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = cty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_cty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_cty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let cty : (Parsetree.core_type) = Obj.magic cty in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 14861 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_cty_ in\n let _v : (string * Parsetree.pattern) = let x =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 14874 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2233 \"parsing/parser.mly\"\n ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) )\n# 14883 \"parsing/parser.ml\"\n \n in\n let _startpos_x_ = _startpos__1_ in\n let _endpos = _endpos_cty_ in\n let _symbolstartpos = _startpos_x_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2227 \"parsing/parser.mly\"\n ( let lab, pat = x in\n lab,\n mkpat ~loc:_sloc (Ppat_constraint (pat, cty)) )\n# 14895 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3615 \"parsing/parser.mly\"\n ( _1 )\n# 14920 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.arg_label * Parsetree.expression) = \n# 2478 \"parsing/parser.mly\"\n ( (Nolabel, _1) )\n# 14945 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : (\n# 692 \"parsing/parser.mly\"\n (string)\n# 14973 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.arg_label * Parsetree.expression) = \n# 2480 \"parsing/parser.mly\"\n ( (Labelled _1, _2) )\n# 14981 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = label;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_label_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_label_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let label : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 15008 \"parsing/parser.ml\"\n ) = Obj.magic label in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_label_ in\n let _v : (Asttypes.arg_label * Parsetree.expression) = let _loc_label_ = (_startpos_label_, _endpos_label_) in\n \n# 2482 \"parsing/parser.mly\"\n ( let loc = _loc_label_ in\n (Labelled label, mkexpvar ~loc label) )\n# 15019 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = label;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_label_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_label_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let ty : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic ty in\n let label : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 15066 \"parsing/parser.ml\"\n ) = Obj.magic label in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Asttypes.arg_label * Parsetree.expression) = let _endpos = _endpos__5_ in\n let _loc_label_ = (_startpos_label_, _endpos_label_) in\n \n# 2485 \"parsing/parser.mly\"\n ( (Labelled label, mkexp_constraint ~loc:(_startpos__2_, _endpos)\n (mkexpvar ~loc:_loc_label_ label) ty) )\n# 15079 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = label;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_label_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_label_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let label : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 15106 \"parsing/parser.ml\"\n ) = Obj.magic label in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_label_ in\n let _v : (Asttypes.arg_label * Parsetree.expression) = let _loc_label_ = (_startpos_label_, _endpos_label_) in\n \n# 2488 \"parsing/parser.mly\"\n ( let loc = _loc_label_ in\n (Optional label, mkexpvar ~loc label) )\n# 15117 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : (\n# 722 \"parsing/parser.mly\"\n (string)\n# 15145 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.arg_label * Parsetree.expression) = \n# 2491 \"parsing/parser.mly\"\n ( (Optional _1, _2) )\n# 15153 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined1 : (Parsetree.expression option) = Obj.magic _1_inlined1 in\n let _3 : (string * Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = let _4 =\n let _1 = _1_inlined1 in\n \n# 2221 \"parsing/parser.mly\"\n ( _1 )\n# 15208 \"parsing/parser.ml\"\n \n in\n \n# 2195 \"parsing/parser.mly\"\n ( (Optional (fst _3), _4, snd _3) )\n# 15214 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 15241 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = let _2 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 15256 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2233 \"parsing/parser.mly\"\n ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) )\n# 15265 \"parsing/parser.ml\"\n \n in\n \n# 2197 \"parsing/parser.mly\"\n ( (Optional (fst _2), None, snd _2) )\n# 15271 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined1 : (Parsetree.expression option) = Obj.magic _1_inlined1 in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 722 \"parsing/parser.mly\"\n (string)\n# 15320 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = let _4 =\n let _1 = _1_inlined1 in\n \n# 2221 \"parsing/parser.mly\"\n ( _1 )\n# 15330 \"parsing/parser.ml\"\n \n in\n \n# 2199 \"parsing/parser.mly\"\n ( (Optional _1, _4, _3) )\n# 15336 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : (\n# 722 \"parsing/parser.mly\"\n (string)\n# 15364 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = \n# 2201 \"parsing/parser.mly\"\n ( (Optional _1, None, _2) )\n# 15372 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (string * Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = \n# 2203 \"parsing/parser.mly\"\n ( (Labelled (fst _3), None, snd _3) )\n# 15418 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 15445 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = let _2 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 15460 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2233 \"parsing/parser.mly\"\n ( (_1.Location.txt, mkpat ~loc:_sloc (Ppat_var _1)) )\n# 15469 \"parsing/parser.ml\"\n \n in\n \n# 2205 \"parsing/parser.mly\"\n ( (Labelled (fst _2), None, snd _2) )\n# 15475 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : (\n# 692 \"parsing/parser.mly\"\n (string)\n# 15503 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = \n# 2207 \"parsing/parser.mly\"\n ( (Labelled _1, None, _2) )\n# 15511 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = \n# 2209 \"parsing/parser.mly\"\n ( (Nolabel, None, _1) )\n# 15536 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.pattern * Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern * Parsetree.expression * bool) = \n# 2534 \"parsing/parser.mly\"\n ( let p,e = _1 in (p,e,false) )\n# 15561 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern * Parsetree.expression * bool) = let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n let _loc = (_startpos, _endpos) in\n \n# 2537 \"parsing/parser.mly\"\n ( (mkpatvar ~loc:_loc _1, mkexpvar ~loc:_loc _1, true) )\n# 15589 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.pattern * Parsetree.expression) = let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2498 \"parsing/parser.mly\"\n ( mkpatvar ~loc:_sloc _1 )\n# 15625 \"parsing/parser.ml\"\n \n in\n \n# 2502 \"parsing/parser.mly\"\n ( (_1, _2) )\n# 15631 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _2 in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.pattern * Parsetree.expression) = let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2498 \"parsing/parser.mly\"\n ( mkpatvar ~loc:_sloc _1 )\n# 15681 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2504 \"parsing/parser.mly\"\n ( let v = _1 in (* PR#7344 *)\n let t =\n match _2 with\n Some t, None -> t\n | _, Some t -> t\n | _ -> assert false\n in\n let loc = Location.(t.ptyp_loc.loc_start, t.ptyp_loc.loc_end) in\n let typ = ghtyp ~loc (Ptyp_poly([],t)) in\n let patloc = (_startpos__1_, _endpos__2_) in\n (ghpat ~loc:patloc (Ppat_constraint(v, typ)),\n mkexp_constraint ~loc:_sloc _4 _2) )\n# 15701 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.core_type) = Obj.magic _3 in\n let _2_inlined1 : unit = Obj.magic _2_inlined1 in\n let xs : (Asttypes.label Asttypes.loc list) = Obj.magic xs in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.pattern * Parsetree.expression) = let _3 =\n let _1 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 15771 \"parsing/parser.ml\"\n in\n \n# 989 \"parsing/parser.mly\"\n ( xs )\n# 15776 \"parsing/parser.ml\"\n \n in\n \n# 3268 \"parsing/parser.mly\"\n ( _1 )\n# 15782 \"parsing/parser.ml\"\n \n in\n \n# 3272 \"parsing/parser.mly\"\n ( Ptyp_poly(_1, _3) )\n# 15788 \"parsing/parser.ml\"\n \n in\n let _startpos__3_ = _startpos_xs_ in\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2498 \"parsing/parser.mly\"\n ( mkpatvar ~loc:_sloc _1 )\n# 15799 \"parsing/parser.ml\"\n \n in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2517 \"parsing/parser.mly\"\n ( let patloc = (_startpos__1_, _endpos__3_) in\n (ghpat ~loc:patloc\n (Ppat_constraint(_1, ghtyp ~loc:(_loc__3_) _3)),\n _5) )\n# 15809 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _8;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__8_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__8_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _8 : (Parsetree.expression) = Obj.magic _8 in\n let _7 : unit = Obj.magic _7 in\n let _6 : (Parsetree.core_type) = Obj.magic _6 in\n let _5 : unit = Obj.magic _5 in\n let xs : (string Asttypes.loc list) = Obj.magic xs in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__8_ in\n let _v : (Parsetree.pattern * Parsetree.expression) = let _4 = \n# 2495 \"parsing/parser.mly\"\n ( xs )\n# 15883 \"parsing/parser.ml\"\n in\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2498 \"parsing/parser.mly\"\n ( mkpatvar ~loc:_sloc _1 )\n# 15892 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__8_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2522 \"parsing/parser.mly\"\n ( let exp, poly =\n wrap_type_annotation ~loc:_sloc _4 _6 _8 in\n let loc = (_startpos__1_, _endpos__6_) in\n (ghpat ~loc (Ppat_constraint(_1, poly)), exp) )\n# 15904 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern * Parsetree.expression) = \n# 2527 \"parsing/parser.mly\"\n ( (_1, _3) )\n# 15943 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.core_type) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.pattern * Parsetree.expression) = \n# 2529 \"parsing/parser.mly\"\n ( let loc = (_startpos__1_, _endpos__3_) in\n (ghpat ~loc (Ppat_constraint(_1, _3)), _5) )\n# 15997 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = rec_flag;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_rec_flag_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_rec_flag_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let body : (Parsetree.pattern * Parsetree.expression * bool) = Obj.magic body in\n let rec_flag : (Asttypes.rec_flag) = Obj.magic rec_flag in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (let_bindings) = let _1 =\n let attrs2 =\n let _1 = _1_inlined2 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 16060 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined2_ in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 16069 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2557 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n mklbs ext rec_flag (mklb ~loc:_sloc true body attrs)\n )\n# 16081 \"parsing/parser.ml\"\n \n in\n \n# 2547 \"parsing/parser.mly\"\n ( _1 )\n# 16087 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (let_binding) = Obj.magic _2 in\n let _1 : (let_bindings) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (let_bindings) = \n# 2548 \"parsing/parser.mly\"\n ( addlb _1 _2 )\n# 16119 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = rec_flag;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_rec_flag_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_rec_flag_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let body : (Parsetree.pattern * Parsetree.expression * bool) = Obj.magic body in\n let rec_flag : (Asttypes.rec_flag) = Obj.magic rec_flag in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (let_bindings) = let _1 =\n let attrs2 =\n let _1 = _1_inlined2 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 16175 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined2_ in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 16184 \"parsing/parser.ml\"\n \n in\n let ext = \n# 3860 \"parsing/parser.mly\"\n ( None )\n# 16190 \"parsing/parser.ml\"\n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2557 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n mklbs ext rec_flag (mklb ~loc:_sloc true body attrs)\n )\n# 16201 \"parsing/parser.ml\"\n \n in\n \n# 2547 \"parsing/parser.mly\"\n ( _1 )\n# 16207 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = rec_flag;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_rec_flag_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_rec_flag_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let body : (Parsetree.pattern * Parsetree.expression * bool) = Obj.magic body in\n let rec_flag : (Asttypes.rec_flag) = Obj.magic rec_flag in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _2 : (string Asttypes.loc) = Obj.magic _2 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (let_bindings) = let _1 =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 16277 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let attrs1 =\n let _1 = _1_inlined2 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 16286 \"parsing/parser.ml\"\n \n in\n let ext =\n let _startpos__1_ = _startpos__1_inlined1_ in\n let _endpos = _endpos__2_ in\n let _startpos = _startpos__1_ in\n let _loc = (_startpos, _endpos) in\n \n# 3862 \"parsing/parser.mly\"\n ( not_expecting _loc \"extension\" )\n# 16297 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2557 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n mklbs ext rec_flag (mklb ~loc:_sloc true body attrs)\n )\n# 16309 \"parsing/parser.ml\"\n \n in\n \n# 2547 \"parsing/parser.mly\"\n ( _1 )\n# 16315 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (let_binding) = Obj.magic _2 in\n let _1 : (let_bindings) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (let_bindings) = \n# 2548 \"parsing/parser.mly\"\n ( addlb _1 _2 )\n# 16347 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = \n# 2237 \"parsing/parser.mly\"\n ( _1 )\n# 16372 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.core_type) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 = \n# 2239 \"parsing/parser.mly\"\n ( Ppat_constraint(_1, _3) )\n# 16412 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 16421 \"parsing/parser.ml\"\n \n in\n \n# 2240 \"parsing/parser.mly\"\n ( _1 )\n# 16427 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = exp;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_exp_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_exp_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let exp : (Parsetree.expression) = Obj.magic exp in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_exp_ in\n let _v : (Parsetree.pattern * Parsetree.expression) = let pat =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2498 \"parsing/parser.mly\"\n ( mkpatvar ~loc:_sloc _1 )\n# 16463 \"parsing/parser.ml\"\n \n in\n \n# 2574 \"parsing/parser.mly\"\n ( (pat, exp) )\n# 16469 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern * Parsetree.expression) = let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n let _loc = (_startpos, _endpos) in\n \n# 2577 \"parsing/parser.mly\"\n ( (mkpatvar ~loc:_loc _1, mkexpvar ~loc:_loc _1) )\n# 16497 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = exp;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_exp_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_exp_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = typ;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_typ_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_typ_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = pat;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_pat_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_pat_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let exp : (Parsetree.expression) = Obj.magic exp in\n let _4 : unit = Obj.magic _4 in\n let typ : (Parsetree.core_type) = Obj.magic typ in\n let _2 : unit = Obj.magic _2 in\n let pat : (Parsetree.pattern) = Obj.magic pat in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_pat_ in\n let _endpos = _endpos_exp_ in\n let _v : (Parsetree.pattern * Parsetree.expression) = \n# 2579 \"parsing/parser.mly\"\n ( let loc = (_startpos_pat_, _endpos_typ_) in\n (ghpat ~loc (Ppat_constraint(pat, typ)), exp) )\n# 16551 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = exp;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_exp_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_exp_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = pat;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_pat_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_pat_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let exp : (Parsetree.expression) = Obj.magic exp in\n let _2 : unit = Obj.magic _2 in\n let pat : (Parsetree.pattern) = Obj.magic pat in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_pat_ in\n let _endpos = _endpos_exp_ in\n let _v : (Parsetree.pattern * Parsetree.expression) = \n# 2582 \"parsing/parser.mly\"\n ( (pat, exp) )\n# 16590 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let body : (Parsetree.pattern * Parsetree.expression) = Obj.magic body in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_body_ in\n let _endpos = _endpos_body_ in\n let _v : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = \n# 2586 \"parsing/parser.mly\"\n ( let let_pat, let_exp = body in\n let_pat, let_exp, [] )\n# 16616 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = bindings;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_bindings_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_bindings_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let body : (Parsetree.pattern * Parsetree.expression) = Obj.magic body in\n let _1 : (\n# 688 \"parsing/parser.mly\"\n (string)\n# 16650 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let bindings : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = Obj.magic bindings in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_bindings_ in\n let _endpos = _endpos_body_ in\n let _v : (Parsetree.pattern * Parsetree.expression * Parsetree.binding_op list) = let pbop_op =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 16663 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_body_ in\n let _symbolstartpos = _startpos_bindings_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2589 \"parsing/parser.mly\"\n ( let let_pat, let_exp, rev_ands = bindings in\n let pbop_pat, pbop_exp = body in\n let pbop_loc = make_loc _sloc in\n let and_ = {pbop_op; pbop_pat; pbop_exp; pbop_loc} in\n let_pat, let_exp, and_ :: rev_ands )\n# 16676 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.class_declaration list) = \n# 211 \"\"\n ( [] )\n# 16694 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = virt;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_virt_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_virt_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.class_declaration list) = Obj.magic xs in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let body : (Parsetree.class_expr) = Obj.magic body in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 16760 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let virt : (Asttypes.virtual_flag) = Obj.magic virt in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.class_declaration list) = let x =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 16775 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 16787 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 16795 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1841 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n let text = symbol_text _symbolstartpos in\n Ci.mk id body ~virt ~params ~attrs ~loc ~text ~docs\n )\n# 16810 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 16816 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.class_description list) = \n# 211 \"\"\n ( [] )\n# 16834 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = cty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_cty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_cty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = virt;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_virt_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_virt_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.class_description list) = Obj.magic xs in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let cty : (Parsetree.class_type) = Obj.magic cty in\n let _6 : unit = Obj.magic _6 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 16907 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let virt : (Asttypes.virtual_flag) = Obj.magic virt in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.class_description list) = let x =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 16922 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 16934 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 16942 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2132 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n let text = symbol_text _symbolstartpos in\n Ci.mk id cty ~virt ~params ~attrs ~loc ~text ~docs\n )\n# 16957 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 16963 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.class_type_declaration list) = \n# 211 \"\"\n ( [] )\n# 16981 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = csig;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_csig_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_csig_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = virt;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_virt_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_virt_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.class_type_declaration list) = Obj.magic xs in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let csig : (Parsetree.class_type) = Obj.magic csig in\n let _6 : unit = Obj.magic _6 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 17054 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let virt : (Asttypes.virtual_flag) = Obj.magic virt in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.class_type_declaration list) = let x =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 17069 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 17081 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 17089 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2171 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n let text = symbol_text _symbolstartpos in\n Ci.mk id csig ~virt ~params ~attrs ~loc ~text ~docs\n )\n# 17104 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 17110 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.module_binding list) = \n# 211 \"\"\n ( [] )\n# 17128 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.module_binding list) = Obj.magic xs in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let body : (Parsetree.module_expr) = Obj.magic body in\n let _1_inlined2 : (string option) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.module_binding list) = let x =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 17191 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let name =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 17203 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 17211 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1503 \"parsing/parser.mly\"\n (\n let loc = make_loc _sloc in\n let attrs = attrs1 @ attrs2 in\n let docs = symbol_docs _sloc in\n let text = symbol_text _symbolstartpos in\n Mb.mk name body ~attrs ~loc ~text ~docs\n )\n# 17226 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 17232 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.module_declaration list) = \n# 211 \"\"\n ( [] )\n# 17250 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = mty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_mty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_mty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.module_declaration list) = Obj.magic xs in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let mty : (Parsetree.module_type) = Obj.magic mty in\n let _4 : unit = Obj.magic _4 in\n let _1_inlined2 : (string option) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.module_declaration list) = let x =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 17320 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let name =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 17332 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 17340 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1782 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let docs = symbol_docs _sloc in\n let loc = make_loc _sloc in\n let text = symbol_text _symbolstartpos in\n Md.mk name mty ~attrs ~loc ~text ~docs\n )\n# 17355 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 17361 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.attributes) = \n# 211 \"\"\n ( [] )\n# 17379 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.attributes) = Obj.magic xs in\n let x : (Parsetree.attribute) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.attributes) = \n# 213 \"\"\n ( x :: xs )\n# 17411 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.type_declaration list) = \n# 211 \"\"\n ( [] )\n# 17429 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = kind_priv_manifest;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_kind_priv_manifest_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_kind_priv_manifest_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.type_declaration list) = Obj.magic xs in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let xs_inlined1 : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = Obj.magic xs_inlined1 in\n let kind_priv_manifest : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic kind_priv_manifest in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 17496 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.type_declaration list) = let x =\n let xs = xs_inlined1 in\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 17511 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let cstrs =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 17520 \"parsing/parser.ml\"\n in\n \n# 971 \"parsing/parser.mly\"\n ( xs )\n# 17525 \"parsing/parser.ml\"\n \n in\n \n# 2985 \"parsing/parser.mly\"\n ( _1 )\n# 17531 \"parsing/parser.ml\"\n \n in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 17542 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 17550 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2974 \"parsing/parser.mly\"\n (\n let (kind, priv, manifest) = kind_priv_manifest in\n let docs = symbol_docs _sloc in\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let text = symbol_text _symbolstartpos in\n Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ~text\n )\n# 17566 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 17572 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.type_declaration list) = \n# 211 \"\"\n ( [] )\n# 17590 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.type_declaration list) = Obj.magic xs in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let xs_inlined1 : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = Obj.magic xs_inlined1 in\n let _2 : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic _2 in\n let _1_inlined3 : unit = Obj.magic _1_inlined3 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 17664 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.type_declaration list) = let x =\n let xs = xs_inlined1 in\n let attrs2 =\n let _1 = _1_inlined4 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 17679 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined4_ in\n let cstrs =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 17688 \"parsing/parser.ml\"\n in\n \n# 971 \"parsing/parser.mly\"\n ( xs )\n# 17693 \"parsing/parser.ml\"\n \n in\n \n# 2985 \"parsing/parser.mly\"\n ( _1 )\n# 17699 \"parsing/parser.ml\"\n \n in\n let kind_priv_manifest = \n# 3020 \"parsing/parser.mly\"\n ( _2 )\n# 17705 \"parsing/parser.ml\"\n in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 17715 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 17723 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2974 \"parsing/parser.mly\"\n (\n let (kind, priv, manifest) = kind_priv_manifest in\n let docs = symbol_docs _sloc in\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let text = symbol_text _symbolstartpos in\n Type.mk id ~params ~cstrs ~kind ~priv ?manifest ~attrs ~loc ~docs ~text\n )\n# 17739 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 17745 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.attributes) = \n# 211 \"\"\n ( [] )\n# 17763 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.attributes) = Obj.magic xs in\n let x : (Parsetree.attribute) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.attributes) = \n# 213 \"\"\n ( x :: xs )\n# 17795 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.signature_item list list) = \n# 211 \"\"\n ( [] )\n# 17813 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.signature_item list list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.signature_item list list) = let x =\n let _1 =\n let _startpos = _startpos__1_ in\n \n# 897 \"parsing/parser.mly\"\n ( text_sig _startpos )\n# 17848 \"parsing/parser.ml\"\n \n in\n \n# 1641 \"parsing/parser.mly\"\n ( _1 )\n# 17854 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 17860 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.signature_item list list) = Obj.magic xs in\n let _1 : (Parsetree.signature_item) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.signature_item list list) = let x =\n let _1 =\n let _startpos = _startpos__1_ in\n \n# 895 \"parsing/parser.mly\"\n ( text_sig _startpos @ [_1] )\n# 17895 \"parsing/parser.ml\"\n \n in\n \n# 1641 \"parsing/parser.mly\"\n ( _1 )\n# 17901 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 17907 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.structure_item list list) = \n# 211 \"\"\n ( [] )\n# 17925 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.structure_item list list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.structure_item list list) = let x =\n let _1 =\n let ys =\n let items = \n# 957 \"parsing/parser.mly\"\n ( [] )\n# 17960 \"parsing/parser.ml\"\n in\n \n# 1386 \"parsing/parser.mly\"\n ( items )\n# 17965 \"parsing/parser.ml\"\n \n in\n let xs =\n let _startpos = _startpos__1_ in\n \n# 893 \"parsing/parser.mly\"\n ( text_str _startpos )\n# 17973 \"parsing/parser.ml\"\n \n in\n \n# 267 \"\"\n ( xs @ ys )\n# 17979 \"parsing/parser.ml\"\n \n in\n \n# 1402 \"parsing/parser.mly\"\n ( _1 )\n# 17985 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 17991 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.structure_item list list) = Obj.magic xs in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let e : (Parsetree.expression) = Obj.magic e in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.structure_item list list) = let x =\n let _1 =\n let ys =\n let (_endpos__1_, _1) = (_endpos__1_inlined1_, _1_inlined1) in\n let items =\n let x =\n let _1 =\n let _1 =\n let attrs = \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 18045 \"parsing/parser.ml\"\n in\n \n# 1393 \"parsing/parser.mly\"\n ( mkstrexp e attrs )\n# 18050 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos_e_ in\n let _startpos = _startpos__1_ in\n \n# 891 \"parsing/parser.mly\"\n ( text_str _startpos @ [_1] )\n# 18058 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos_e_ in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 910 \"parsing/parser.mly\"\n ( mark_rhs_docs _startpos _endpos;\n _1 )\n# 18068 \"parsing/parser.ml\"\n \n in\n \n# 959 \"parsing/parser.mly\"\n ( x )\n# 18074 \"parsing/parser.ml\"\n \n in\n \n# 1386 \"parsing/parser.mly\"\n ( items )\n# 18080 \"parsing/parser.ml\"\n \n in\n let xs =\n let _startpos = _startpos__1_ in\n \n# 893 \"parsing/parser.mly\"\n ( text_str _startpos )\n# 18088 \"parsing/parser.ml\"\n \n in\n \n# 267 \"\"\n ( xs @ ys )\n# 18094 \"parsing/parser.ml\"\n \n in\n \n# 1402 \"parsing/parser.mly\"\n ( _1 )\n# 18100 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 18106 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.structure_item list list) = Obj.magic xs in\n let _1 : (Parsetree.structure_item) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.structure_item list list) = let x =\n let _1 =\n let _startpos = _startpos__1_ in\n \n# 891 \"parsing/parser.mly\"\n ( text_str _startpos @ [_1] )\n# 18141 \"parsing/parser.ml\"\n \n in\n \n# 1402 \"parsing/parser.mly\"\n ( _1 )\n# 18147 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 18153 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.class_type_field list list) = \n# 211 \"\"\n ( [] )\n# 18171 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.class_type_field list list) = Obj.magic xs in\n let _1 : (Parsetree.class_type_field) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.class_type_field list list) = let x =\n let _startpos = _startpos__1_ in\n \n# 905 \"parsing/parser.mly\"\n ( text_csig _startpos @ [_1] )\n# 18205 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 18211 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.class_field list list) = \n# 211 \"\"\n ( [] )\n# 18229 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.class_field list list) = Obj.magic xs in\n let _1 : (Parsetree.class_field) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.class_field list list) = let x =\n let _startpos = _startpos__1_ in\n \n# 903 \"parsing/parser.mly\"\n ( text_cstr _startpos @ [_1] )\n# 18263 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 18269 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.structure_item list list) = \n# 211 \"\"\n ( [] )\n# 18287 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.structure_item list list) = Obj.magic xs in\n let _1 : (Parsetree.structure_item) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.structure_item list list) = let x =\n let _startpos = _startpos__1_ in\n \n# 891 \"parsing/parser.mly\"\n ( text_str _startpos @ [_1] )\n# 18321 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 18327 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.toplevel_phrase list list) = \n# 211 \"\"\n ( [] )\n# 18345 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.toplevel_phrase list list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.toplevel_phrase list list) = let x =\n let _1 =\n let x =\n let _1 = \n# 957 \"parsing/parser.mly\"\n ( [] )\n# 18380 \"parsing/parser.ml\"\n in\n \n# 1189 \"parsing/parser.mly\"\n ( _1 )\n# 18385 \"parsing/parser.ml\"\n \n in\n \n# 183 \"\"\n ( x )\n# 18391 \"parsing/parser.ml\"\n \n in\n \n# 1201 \"parsing/parser.mly\"\n ( _1 )\n# 18397 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 18403 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.toplevel_phrase list list) = Obj.magic xs in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let e : (Parsetree.expression) = Obj.magic e in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.toplevel_phrase list list) = let x =\n let _1 =\n let x =\n let _1 = _1_inlined1 in\n let _1 =\n let x =\n let _1 =\n let _1 =\n let attrs = \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 18457 \"parsing/parser.ml\"\n in\n \n# 1393 \"parsing/parser.mly\"\n ( mkstrexp e attrs )\n# 18462 \"parsing/parser.ml\"\n \n in\n \n# 901 \"parsing/parser.mly\"\n ( Ptop_def [_1] )\n# 18468 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos_e_ in\n let _startpos = _startpos__1_ in\n \n# 899 \"parsing/parser.mly\"\n ( text_def _startpos @ [_1] )\n# 18476 \"parsing/parser.ml\"\n \n in\n \n# 959 \"parsing/parser.mly\"\n ( x )\n# 18482 \"parsing/parser.ml\"\n \n in\n \n# 1189 \"parsing/parser.mly\"\n ( _1 )\n# 18488 \"parsing/parser.ml\"\n \n in\n \n# 183 \"\"\n ( x )\n# 18494 \"parsing/parser.ml\"\n \n in\n \n# 1201 \"parsing/parser.mly\"\n ( _1 )\n# 18500 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 18506 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.toplevel_phrase list list) = Obj.magic xs in\n let _1 : (Parsetree.structure_item) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.toplevel_phrase list list) = let x =\n let _1 =\n let _1 = \n# 901 \"parsing/parser.mly\"\n ( Ptop_def [_1] )\n# 18540 \"parsing/parser.ml\"\n in\n let _startpos = _startpos__1_ in\n \n# 899 \"parsing/parser.mly\"\n ( text_def _startpos @ [_1] )\n# 18546 \"parsing/parser.ml\"\n \n in\n \n# 1201 \"parsing/parser.mly\"\n ( _1 )\n# 18552 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 18558 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (Parsetree.toplevel_phrase list list) = Obj.magic xs in\n let _1 : (Parsetree.toplevel_phrase) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.toplevel_phrase list list) = let x =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 910 \"parsing/parser.mly\"\n ( mark_rhs_docs _startpos _endpos;\n _1 )\n# 18596 \"parsing/parser.ml\"\n \n in\n let _startpos = _startpos__1_ in\n \n# 899 \"parsing/parser.mly\"\n ( text_def _startpos @ [_1] )\n# 18603 \"parsing/parser.ml\"\n \n in\n \n# 1201 \"parsing/parser.mly\"\n ( _1 )\n# 18609 \"parsing/parser.ml\"\n \n in\n \n# 213 \"\"\n ( x :: xs )\n# 18615 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = opat;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_opat_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_opat_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = octy;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_octy_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_octy_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let opat : (Parsetree.pattern option) = Obj.magic opat in\n let octy : (Parsetree.core_type option) = Obj.magic octy in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_opat_ in\n let _v : ((Longident.t Asttypes.loc * Parsetree.pattern) list * unit option) = let _2 = \n# 124 \"\"\n ( None )\n# 18654 \"parsing/parser.ml\"\n in\n let x =\n let label =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 18664 \"parsing/parser.ml\"\n \n in\n let _startpos_label_ = _startpos__1_ in\n let _endpos = _endpos_opat_ in\n let _symbolstartpos = _startpos_label_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2860 \"parsing/parser.mly\"\n ( let constraint_loc, label, pat =\n match opat with\n | None ->\n (* No pattern; this is a pun. Desugar it.\n But that the pattern was there and the label reconstructed (which\n piece of AST is marked as ghost is important for warning\n emission). *)\n _sloc, make_ghost label, pat_of_label label\n | Some pat ->\n (_startpos_octy_, _endpos), label, pat\n in\n label, mkpat_opt_constraint ~loc:constraint_loc pat octy\n )\n# 18686 \"parsing/parser.ml\"\n \n in\n \n# 1126 \"parsing/parser.mly\"\n ( [x], None )\n# 18692 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = opat;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_opat_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_opat_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = octy;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_octy_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_octy_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let x : unit = Obj.magic x in\n let opat : (Parsetree.pattern option) = Obj.magic opat in\n let octy : (Parsetree.core_type option) = Obj.magic octy in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_x_ in\n let _v : ((Longident.t Asttypes.loc * Parsetree.pattern) list * unit option) = let _2 = \n# 126 \"\"\n ( Some x )\n# 18738 \"parsing/parser.ml\"\n in\n let x =\n let label =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 18748 \"parsing/parser.ml\"\n \n in\n let _startpos_label_ = _startpos__1_ in\n let _endpos = _endpos_opat_ in\n let _symbolstartpos = _startpos_label_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2860 \"parsing/parser.mly\"\n ( let constraint_loc, label, pat =\n match opat with\n | None ->\n (* No pattern; this is a pun. Desugar it.\n But that the pattern was there and the label reconstructed (which\n piece of AST is marked as ghost is important for warning\n emission). *)\n _sloc, make_ghost label, pat_of_label label\n | Some pat ->\n (_startpos_octy_, _endpos), label, pat\n in\n label, mkpat_opt_constraint ~loc:constraint_loc pat octy\n )\n# 18770 \"parsing/parser.ml\"\n \n in\n \n# 1126 \"parsing/parser.mly\"\n ( [x], None )\n# 18776 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = y;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_y_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_y_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = opat;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_opat_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_opat_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = octy;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_octy_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_octy_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _4 : (unit option) = Obj.magic _4 in\n let y : unit = Obj.magic y in\n let _2 : unit = Obj.magic _2 in\n let opat : (Parsetree.pattern option) = Obj.magic opat in\n let octy : (Parsetree.core_type option) = Obj.magic octy in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : ((Longident.t Asttypes.loc * Parsetree.pattern) list * unit option) = let x =\n let label =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 18841 \"parsing/parser.ml\"\n \n in\n let _startpos_label_ = _startpos__1_ in\n let _endpos = _endpos_opat_ in\n let _symbolstartpos = _startpos_label_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2860 \"parsing/parser.mly\"\n ( let constraint_loc, label, pat =\n match opat with\n | None ->\n (* No pattern; this is a pun. Desugar it.\n But that the pattern was there and the label reconstructed (which\n piece of AST is marked as ghost is important for warning\n emission). *)\n _sloc, make_ghost label, pat_of_label label\n | Some pat ->\n (_startpos_octy_, _endpos), label, pat\n in\n label, mkpat_opt_constraint ~loc:constraint_loc pat octy\n )\n# 18863 \"parsing/parser.ml\"\n \n in\n \n# 1128 \"parsing/parser.mly\"\n ( [x], Some y )\n# 18869 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = tail;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_tail_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_tail_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = opat;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_opat_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_opat_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = octy;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_octy_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_octy_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let tail : ((Longident.t Asttypes.loc * Parsetree.pattern) list * unit option) = Obj.magic tail in\n let _2 : unit = Obj.magic _2 in\n let opat : (Parsetree.pattern option) = Obj.magic opat in\n let octy : (Parsetree.core_type option) = Obj.magic octy in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_tail_ in\n let _v : ((Longident.t Asttypes.loc * Parsetree.pattern) list * unit option) = let x =\n let label =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 18927 \"parsing/parser.ml\"\n \n in\n let _startpos_label_ = _startpos__1_ in\n let _endpos = _endpos_opat_ in\n let _symbolstartpos = _startpos_label_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2860 \"parsing/parser.mly\"\n ( let constraint_loc, label, pat =\n match opat with\n | None ->\n (* No pattern; this is a pun. Desugar it.\n But that the pattern was there and the label reconstructed (which\n piece of AST is marked as ghost is important for warning\n emission). *)\n _sloc, make_ghost label, pat_of_label label\n | Some pat ->\n (_startpos_octy_, _endpos), label, pat\n in\n label, mkpat_opt_constraint ~loc:constraint_loc pat octy\n )\n# 18949 \"parsing/parser.ml\"\n \n in\n \n# 1132 \"parsing/parser.mly\"\n ( let xs, y = tail in\n x :: xs, y )\n# 18956 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.case) = \n# 2615 \"parsing/parser.mly\"\n ( Exp.case _1 _3 )\n# 18995 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.case) = \n# 2617 \"parsing/parser.mly\"\n ( Exp.case _1 ~guard:_3 _5 )\n# 19048 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.case) = let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2619 \"parsing/parser.mly\"\n ( Exp.case _1 (Exp.unreachable ~loc:(make_loc _loc__3_) ()) )\n# 19088 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = tail;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_tail_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_tail_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let tail : (Parsetree.object_field list * Asttypes.closed_flag) = Obj.magic tail in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 19151 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_tail_ in\n let _v : (Parsetree.object_field list * Asttypes.closed_flag) = let head =\n let _6 =\n let _1 = _1_inlined3 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 19162 \"parsing/parser.ml\"\n \n in\n let _endpos__6_ = _endpos__1_inlined3_ in\n let _4 =\n let _1 = _1_inlined2 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 19171 \"parsing/parser.ml\"\n \n in\n let _endpos__4_ = _endpos__1_inlined2_ in\n let _3 =\n let _1 = _1_inlined1 in\n \n# 3286 \"parsing/parser.mly\"\n ( _1 )\n# 19180 \"parsing/parser.ml\"\n \n in\n let _1 =\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 19187 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 19195 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__6_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3496 \"parsing/parser.mly\"\n ( let info =\n match rhs_info _endpos__4_ with\n | Some _ as info_before_semi -> info_before_semi\n | None -> symbol_info _endpos\n in\n let attrs = add_info_attrs info (_4 @ _6) in\n Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 )\n# 19210 \"parsing/parser.ml\"\n \n in\n \n# 3477 \"parsing/parser.mly\"\n ( let (f, c) = tail in (head :: f, c) )\n# 19216 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = tail;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_tail_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_tail_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let tail : (Parsetree.object_field list * Asttypes.closed_flag) = Obj.magic tail in\n let _2 : unit = Obj.magic _2 in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_ty_ in\n let _endpos = _endpos_tail_ in\n let _v : (Parsetree.object_field list * Asttypes.closed_flag) = let head =\n let _endpos = _endpos_ty_ in\n let _symbolstartpos = _startpos_ty_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3507 \"parsing/parser.mly\"\n ( Of.inherit_ ~loc:(make_loc _sloc) ty )\n# 19259 \"parsing/parser.ml\"\n \n in\n \n# 3477 \"parsing/parser.mly\"\n ( let (f, c) = tail in (head :: f, c) )\n# 19265 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 19321 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.object_field list * Asttypes.closed_flag) = let head =\n let _6 =\n let _1 = _1_inlined3 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 19332 \"parsing/parser.ml\"\n \n in\n let _endpos__6_ = _endpos__1_inlined3_ in\n let _4 =\n let _1 = _1_inlined2 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 19341 \"parsing/parser.ml\"\n \n in\n let _endpos__4_ = _endpos__1_inlined2_ in\n let _3 =\n let _1 = _1_inlined1 in\n \n# 3286 \"parsing/parser.mly\"\n ( _1 )\n# 19350 \"parsing/parser.ml\"\n \n in\n let _1 =\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 19357 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 19365 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__6_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3496 \"parsing/parser.mly\"\n ( let info =\n match rhs_info _endpos__4_ with\n | Some _ as info_before_semi -> info_before_semi\n | None -> symbol_info _endpos\n in\n let attrs = add_info_attrs info (_4 @ _6) in\n Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 )\n# 19380 \"parsing/parser.ml\"\n \n in\n \n# 3480 \"parsing/parser.mly\"\n ( [head], Closed )\n# 19386 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_ty_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.object_field list * Asttypes.closed_flag) = let head =\n let _endpos = _endpos_ty_ in\n let _symbolstartpos = _startpos_ty_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3507 \"parsing/parser.mly\"\n ( Of.inherit_ ~loc:(make_loc _sloc) ty )\n# 19422 \"parsing/parser.ml\"\n \n in\n \n# 3480 \"parsing/parser.mly\"\n ( [head], Closed )\n# 19428 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 19470 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.object_field list * Asttypes.closed_flag) = let head =\n let _4 =\n let _1 = _1_inlined2 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 19481 \"parsing/parser.ml\"\n \n in\n let _endpos__4_ = _endpos__1_inlined2_ in\n let _3 =\n let _1 = _1_inlined1 in\n \n# 3286 \"parsing/parser.mly\"\n ( _1 )\n# 19490 \"parsing/parser.ml\"\n \n in\n let _1 =\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 19497 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 19505 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3489 \"parsing/parser.mly\"\n ( let info = symbol_info _endpos in\n let attrs = add_info_attrs info _4 in\n Of.tag ~loc:(make_loc _sloc) ~attrs _1 _3 )\n# 19516 \"parsing/parser.ml\"\n \n in\n \n# 3483 \"parsing/parser.mly\"\n ( [head], Closed )\n# 19522 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_ty_ in\n let _endpos = _endpos_ty_ in\n let _v : (Parsetree.object_field list * Asttypes.closed_flag) = let head =\n let _endpos = _endpos_ty_ in\n let _symbolstartpos = _startpos_ty_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3507 \"parsing/parser.mly\"\n ( Of.inherit_ ~loc:(make_loc _sloc) ty )\n# 19551 \"parsing/parser.ml\"\n \n in\n \n# 3483 \"parsing/parser.mly\"\n ( [head], Closed )\n# 19557 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.object_field list * Asttypes.closed_flag) = \n# 3485 \"parsing/parser.mly\"\n ( [], Open )\n# 19582 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = private_;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_private__;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_private__;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 19629 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let private_ : (Asttypes.private_flag) = Obj.magic private_ in\n let _1 : (Parsetree.attributes) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.private_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let ty =\n let _1 = _1_inlined2 in\n \n# 3282 \"parsing/parser.mly\"\n ( _1 )\n# 19643 \"parsing/parser.ml\"\n \n in\n let label =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 19651 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 19659 \"parsing/parser.ml\"\n \n in\n let attrs = \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 19665 \"parsing/parser.ml\"\n in\n let _1 = \n# 3752 \"parsing/parser.mly\"\n ( Fresh )\n# 19670 \"parsing/parser.ml\"\n in\n \n# 1979 \"parsing/parser.mly\"\n ( (label, private_, Cfk_virtual ty), attrs )\n# 19675 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 19715 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _3 : (Asttypes.private_flag) = Obj.magic _3 in\n let _1 : (Parsetree.attributes) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.private_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 19729 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 19737 \"parsing/parser.ml\"\n \n in\n let _2 = \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 19743 \"parsing/parser.ml\"\n in\n let _1 = \n# 3755 \"parsing/parser.mly\"\n ( Fresh )\n# 19748 \"parsing/parser.ml\"\n in\n \n# 1981 \"parsing/parser.mly\"\n ( let e = _5 in\n let loc = Location.(e.pexp_loc.loc_start, e.pexp_loc.loc_end) in\n (_4, _3,\n Cfk_concrete (_1, ghexp ~loc (Pexp_poly (e, None)))), _2 )\n# 19756 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 19802 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let _3 : (Asttypes.private_flag) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.private_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 19817 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 19825 \"parsing/parser.ml\"\n \n in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 19833 \"parsing/parser.ml\"\n \n in\n let _1 = \n# 3756 \"parsing/parser.mly\"\n ( Override )\n# 19839 \"parsing/parser.ml\"\n in\n \n# 1981 \"parsing/parser.mly\"\n ( let e = _5 in\n let loc = Location.(e.pexp_loc.loc_start, e.pexp_loc.loc_end) in\n (_4, _3,\n Cfk_concrete (_1, ghexp ~loc (Pexp_poly (e, None)))), _2 )\n# 19847 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _8;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__8_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__8_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _8 : (Parsetree.expression) = Obj.magic _8 in\n let _7 : unit = Obj.magic _7 in\n let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 19908 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _3 : (Asttypes.private_flag) = Obj.magic _3 in\n let _1 : (Parsetree.attributes) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__8_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.private_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let _6 =\n let _1 = _1_inlined2 in\n \n# 3282 \"parsing/parser.mly\"\n ( _1 )\n# 19922 \"parsing/parser.ml\"\n \n in\n let _startpos__6_ = _startpos__1_inlined2_ in\n let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 19931 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 19939 \"parsing/parser.ml\"\n \n in\n let _2 = \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 19945 \"parsing/parser.ml\"\n in\n let _1 = \n# 3755 \"parsing/parser.mly\"\n ( Fresh )\n# 19950 \"parsing/parser.ml\"\n in\n \n# 1987 \"parsing/parser.mly\"\n ( let poly_exp =\n let loc = (_startpos__6_, _endpos__8_) in\n ghexp ~loc (Pexp_poly(_8, Some _6)) in\n (_4, _3, Cfk_concrete (_1, poly_exp)), _2 )\n# 19958 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _8;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__8_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__8_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _8 : (Parsetree.expression) = Obj.magic _8 in\n let _7 : unit = Obj.magic _7 in\n let _1_inlined3 : (Parsetree.core_type) = Obj.magic _1_inlined3 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 20025 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let _3 : (Asttypes.private_flag) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__8_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.private_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let _6 =\n let _1 = _1_inlined3 in\n \n# 3282 \"parsing/parser.mly\"\n ( _1 )\n# 20040 \"parsing/parser.ml\"\n \n in\n let _startpos__6_ = _startpos__1_inlined3_ in\n let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 20049 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 20057 \"parsing/parser.ml\"\n \n in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 20065 \"parsing/parser.ml\"\n \n in\n let _1 = \n# 3756 \"parsing/parser.mly\"\n ( Override )\n# 20071 \"parsing/parser.ml\"\n in\n \n# 1987 \"parsing/parser.mly\"\n ( let poly_exp =\n let loc = (_startpos__6_, _endpos__8_) in\n ghexp ~loc (Pexp_poly(_8, Some _6)) in\n (_4, _3, Cfk_concrete (_1, poly_exp)), _2 )\n# 20079 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _11;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__11_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__11_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _10;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__10_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__10_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _9;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__9_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__9_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _8;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__8_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__8_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _11 : (Parsetree.expression) = Obj.magic _11 in\n let _10 : unit = Obj.magic _10 in\n let _9 : (Parsetree.core_type) = Obj.magic _9 in\n let _8 : unit = Obj.magic _8 in\n let xs : (string Asttypes.loc list) = Obj.magic xs in\n let _6 : unit = Obj.magic _6 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 20161 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _3 : (Asttypes.private_flag) = Obj.magic _3 in\n let _1 : (Parsetree.attributes) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__11_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.private_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let _7 = \n# 2495 \"parsing/parser.mly\"\n ( xs )\n# 20173 \"parsing/parser.ml\"\n in\n let _startpos__7_ = _startpos_xs_ in\n let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 20181 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 20189 \"parsing/parser.ml\"\n \n in\n let _startpos__4_ = _startpos__1_inlined1_ in\n let _2 = \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 20196 \"parsing/parser.ml\"\n in\n let (_endpos__2_, _startpos__2_) = (_endpos__1_, _startpos__1_) in\n let _1 = \n# 3755 \"parsing/parser.mly\"\n ( Fresh )\n# 20202 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos__0_, _endpos__0_) in\n let _endpos = _endpos__11_ in\n let _symbolstartpos = if _startpos__1_ != _endpos__1_ then\n _startpos__1_\n else\n if _startpos__2_ != _endpos__2_ then\n _startpos__2_\n else\n if _startpos__3_ != _endpos__3_ then\n _startpos__3_\n else\n _startpos__4_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1993 \"parsing/parser.mly\"\n ( let poly_exp_loc = (_startpos__7_, _endpos__11_) in\n let poly_exp =\n let exp, poly =\n (* it seems odd to use the global ~loc here while poly_exp_loc\n is tighter, but this is what ocamlyacc does;\n TODO improve parser.mly *)\n wrap_type_annotation ~loc:_sloc _7 _9 _11 in\n ghexp ~loc:poly_exp_loc (Pexp_poly(exp, Some poly)) in\n (_4, _3,\n Cfk_concrete (_1, poly_exp)), _2 )\n# 20229 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _11;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__11_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__11_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _10;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__10_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__10_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _9;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__9_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__9_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _8;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__8_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__8_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _11 : (Parsetree.expression) = Obj.magic _11 in\n let _10 : unit = Obj.magic _10 in\n let _9 : (Parsetree.core_type) = Obj.magic _9 in\n let _8 : unit = Obj.magic _8 in\n let xs : (string Asttypes.loc list) = Obj.magic xs in\n let _6 : unit = Obj.magic _6 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 20317 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let _3 : (Asttypes.private_flag) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__11_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.private_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let _7 = \n# 2495 \"parsing/parser.mly\"\n ( xs )\n# 20330 \"parsing/parser.ml\"\n in\n let _startpos__7_ = _startpos_xs_ in\n let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 20338 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 20346 \"parsing/parser.ml\"\n \n in\n let _startpos__4_ = _startpos__1_inlined2_ in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 20355 \"parsing/parser.ml\"\n \n in\n let (_endpos__2_, _startpos__2_) = (_endpos__1_inlined1_, _startpos__1_inlined1_) in\n let _1 = \n# 3756 \"parsing/parser.mly\"\n ( Override )\n# 20362 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__11_ in\n let _symbolstartpos = if _startpos__1_ != _endpos__1_ then\n _startpos__1_\n else\n if _startpos__2_ != _endpos__2_ then\n _startpos__2_\n else\n if _startpos__3_ != _endpos__3_ then\n _startpos__3_\n else\n _startpos__4_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1993 \"parsing/parser.mly\"\n ( let poly_exp_loc = (_startpos__7_, _endpos__11_) in\n let poly_exp =\n let exp, poly =\n (* it seems odd to use the global ~loc here while poly_exp_loc\n is tighter, but this is what ocamlyacc does;\n TODO improve parser.mly *)\n wrap_type_annotation ~loc:_sloc _7 _9 _11 in\n ghexp ~loc:poly_exp_loc (Pexp_poly(exp, Some poly)) in\n (_4, _3,\n Cfk_concrete (_1, poly_exp)), _2 )\n# 20388 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 20409 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3608 \"parsing/parser.mly\"\n ( Lident _1 )\n# 20417 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 20450 \"parsing/parser.ml\"\n ) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Longident.t) = \n# 3609 \"parsing/parser.mly\"\n ( Ldot(_1,_3) )\n# 20460 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 756 \"parsing/parser.mly\"\n (string)\n# 20481 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3608 \"parsing/parser.mly\"\n ( Lident _1 )\n# 20489 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (\n# 756 \"parsing/parser.mly\"\n (string)\n# 20522 \"parsing/parser.ml\"\n ) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Longident.t) = \n# 3609 \"parsing/parser.mly\"\n ( Ldot(_1,_3) )\n# 20532 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = let _1 = \n# 3646 \"parsing/parser.mly\"\n ( _1 )\n# 20557 \"parsing/parser.ml\"\n in\n \n# 3608 \"parsing/parser.mly\"\n ( Lident _1 )\n# 20562 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Longident.t) = let _1 =\n let _1 = \n# 3588 \"parsing/parser.mly\"\n ( \"::\" )\n# 20602 \"parsing/parser.ml\"\n in\n \n# 3646 \"parsing/parser.mly\"\n ( _1 )\n# 20607 \"parsing/parser.ml\"\n \n in\n \n# 3608 \"parsing/parser.mly\"\n ( Lident _1 )\n# 20613 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = let _1 = \n# 3646 \"parsing/parser.mly\"\n ( _1 )\n# 20638 \"parsing/parser.ml\"\n in\n \n# 3608 \"parsing/parser.mly\"\n ( Lident _1 )\n# 20643 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Longident.t) = let _3 =\n let _1 = _1_inlined1 in\n \n# 3646 \"parsing/parser.mly\"\n ( _1 )\n# 20684 \"parsing/parser.ml\"\n \n in\n \n# 3609 \"parsing/parser.mly\"\n ( Ldot(_1,_3) )\n# 20690 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2_inlined1 : unit = Obj.magic _2_inlined1 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Longident.t) = let _3 =\n let _1 = \n# 3588 \"parsing/parser.mly\"\n ( \"::\" )\n# 20744 \"parsing/parser.ml\"\n in\n \n# 3646 \"parsing/parser.mly\"\n ( _1 )\n# 20749 \"parsing/parser.ml\"\n \n in\n \n# 3609 \"parsing/parser.mly\"\n ( Ldot(_1,_3) )\n# 20755 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Longident.t) = let _3 =\n let _1 = _1_inlined1 in\n \n# 3646 \"parsing/parser.mly\"\n ( _1 )\n# 20796 \"parsing/parser.ml\"\n \n in\n \n# 3609 \"parsing/parser.mly\"\n ( Ldot(_1,_3) )\n# 20802 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3608 \"parsing/parser.mly\"\n ( Lident _1 )\n# 20827 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Asttypes.label) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Longident.t) = \n# 3609 \"parsing/parser.mly\"\n ( Ldot(_1,_3) )\n# 20866 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 20887 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3608 \"parsing/parser.mly\"\n ( Lident _1 )\n# 20895 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 20928 \"parsing/parser.ml\"\n ) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Longident.t) = \n# 3609 \"parsing/parser.mly\"\n ( Ldot(_1,_3) )\n# 20938 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 756 \"parsing/parser.mly\"\n (string)\n# 20959 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3608 \"parsing/parser.mly\"\n ( Lident _1 )\n# 20967 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (\n# 756 \"parsing/parser.mly\"\n (string)\n# 21000 \"parsing/parser.ml\"\n ) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Longident.t) = \n# 3609 \"parsing/parser.mly\"\n ( Ldot(_1,_3) )\n# 21010 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3608 \"parsing/parser.mly\"\n ( Lident _1 )\n# 21035 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Asttypes.label) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Longident.t) = \n# 3609 \"parsing/parser.mly\"\n ( Ldot(_1,_3) )\n# 21074 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3624 \"parsing/parser.mly\"\n ( _1 )\n# 21099 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Longident.t) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Longident.t) = let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3626 \"parsing/parser.mly\"\n ( lapply ~loc:_sloc _1 _3 )\n# 21148 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Longident.t) = let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 3628 \"parsing/parser.mly\"\n ( expecting _loc__3_ \"module path\" )\n# 21188 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3621 \"parsing/parser.mly\"\n ( _1 )\n# 21213 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = me;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let me : (Parsetree.module_expr) = Obj.magic me in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_me_ in\n let _v : (Parsetree.module_expr) = \n# 1462 \"parsing/parser.mly\"\n ( me )\n# 21245 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = me;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = mty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_mty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_mty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let me : (Parsetree.module_expr) = Obj.magic me in\n let _3 : unit = Obj.magic _3 in\n let mty : (Parsetree.module_type) = Obj.magic mty in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_me_ in\n let _v : (Parsetree.module_expr) = let _1 =\n let _1 = \n# 1465 \"parsing/parser.mly\"\n ( Pmod_constraint(me, mty) )\n# 21292 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos_me_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 930 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc _1 )\n# 21301 \"parsing/parser.ml\"\n \n in\n \n# 1469 \"parsing/parser.mly\"\n ( _1 )\n# 21307 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = arg_and_pos;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_arg_and_pos_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_arg_and_pos_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let body : (Parsetree.module_expr) = Obj.magic body in\n let arg_and_pos : (Lexing.position * Parsetree.functor_parameter) = Obj.magic arg_and_pos in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_arg_and_pos_ in\n let _endpos = _endpos_body_ in\n let _v : (Parsetree.module_expr) = let _1 =\n let _1 = \n# 1467 \"parsing/parser.mly\"\n ( let (_, arg) = arg_and_pos in\n Pmod_functor(arg, body) )\n# 21341 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_body_, _startpos_arg_and_pos_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 930 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc _1 )\n# 21350 \"parsing/parser.ml\"\n \n in\n \n# 1469 \"parsing/parser.mly\"\n ( _1 )\n# 21356 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = mty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_mty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_mty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let mty : (Parsetree.module_type) = Obj.magic mty in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_mty_ in\n let _v : (Parsetree.module_type) = \n# 1708 \"parsing/parser.mly\"\n ( mty )\n# 21388 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = arg_and_pos;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_arg_and_pos_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_arg_and_pos_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let body : (Parsetree.module_type) = Obj.magic body in\n let arg_and_pos : (Lexing.position * Parsetree.functor_parameter) = Obj.magic arg_and_pos in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_arg_and_pos_ in\n let _endpos = _endpos_body_ in\n let _v : (Parsetree.module_type) = let _1 =\n let _1 = \n# 1711 \"parsing/parser.mly\"\n ( let (_, arg) = arg_and_pos in\n Pmty_functor(arg, body) )\n# 21422 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_body_, _startpos_arg_and_pos_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 932 \"parsing/parser.mly\"\n ( mkmty ~loc:_sloc _1 )\n# 21431 \"parsing/parser.ml\"\n \n in\n \n# 1714 \"parsing/parser.mly\"\n ( _1 )\n# 21437 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = s;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_s_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_s_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let s : (Parsetree.structure) = Obj.magic s in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.module_expr) = let attrs =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 21485 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1301 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc ~attrs (Pmod_structure s) )\n# 21494 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.structure) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.module_expr) = let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 21542 \"parsing/parser.ml\"\n \n in\n let _loc__4_ = (_startpos__4_, _endpos__4_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1303 \"parsing/parser.mly\"\n ( unclosed \"struct\" _loc__1_ \"end\" _loc__4_ )\n# 21550 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = me;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let me : (Parsetree.module_expr) = Obj.magic me in\n let _4 : unit = Obj.magic _4 in\n let _1_inlined2 : ((Lexing.position * Parsetree.functor_parameter) list) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_me_ in\n let _v : (Parsetree.module_expr) = let args =\n let _1 = _1_inlined2 in\n \n# 1267 \"parsing/parser.mly\"\n ( _1 )\n# 21605 \"parsing/parser.ml\"\n \n in\n let attrs =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 21613 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_me_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1305 \"parsing/parser.mly\"\n ( wrap_mod_attrs ~loc:_sloc attrs (\n List.fold_left (fun acc (startpos, arg) ->\n mkmod ~loc:(startpos, _endpos) (Pmod_functor (arg, acc))\n ) me args\n ) )\n# 21626 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = me;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let me : (Parsetree.module_expr) = Obj.magic me in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_me_ in\n let _endpos = _endpos_me_ in\n let _v : (Parsetree.module_expr) = \n# 1311 \"parsing/parser.mly\"\n ( me )\n# 21651 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = attr;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_attr_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_attr_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = me;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let attr : (Parsetree.attribute) = Obj.magic attr in\n let me : (Parsetree.module_expr) = Obj.magic me in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_me_ in\n let _endpos = _endpos_attr_ in\n let _v : (Parsetree.module_expr) = \n# 1313 \"parsing/parser.mly\"\n ( Mod.attr me attr )\n# 21683 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.module_expr) = let _1 =\n let _1 =\n let x =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 21714 \"parsing/parser.ml\"\n \n in\n \n# 1317 \"parsing/parser.mly\"\n ( Pmod_ident x )\n# 21720 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 930 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc _1 )\n# 21729 \"parsing/parser.ml\"\n \n in\n \n# 1329 \"parsing/parser.mly\"\n ( _1 )\n# 21735 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = me2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = me1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let me2 : (Parsetree.module_expr) = Obj.magic me2 in\n let me1 : (Parsetree.module_expr) = Obj.magic me1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_me1_ in\n let _endpos = _endpos_me2_ in\n let _v : (Parsetree.module_expr) = let _1 =\n let _1 = \n# 1320 \"parsing/parser.mly\"\n ( Pmod_apply(me1, me2) )\n# 21768 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_me2_, _startpos_me1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 930 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc _1 )\n# 21777 \"parsing/parser.ml\"\n \n in\n \n# 1329 \"parsing/parser.mly\"\n ( _1 )\n# 21783 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = me1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let me1 : (Parsetree.module_expr) = Obj.magic me1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_me1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.module_expr) = let _1 =\n let _1 =\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos_me1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1323 \"parsing/parser.mly\"\n ( (* TODO review mkmod location *)\n Pmod_apply(me1, mkmod ~loc:_sloc (Pmod_structure [])) )\n# 21828 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos__3_, _startpos_me1_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 930 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc _1 )\n# 21838 \"parsing/parser.ml\"\n \n in\n \n# 1329 \"parsing/parser.mly\"\n ( _1 )\n# 21844 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = ex;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ex_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ex_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let ex : (Parsetree.extension) = Obj.magic ex in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_ex_ in\n let _endpos = _endpos_ex_ in\n let _v : (Parsetree.module_expr) = let _1 =\n let _1 = \n# 1327 \"parsing/parser.mly\"\n ( Pmod_extension ex )\n# 21870 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_ex_, _startpos_ex_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 930 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc _1 )\n# 21879 \"parsing/parser.ml\"\n \n in\n \n# 1329 \"parsing/parser.mly\"\n ( _1 )\n# 21885 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (\n# 756 \"parsing/parser.mly\"\n (string)\n# 21906 \"parsing/parser.ml\"\n ) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (string option) = \n# 1284 \"parsing/parser.mly\"\n ( Some x )\n# 21914 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string option) = \n# 1287 \"parsing/parser.mly\"\n ( None )\n# 21939 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (\n# 756 \"parsing/parser.mly\"\n (string)\n# 21999 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined4_ in\n let _v : (Parsetree.module_substitution * string Asttypes.loc option) = let attrs2 =\n let _1 = _1_inlined4 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 22012 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined4_ in\n let body =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 22024 \"parsing/parser.ml\"\n \n in\n let uid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 22035 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 22043 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1744 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Ms.mk uid body ~attrs ~loc ~docs, ext\n )\n# 22057 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _6 : unit = Obj.magic _6 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (\n# 756 \"parsing/parser.mly\"\n (string)\n# 22110 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : (string Asttypes.loc option) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__6_ in\n let _v : (Parsetree.module_substitution * string Asttypes.loc option) = let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 22126 \"parsing/parser.ml\"\n \n in\n let _3 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 22134 \"parsing/parser.ml\"\n \n in\n let _loc__6_ = (_startpos__6_, _endpos__6_) in\n \n# 1751 \"parsing/parser.mly\"\n ( expecting _loc__6_ \"module path\" )\n# 22141 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = s;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_s_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_s_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let s : (Parsetree.signature) = Obj.magic s in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.module_type) = let attrs =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 22189 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1594 \"parsing/parser.mly\"\n ( mkmty ~loc:_sloc ~attrs (Pmty_signature s) )\n# 22198 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.signature) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.module_type) = let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 22246 \"parsing/parser.ml\"\n \n in\n let _loc__4_ = (_startpos__4_, _endpos__4_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1596 \"parsing/parser.mly\"\n ( unclosed \"sig\" _loc__1_ \"end\" _loc__4_ )\n# 22254 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = mty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_mty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_mty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let mty : (Parsetree.module_type) = Obj.magic mty in\n let _4 : unit = Obj.magic _4 in\n let _1_inlined2 : ((Lexing.position * Parsetree.functor_parameter) list) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_mty_ in\n let _v : (Parsetree.module_type) = let args =\n let _1 = _1_inlined2 in\n \n# 1267 \"parsing/parser.mly\"\n ( _1 )\n# 22309 \"parsing/parser.ml\"\n \n in\n let attrs =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 22317 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_mty_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1600 \"parsing/parser.mly\"\n ( wrap_mty_attrs ~loc:_sloc attrs (\n List.fold_left (fun acc (startpos, arg) ->\n mkmty ~loc:(startpos, _endpos) (Pmty_functor (arg, acc))\n ) mty args\n ) )\n# 22330 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : (Parsetree.module_expr) = Obj.magic _5 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.module_type) = let _4 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 22385 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1606 \"parsing/parser.mly\"\n ( mkmty ~loc:_sloc ~attrs:_4 (Pmty_typeof _5) )\n# 22394 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.module_type) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.module_type) = \n# 1608 \"parsing/parser.mly\"\n ( _2 )\n# 22433 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.module_type) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.module_type) = let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1610 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__3_ )\n# 22474 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.attribute) = Obj.magic _2 in\n let _1 : (Parsetree.module_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.module_type) = \n# 1612 \"parsing/parser.mly\"\n ( Mty.attr _1 _2 )\n# 22506 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.module_type) = let _1 =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 22537 \"parsing/parser.ml\"\n \n in\n \n# 1615 \"parsing/parser.mly\"\n ( Pmty_ident _1 )\n# 22543 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 932 \"parsing/parser.mly\"\n ( mkmty ~loc:_sloc _1 )\n# 22552 \"parsing/parser.ml\"\n \n in\n \n# 1626 \"parsing/parser.mly\"\n ( _1 )\n# 22558 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.module_type) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.module_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.module_type) = let _1 =\n let _1 = \n# 1618 \"parsing/parser.mly\"\n ( Pmty_functor(Named (mknoloc None, _1), _3) )\n# 22598 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 932 \"parsing/parser.mly\"\n ( mkmty ~loc:_sloc _1 )\n# 22607 \"parsing/parser.ml\"\n \n in\n \n# 1626 \"parsing/parser.mly\"\n ( _1 )\n# 22613 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.with_constraint list) = Obj.magic xs in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.module_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.module_type) = let _1 =\n let _1 =\n let _3 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 22655 \"parsing/parser.ml\"\n in\n \n# 1021 \"parsing/parser.mly\"\n ( xs )\n# 22660 \"parsing/parser.ml\"\n \n in\n \n# 1620 \"parsing/parser.mly\"\n ( Pmty_with(_1, _3) )\n# 22666 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_xs_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 932 \"parsing/parser.mly\"\n ( mkmty ~loc:_sloc _1 )\n# 22676 \"parsing/parser.ml\"\n \n in\n \n# 1626 \"parsing/parser.mly\"\n ( _1 )\n# 22682 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.extension) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.module_type) = let _1 =\n let _1 = \n# 1624 \"parsing/parser.mly\"\n ( Pmty_extension _1 )\n# 22708 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 932 \"parsing/parser.mly\"\n ( mkmty ~loc:_sloc _1 )\n# 22716 \"parsing/parser.ml\"\n \n in\n \n# 1626 \"parsing/parser.mly\"\n ( _1 )\n# 22722 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = typ;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_typ_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_typ_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let typ : (Parsetree.module_type option) = Obj.magic typ in\n let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.module_type_declaration * string Asttypes.loc option) = let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 22791 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 22803 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 22811 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1540 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Mtd.mk id ?typ ~attrs ~loc ~docs, ext\n )\n# 22825 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = typ;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_typ_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_typ_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let typ : (Parsetree.module_type) = Obj.magic typ in\n let _6 : unit = Obj.magic _6 in\n let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.module_type_declaration * string Asttypes.loc option) = let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 22901 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 22913 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 22921 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1800 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Mtd.mk id ~typ ~attrs ~loc ~docs, ext\n )\n# 22935 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3631 \"parsing/parser.mly\"\n ( _1 )\n# 22960 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Asttypes.mutable_flag) = \n# 3712 \"parsing/parser.mly\"\n ( Immutable )\n# 22978 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.mutable_flag) = \n# 3713 \"parsing/parser.mly\"\n ( Mutable )\n# 23003 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = \n# 3721 \"parsing/parser.mly\"\n ( Immutable, Concrete )\n# 23021 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = \n# 3723 \"parsing/parser.mly\"\n ( Mutable, Concrete )\n# 23046 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = \n# 3725 \"parsing/parser.mly\"\n ( Immutable, Virtual )\n# 23071 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = \n# 3728 \"parsing/parser.mly\"\n ( Mutable, Virtual )\n# 23103 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.mutable_flag * Asttypes.virtual_flag) = \n# 3728 \"parsing/parser.mly\"\n ( Mutable, Virtual )\n# 23135 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Asttypes.label) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.label) = \n# 3683 \"parsing/parser.mly\"\n ( _2 )\n# 23167 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 23188 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string Asttypes.loc list) = let x =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 23200 \"parsing/parser.ml\"\n \n in\n \n# 221 \"\"\n ( [ x ] )\n# 23206 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (string Asttypes.loc list) = Obj.magic xs in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 23234 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (string Asttypes.loc list) = let x =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 23246 \"parsing/parser.ml\"\n \n in\n \n# 223 \"\"\n ( x :: xs )\n# 23252 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = s;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_s_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_s_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let s : (\n# 743 \"parsing/parser.mly\"\n (string * Location.t * string option)\n# 23273 \"parsing/parser.ml\"\n ) = Obj.magic s in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_s_ in\n let _endpos = _endpos_s_ in\n let _v : (string list) = let x = \n# 3679 \"parsing/parser.mly\"\n ( let body, _, _ = s in body )\n# 23281 \"parsing/parser.ml\"\n in\n \n# 221 \"\"\n ( [ x ] )\n# 23286 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = s;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_s_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_s_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let xs : (string list) = Obj.magic xs in\n let s : (\n# 743 \"parsing/parser.mly\"\n (string * Location.t * string option)\n# 23314 \"parsing/parser.ml\"\n ) = Obj.magic s in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_s_ in\n let _endpos = _endpos_xs_ in\n let _v : (string list) = let x = \n# 3679 \"parsing/parser.mly\"\n ( let body, _, _ = s in body )\n# 23322 \"parsing/parser.ml\"\n in\n \n# 223 \"\"\n ( x :: xs )\n# 23327 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_ty_ in\n let _endpos = _endpos_ty_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3708 \"parsing/parser.mly\"\n ( Public )\n# 23352 \"parsing/parser.ml\"\n in\n \n# 2994 \"parsing/parser.mly\"\n ( (Ptype_abstract, priv, Some ty) )\n# 23357 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_ty_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3709 \"parsing/parser.mly\"\n ( Private )\n# 23389 \"parsing/parser.ml\"\n in\n \n# 2994 \"parsing/parser.mly\"\n ( (Ptype_abstract, priv, Some ty) )\n# 23394 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = cs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_cs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_cs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let cs : (Parsetree.constructor_declaration list) = Obj.magic cs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_cs_ in\n let _endpos = _endpos_cs_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3708 \"parsing/parser.mly\"\n ( Public )\n# 23419 \"parsing/parser.ml\"\n in\n let oty =\n let _1 = \n# 124 \"\"\n ( None )\n# 23425 \"parsing/parser.ml\"\n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 23430 \"parsing/parser.ml\"\n \n in\n \n# 2998 \"parsing/parser.mly\"\n ( (Ptype_variant cs, priv, oty) )\n# 23436 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = cs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_cs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_cs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let cs : (Parsetree.constructor_declaration list) = Obj.magic cs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_cs_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3709 \"parsing/parser.mly\"\n ( Private )\n# 23468 \"parsing/parser.ml\"\n in\n let oty =\n let _1 = \n# 124 \"\"\n ( None )\n# 23474 \"parsing/parser.ml\"\n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 23479 \"parsing/parser.ml\"\n \n in\n \n# 2998 \"parsing/parser.mly\"\n ( (Ptype_variant cs, priv, oty) )\n# 23485 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = cs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_cs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_cs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let cs : (Parsetree.constructor_declaration list) = Obj.magic cs in\n let _2 : unit = Obj.magic _2 in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_cs_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3708 \"parsing/parser.mly\"\n ( Public )\n# 23524 \"parsing/parser.ml\"\n in\n let oty =\n let _1 =\n let x = \n# 191 \"\"\n ( x )\n# 23531 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 23536 \"parsing/parser.ml\"\n \n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 23542 \"parsing/parser.ml\"\n \n in\n \n# 2998 \"parsing/parser.mly\"\n ( (Ptype_variant cs, priv, oty) )\n# 23548 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = cs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_cs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_cs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let cs : (Parsetree.constructor_declaration list) = Obj.magic cs in\n let _1 : unit = Obj.magic _1 in\n let _2 : unit = Obj.magic _2 in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_cs_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3709 \"parsing/parser.mly\"\n ( Private )\n# 23594 \"parsing/parser.ml\"\n in\n let oty =\n let _1 =\n let x = \n# 191 \"\"\n ( x )\n# 23601 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 23606 \"parsing/parser.ml\"\n \n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 23612 \"parsing/parser.ml\"\n \n in\n \n# 2998 \"parsing/parser.mly\"\n ( (Ptype_variant cs, priv, oty) )\n# 23618 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__3_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3708 \"parsing/parser.mly\"\n ( Public )\n# 23643 \"parsing/parser.ml\"\n in\n let oty =\n let _1 = \n# 124 \"\"\n ( None )\n# 23649 \"parsing/parser.ml\"\n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 23654 \"parsing/parser.ml\"\n \n in\n \n# 3002 \"parsing/parser.mly\"\n ( (Ptype_open, priv, oty) )\n# 23660 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3709 \"parsing/parser.mly\"\n ( Private )\n# 23692 \"parsing/parser.ml\"\n in\n let oty =\n let _1 = \n# 124 \"\"\n ( None )\n# 23698 \"parsing/parser.ml\"\n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 23703 \"parsing/parser.ml\"\n \n in\n \n# 3002 \"parsing/parser.mly\"\n ( (Ptype_open, priv, oty) )\n# 23709 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3708 \"parsing/parser.mly\"\n ( Public )\n# 23748 \"parsing/parser.ml\"\n in\n let oty =\n let _1 =\n let x = \n# 191 \"\"\n ( x )\n# 23755 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 23760 \"parsing/parser.ml\"\n \n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 23766 \"parsing/parser.ml\"\n \n in\n \n# 3002 \"parsing/parser.mly\"\n ( (Ptype_open, priv, oty) )\n# 23772 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _1 : unit = Obj.magic _1 in\n let _2 : unit = Obj.magic _2 in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3709 \"parsing/parser.mly\"\n ( Private )\n# 23818 \"parsing/parser.ml\"\n in\n let oty =\n let _1 =\n let x = \n# 191 \"\"\n ( x )\n# 23825 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 23830 \"parsing/parser.ml\"\n \n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 23836 \"parsing/parser.ml\"\n \n in\n \n# 3002 \"parsing/parser.mly\"\n ( (Ptype_open, priv, oty) )\n# 23842 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ls;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ls_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ls_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let ls : (Parsetree.label_declaration list) = Obj.magic ls in\n let _3 : unit = Obj.magic _3 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__3_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3708 \"parsing/parser.mly\"\n ( Public )\n# 23881 \"parsing/parser.ml\"\n in\n let oty =\n let _1 = \n# 124 \"\"\n ( None )\n# 23887 \"parsing/parser.ml\"\n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 23892 \"parsing/parser.ml\"\n \n in\n \n# 3006 \"parsing/parser.mly\"\n ( (Ptype_record ls, priv, oty) )\n# 23898 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ls;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ls_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ls_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let ls : (Parsetree.label_declaration list) = Obj.magic ls in\n let _3 : unit = Obj.magic _3 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3709 \"parsing/parser.mly\"\n ( Private )\n# 23944 \"parsing/parser.ml\"\n in\n let oty =\n let _1 = \n# 124 \"\"\n ( None )\n# 23950 \"parsing/parser.ml\"\n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 23955 \"parsing/parser.ml\"\n \n in\n \n# 3006 \"parsing/parser.mly\"\n ( (Ptype_record ls, priv, oty) )\n# 23961 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ls;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ls_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ls_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let ls : (Parsetree.label_declaration list) = Obj.magic ls in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3708 \"parsing/parser.mly\"\n ( Public )\n# 24014 \"parsing/parser.ml\"\n in\n let oty =\n let _1 =\n let x = \n# 191 \"\"\n ( x )\n# 24021 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 24026 \"parsing/parser.ml\"\n \n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 24032 \"parsing/parser.ml\"\n \n in\n \n# 3006 \"parsing/parser.mly\"\n ( (Ptype_record ls, priv, oty) )\n# 24038 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ls;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ls_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ls_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let ls : (Parsetree.label_declaration list) = Obj.magic ls in\n let _3 : unit = Obj.magic _3 in\n let _1 : unit = Obj.magic _1 in\n let _2 : unit = Obj.magic _2 in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = let priv = \n# 3709 \"parsing/parser.mly\"\n ( Private )\n# 24098 \"parsing/parser.ml\"\n in\n let oty =\n let _1 =\n let x = \n# 191 \"\"\n ( x )\n# 24105 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 24110 \"parsing/parser.ml\"\n \n in\n \n# 3010 \"parsing/parser.mly\"\n ( _1 )\n# 24116 \"parsing/parser.ml\"\n \n in\n \n# 3006 \"parsing/parser.mly\"\n ( (Ptype_record ls, priv, oty) )\n# 24122 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = me;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let me : (Parsetree.module_expr) = Obj.magic me in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.open_declaration * string Asttypes.loc option) = let attrs2 =\n let _1 = _1_inlined2 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 24177 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined2_ in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 24186 \"parsing/parser.ml\"\n \n in\n let override = \n# 3755 \"parsing/parser.mly\"\n ( Fresh )\n# 24192 \"parsing/parser.ml\"\n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1559 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Opn.mk me ~override ~attrs ~loc ~docs, ext\n )\n# 24205 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = me;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let me : (Parsetree.module_expr) = Obj.magic me in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.open_declaration * string Asttypes.loc option) = let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 24267 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let attrs1 =\n let _1 = _1_inlined2 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 24276 \"parsing/parser.ml\"\n \n in\n let override = \n# 3756 \"parsing/parser.mly\"\n ( Override )\n# 24282 \"parsing/parser.ml\"\n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1559 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Opn.mk me ~override ~attrs ~loc ~docs, ext\n )\n# 24295 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.open_description * string Asttypes.loc option) = let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 24350 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 24362 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 24370 \"parsing/parser.ml\"\n \n in\n let override = \n# 3755 \"parsing/parser.mly\"\n ( Fresh )\n# 24376 \"parsing/parser.ml\"\n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1574 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Opn.mk id ~override ~attrs ~loc ~docs, ext\n )\n# 24389 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined4_ in\n let _v : (Parsetree.open_description * string Asttypes.loc option) = let attrs2 =\n let _1 = _1_inlined4 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 24451 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined4_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 24463 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined2 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 24471 \"parsing/parser.ml\"\n \n in\n let override = \n# 3756 \"parsing/parser.mly\"\n ( Override )\n# 24477 \"parsing/parser.ml\"\n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1574 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Opn.mk id ~override ~attrs ~loc ~docs, ext\n )\n# 24490 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 729 \"parsing/parser.mly\"\n (string)\n# 24511 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3547 \"parsing/parser.mly\"\n ( _1 )\n# 24519 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 687 \"parsing/parser.mly\"\n (string)\n# 24540 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3548 \"parsing/parser.mly\"\n ( _1 )\n# 24548 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 688 \"parsing/parser.mly\"\n (string)\n# 24569 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3549 \"parsing/parser.mly\"\n ( _1 )\n# 24577 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (string) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 24619 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Asttypes.label) = \n# 3550 \"parsing/parser.mly\"\n ( \".\"^ _1 ^\"(\" ^ _3 ^ \")\" )\n# 24627 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _3 : (string) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 24676 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Asttypes.label) = \n# 3551 \"parsing/parser.mly\"\n ( \".\"^ _1 ^ \"(\" ^ _3 ^ \")<-\" )\n# 24684 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (string) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 24726 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Asttypes.label) = \n# 3552 \"parsing/parser.mly\"\n ( \".\"^ _1 ^\"[\" ^ _3 ^ \"]\" )\n# 24734 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _3 : (string) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 24783 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Asttypes.label) = \n# 3553 \"parsing/parser.mly\"\n ( \".\"^ _1 ^ \"[\" ^ _3 ^ \"]<-\" )\n# 24791 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (string) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 24833 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Asttypes.label) = \n# 3554 \"parsing/parser.mly\"\n ( \".\"^ _1 ^\"{\" ^ _3 ^ \"}\" )\n# 24841 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let _3 : (string) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 24890 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Asttypes.label) = \n# 3555 \"parsing/parser.mly\"\n ( \".\"^ _1 ^ \"{\" ^ _3 ^ \"}<-\" )\n# 24898 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 740 \"parsing/parser.mly\"\n (string)\n# 24919 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3556 \"parsing/parser.mly\"\n ( _1 )\n# 24927 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3557 \"parsing/parser.mly\"\n ( \"!\" )\n# 24952 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = op;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_op_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_op_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let op : (\n# 681 \"parsing/parser.mly\"\n (string)\n# 24973 \"parsing/parser.ml\"\n ) = Obj.magic op in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_op_ in\n let _endpos = _endpos_op_ in\n let _v : (Asttypes.label) = let _1 = \n# 3561 \"parsing/parser.mly\"\n ( op )\n# 24981 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 24986 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = op;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_op_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_op_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let op : (\n# 682 \"parsing/parser.mly\"\n (string)\n# 25007 \"parsing/parser.ml\"\n ) = Obj.magic op in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_op_ in\n let _endpos = _endpos_op_ in\n let _v : (Asttypes.label) = let _1 = \n# 3562 \"parsing/parser.mly\"\n ( op )\n# 25015 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25020 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = op;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_op_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_op_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let op : (\n# 683 \"parsing/parser.mly\"\n (string)\n# 25041 \"parsing/parser.ml\"\n ) = Obj.magic op in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_op_ in\n let _endpos = _endpos_op_ in\n let _v : (Asttypes.label) = let _1 = \n# 3563 \"parsing/parser.mly\"\n ( op )\n# 25049 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25054 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = op;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_op_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_op_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let op : (\n# 684 \"parsing/parser.mly\"\n (string)\n# 25075 \"parsing/parser.ml\"\n ) = Obj.magic op in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_op_ in\n let _endpos = _endpos_op_ in\n let _v : (Asttypes.label) = let _1 = \n# 3564 \"parsing/parser.mly\"\n ( op )\n# 25083 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25088 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = op;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_op_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_op_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let op : (\n# 685 \"parsing/parser.mly\"\n (string)\n# 25109 \"parsing/parser.ml\"\n ) = Obj.magic op in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_op_ in\n let _endpos = _endpos_op_ in\n let _v : (Asttypes.label) = let _1 = \n# 3565 \"parsing/parser.mly\"\n ( op )\n# 25117 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25122 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3566 \"parsing/parser.mly\"\n (\"+\")\n# 25147 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25152 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3567 \"parsing/parser.mly\"\n (\"+.\")\n# 25177 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25182 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3568 \"parsing/parser.mly\"\n (\"+=\")\n# 25207 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25212 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3569 \"parsing/parser.mly\"\n (\"-\")\n# 25237 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25242 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3570 \"parsing/parser.mly\"\n (\"-.\")\n# 25267 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25272 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3571 \"parsing/parser.mly\"\n (\"*\")\n# 25297 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25302 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3572 \"parsing/parser.mly\"\n (\"%\")\n# 25327 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25332 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3573 \"parsing/parser.mly\"\n (\"=\")\n# 25357 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25362 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3574 \"parsing/parser.mly\"\n (\"<\")\n# 25387 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25392 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3575 \"parsing/parser.mly\"\n (\">\")\n# 25417 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25422 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3576 \"parsing/parser.mly\"\n (\"or\")\n# 25447 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25452 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3577 \"parsing/parser.mly\"\n (\"||\")\n# 25477 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25482 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3578 \"parsing/parser.mly\"\n (\"&\")\n# 25507 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25512 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3579 \"parsing/parser.mly\"\n (\"&&\")\n# 25537 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25542 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = let _1 = \n# 3580 \"parsing/parser.mly\"\n (\":=\")\n# 25567 \"parsing/parser.ml\"\n in\n \n# 3558 \"parsing/parser.mly\"\n ( _1 )\n# 25572 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (bool) = \n# 3462 \"parsing/parser.mly\"\n ( true )\n# 25597 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (bool) = \n# 3463 \"parsing/parser.mly\"\n ( false )\n# 25615 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (unit option) = \n# 114 \"\"\n ( None )\n# 25633 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : unit = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (unit option) = \n# 116 \"\"\n ( Some x )\n# 25658 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (unit option) = \n# 114 \"\"\n ( None )\n# 25676 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : unit = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (unit option) = \n# 116 \"\"\n ( Some x )\n# 25701 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (string Asttypes.loc option) = \n# 114 \"\"\n ( None )\n# 25719 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 25746 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (string Asttypes.loc option) = let x =\n let x =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 25761 \"parsing/parser.ml\"\n \n in\n \n# 183 \"\"\n ( x )\n# 25767 \"parsing/parser.ml\"\n \n in\n \n# 116 \"\"\n ( Some x )\n# 25773 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.core_type option) = \n# 114 \"\"\n ( None )\n# 25791 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.core_type option) = let x = \n# 183 \"\"\n ( x )\n# 25823 \"parsing/parser.ml\"\n in\n \n# 116 \"\"\n ( Some x )\n# 25828 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.expression option) = \n# 114 \"\"\n ( None )\n# 25846 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let x : (Parsetree.expression) = Obj.magic x in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.expression option) = let x = \n# 183 \"\"\n ( x )\n# 25878 \"parsing/parser.ml\"\n in\n \n# 116 \"\"\n ( Some x )\n# 25883 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.module_type option) = \n# 114 \"\"\n ( None )\n# 25901 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let x : (Parsetree.module_type) = Obj.magic x in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.module_type option) = let x = \n# 183 \"\"\n ( x )\n# 25933 \"parsing/parser.ml\"\n in\n \n# 116 \"\"\n ( Some x )\n# 25938 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.pattern option) = \n# 114 \"\"\n ( None )\n# 25956 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let x : (Parsetree.pattern) = Obj.magic x in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.pattern option) = let x = \n# 183 \"\"\n ( x )\n# 25988 \"parsing/parser.ml\"\n in\n \n# 116 \"\"\n ( Some x )\n# 25993 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.expression option) = \n# 114 \"\"\n ( None )\n# 26011 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let x : (Parsetree.expression) = Obj.magic x in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.expression option) = let x = \n# 183 \"\"\n ( x )\n# 26043 \"parsing/parser.ml\"\n in\n \n# 116 \"\"\n ( Some x )\n# 26048 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : ((Parsetree.core_type option * Parsetree.core_type option) option) = \n# 114 \"\"\n ( None )\n# 26066 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : ((Parsetree.core_type option * Parsetree.core_type option) option) = \n# 116 \"\"\n ( Some x )\n# 26091 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 722 \"parsing/parser.mly\"\n (string)\n# 26112 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3767 \"parsing/parser.mly\"\n ( _1 )\n# 26120 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 26154 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (string) = \n# 3768 \"parsing/parser.mly\"\n ( _2 )\n# 26163 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = mty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_mty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_mty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = me;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let mty : (Parsetree.module_type) = Obj.magic mty in\n let _3 : unit = Obj.magic _3 in\n let me : (Parsetree.module_expr) = Obj.magic me in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.module_expr) = let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1338 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc (Pmod_constraint(me, mty)) )\n# 26219 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.module_type) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.module_expr) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.module_expr) = let _loc__5_ = (_startpos__5_, _endpos__5_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1340 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__5_ )\n# 26274 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = me;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_me_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_me_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let me : (Parsetree.module_expr) = Obj.magic me in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.module_expr) = \n# 1343 \"parsing/parser.mly\"\n ( me (* TODO consider reloc *) )\n# 26313 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.module_expr) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.module_expr) = let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1345 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__3_ )\n# 26354 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let e : (Parsetree.expression) = Obj.magic e in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.module_expr) = let e = \n# 1362 \"parsing/parser.mly\"\n ( e )\n# 26407 \"parsing/parser.ml\"\n in\n let attrs =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 26414 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1349 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) )\n# 26423 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (Parsetree.module_type) = Obj.magic _1_inlined2 in\n let _2_inlined1 : unit = Obj.magic _2_inlined1 in\n let e : (Parsetree.expression) = Obj.magic e in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.module_expr) = let e =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let ty =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3437 \"parsing/parser.mly\"\n ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in\n let descr = Ptyp_package (lid, cstrs) in\n mktyp ~loc:_sloc ~attrs descr )\n# 26498 \"parsing/parser.ml\"\n \n in\n let _endpos_ty_ = _endpos__1_ in\n let _endpos = _endpos_ty_ in\n let _startpos = _startpos_e_ in\n let _loc = (_startpos, _endpos) in\n \n# 1364 \"parsing/parser.mly\"\n ( ghexp ~loc:_loc (Pexp_constraint (e, ty)) )\n# 26508 \"parsing/parser.ml\"\n \n in\n let attrs =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 26516 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1349 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) )\n# 26525 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined3 : (Parsetree.module_type) = Obj.magic _1_inlined3 in\n let _4 : unit = Obj.magic _4 in\n let _1_inlined2 : (Parsetree.module_type) = Obj.magic _1_inlined2 in\n let _2_inlined1 : unit = Obj.magic _2_inlined1 in\n let e : (Parsetree.expression) = Obj.magic e in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.module_expr) = let e =\n let (_endpos__1_inlined1_, _startpos__1_inlined1_, _endpos__1_, _startpos__1_, _1_inlined1, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined3, _1_inlined2) in\n let ty2 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3437 \"parsing/parser.mly\"\n ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in\n let descr = Ptyp_package (lid, cstrs) in\n mktyp ~loc:_sloc ~attrs descr )\n# 26615 \"parsing/parser.ml\"\n \n in\n let _endpos_ty2_ = _endpos__1_inlined1_ in\n let ty1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3437 \"parsing/parser.mly\"\n ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in\n let descr = Ptyp_package (lid, cstrs) in\n mktyp ~loc:_sloc ~attrs descr )\n# 26628 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_ty2_ in\n let _startpos = _startpos_e_ in\n let _loc = (_startpos, _endpos) in\n \n# 1366 \"parsing/parser.mly\"\n ( ghexp ~loc:_loc (Pexp_coerce (e, Some ty1, ty2)) )\n# 26637 \"parsing/parser.ml\"\n \n in\n let attrs =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 26645 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1349 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) )\n# 26654 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (Parsetree.module_type) = Obj.magic _1_inlined2 in\n let _2_inlined1 : unit = Obj.magic _2_inlined1 in\n let e : (Parsetree.expression) = Obj.magic e in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.module_expr) = let e =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let ty2 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3437 \"parsing/parser.mly\"\n ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in\n let descr = Ptyp_package (lid, cstrs) in\n mktyp ~loc:_sloc ~attrs descr )\n# 26729 \"parsing/parser.ml\"\n \n in\n let _endpos_ty2_ = _endpos__1_ in\n let _endpos = _endpos_ty2_ in\n let _startpos = _startpos_e_ in\n let _loc = (_startpos, _endpos) in\n \n# 1368 \"parsing/parser.mly\"\n ( ghexp ~loc:_loc (Pexp_coerce (e, None, ty2)) )\n# 26739 \"parsing/parser.ml\"\n \n in\n let attrs =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 26747 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1349 \"parsing/parser.mly\"\n ( mkmod ~loc:_sloc ~attrs (Pmod_unpack e) )\n# 26756 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _6 : unit = Obj.magic _6 in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__6_ in\n let _v : (Parsetree.module_expr) = let _3 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 26818 \"parsing/parser.ml\"\n \n in\n let _loc__6_ = (_startpos__6_, _endpos__6_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1351 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__6_ )\n# 26826 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _6 : unit = Obj.magic _6 in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__6_ in\n let _v : (Parsetree.module_expr) = let _3 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 26888 \"parsing/parser.ml\"\n \n in\n let _loc__6_ = (_startpos__6_, _endpos__6_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1353 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__6_ )\n# 26896 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.module_expr) = let _3 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 26951 \"parsing/parser.ml\"\n \n in\n let _loc__5_ = (_startpos__5_, _endpos__5_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1355 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__5_ )\n# 26959 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Longident.t) = \n# 1257 \"parsing/parser.mly\"\n ( _1 )\n# 26991 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Longident.t) = \n# 1242 \"parsing/parser.mly\"\n ( _1 )\n# 27023 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.core_type) = \n# 1217 \"parsing/parser.mly\"\n ( _1 )\n# 27055 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = \n# 1222 \"parsing/parser.mly\"\n ( _1 )\n# 27087 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Longident.t) = \n# 1247 \"parsing/parser.mly\"\n ( _1 )\n# 27119 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Longident.t) = \n# 1252 \"parsing/parser.mly\"\n ( _1 )\n# 27151 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.module_expr) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.module_expr) = \n# 1212 \"parsing/parser.mly\"\n ( _1 )\n# 27183 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.module_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.module_type) = \n# 1207 \"parsing/parser.mly\"\n ( _1 )\n# 27215 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Longident.t) = \n# 1232 \"parsing/parser.mly\"\n ( _1 )\n# 27247 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.pattern) = \n# 1227 \"parsing/parser.mly\"\n ( _1 )\n# 27279 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Longident.t) = \n# 1237 \"parsing/parser.mly\"\n ( _1 )\n# 27311 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _loc__2_ = (_startpos__2_, _endpos__2_) in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2723 \"parsing/parser.mly\"\n ( mkpat_cons ~loc:_sloc _loc__2_ (ghpat ~loc:_sloc (Ppat_tuple[_1;_3])) )\n# 27355 \"parsing/parser.ml\"\n \n in\n \n# 2711 \"parsing/parser.mly\"\n ( _1 )\n# 27361 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.attribute) = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.pattern) = let _1 = \n# 2725 \"parsing/parser.mly\"\n ( Pat.attr _1 _2 )\n# 27393 \"parsing/parser.ml\"\n in\n \n# 2711 \"parsing/parser.mly\"\n ( _1 )\n# 27398 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 = \n# 2727 \"parsing/parser.mly\"\n ( _1 )\n# 27423 \"parsing/parser.ml\"\n in\n \n# 2711 \"parsing/parser.mly\"\n ( _1 )\n# 27428 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _3 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 27475 \"parsing/parser.ml\"\n \n in\n \n# 2730 \"parsing/parser.mly\"\n ( Ppat_alias(_1, _3) )\n# 27481 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 27491 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 27497 \"parsing/parser.ml\"\n \n in\n \n# 2711 \"parsing/parser.mly\"\n ( _1 )\n# 27503 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2732 \"parsing/parser.mly\"\n ( expecting _loc__3_ \"identifier\" )\n# 27546 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 27556 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 27562 \"parsing/parser.ml\"\n \n in\n \n# 2711 \"parsing/parser.mly\"\n ( _1 )\n# 27568 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.pattern list) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 = \n# 2734 \"parsing/parser.mly\"\n ( Ppat_tuple(List.rev _1) )\n# 27595 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 27603 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 27609 \"parsing/parser.ml\"\n \n in\n \n# 2711 \"parsing/parser.mly\"\n ( _1 )\n# 27615 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2736 \"parsing/parser.mly\"\n ( expecting _loc__3_ \"pattern\" )\n# 27658 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 27668 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 27674 \"parsing/parser.ml\"\n \n in\n \n# 2711 \"parsing/parser.mly\"\n ( _1 )\n# 27680 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 = \n# 2738 \"parsing/parser.mly\"\n ( Ppat_or(_1, _3) )\n# 27721 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 27730 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 27736 \"parsing/parser.ml\"\n \n in\n \n# 2711 \"parsing/parser.mly\"\n ( _1 )\n# 27742 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2740 \"parsing/parser.mly\"\n ( expecting _loc__3_ \"pattern\" )\n# 27785 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 27795 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 27801 \"parsing/parser.ml\"\n \n in\n \n# 2711 \"parsing/parser.mly\"\n ( _1 )\n# 27807 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 27857 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 27863 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2713 \"parsing/parser.mly\"\n ( mkpat_attrs ~loc:_sloc (Ppat_exception _3) _2)\n# 27872 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern list) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern list) = \n# 2840 \"parsing/parser.mly\"\n ( _3 :: _1 )\n# 27911 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern list) = \n# 2841 \"parsing/parser.mly\"\n ( [_3; _1] )\n# 27950 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern list) = let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2842 \"parsing/parser.mly\"\n ( expecting _loc__3_ \"pattern\" )\n# 27990 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern list) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern list) = \n# 2840 \"parsing/parser.mly\"\n ( _3 :: _1 )\n# 28029 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern list) = \n# 2841 \"parsing/parser.mly\"\n ( [_3; _1] )\n# 28068 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern list) = let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2842 \"parsing/parser.mly\"\n ( expecting _loc__3_ \"pattern\" )\n# 28108 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = \n# 2746 \"parsing/parser.mly\"\n ( _1 )\n# 28133 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 28171 \"parsing/parser.ml\"\n \n in\n \n# 2749 \"parsing/parser.mly\"\n ( Ppat_construct(_1, Some ([], _2)) )\n# 28177 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 28187 \"parsing/parser.ml\"\n \n in\n \n# 2755 \"parsing/parser.mly\"\n ( _1 )\n# 28193 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = pat;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_pat_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_pat_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let pat : (Parsetree.pattern) = Obj.magic pat in\n let _5 : unit = Obj.magic _5 in\n let xs : (string Asttypes.loc list) = Obj.magic xs in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_pat_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let newtypes = \n# 2495 \"parsing/parser.mly\"\n ( xs )\n# 28255 \"parsing/parser.ml\"\n in\n let constr =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 28264 \"parsing/parser.ml\"\n \n in\n \n# 2752 \"parsing/parser.mly\"\n ( Ppat_construct(constr, Some (newtypes, pat)) )\n# 28270 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_pat_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 28280 \"parsing/parser.ml\"\n \n in\n \n# 2755 \"parsing/parser.mly\"\n ( _1 )\n# 28286 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 = \n# 2754 \"parsing/parser.mly\"\n ( Ppat_variant(_1, Some _2) )\n# 28319 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 28328 \"parsing/parser.ml\"\n \n in\n \n# 2755 \"parsing/parser.mly\"\n ( _1 )\n# 28334 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 28384 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 28390 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2757 \"parsing/parser.mly\"\n ( mkpat_attrs ~loc:_sloc (Ppat_lazy _3) _2)\n# 28399 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _loc__2_ = (_startpos__2_, _endpos__2_) in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2723 \"parsing/parser.mly\"\n ( mkpat_cons ~loc:_sloc _loc__2_ (ghpat ~loc:_sloc (Ppat_tuple[_1;_3])) )\n# 28443 \"parsing/parser.ml\"\n \n in\n \n# 2718 \"parsing/parser.mly\"\n ( _1 )\n# 28449 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.attribute) = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.pattern) = let _1 = \n# 2725 \"parsing/parser.mly\"\n ( Pat.attr _1 _2 )\n# 28481 \"parsing/parser.ml\"\n in\n \n# 2718 \"parsing/parser.mly\"\n ( _1 )\n# 28486 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 = \n# 2727 \"parsing/parser.mly\"\n ( _1 )\n# 28511 \"parsing/parser.ml\"\n in\n \n# 2718 \"parsing/parser.mly\"\n ( _1 )\n# 28516 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _3 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 28563 \"parsing/parser.ml\"\n \n in\n \n# 2730 \"parsing/parser.mly\"\n ( Ppat_alias(_1, _3) )\n# 28569 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 28579 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 28585 \"parsing/parser.ml\"\n \n in\n \n# 2718 \"parsing/parser.mly\"\n ( _1 )\n# 28591 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2732 \"parsing/parser.mly\"\n ( expecting _loc__3_ \"identifier\" )\n# 28634 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 28644 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 28650 \"parsing/parser.ml\"\n \n in\n \n# 2718 \"parsing/parser.mly\"\n ( _1 )\n# 28656 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.pattern list) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 = \n# 2734 \"parsing/parser.mly\"\n ( Ppat_tuple(List.rev _1) )\n# 28683 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 28691 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 28697 \"parsing/parser.ml\"\n \n in\n \n# 2718 \"parsing/parser.mly\"\n ( _1 )\n# 28703 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2736 \"parsing/parser.mly\"\n ( expecting _loc__3_ \"pattern\" )\n# 28746 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 28756 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 28762 \"parsing/parser.ml\"\n \n in\n \n# 2718 \"parsing/parser.mly\"\n ( _1 )\n# 28768 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 = \n# 2738 \"parsing/parser.mly\"\n ( Ppat_or(_1, _3) )\n# 28809 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 28818 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 28824 \"parsing/parser.ml\"\n \n in\n \n# 2718 \"parsing/parser.mly\"\n ( _1 )\n# 28830 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2740 \"parsing/parser.mly\"\n ( expecting _loc__3_ \"pattern\" )\n# 28873 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 28883 \"parsing/parser.ml\"\n \n in\n \n# 2741 \"parsing/parser.mly\"\n ( _1 )\n# 28889 \"parsing/parser.ml\"\n \n in\n \n# 2718 \"parsing/parser.mly\"\n ( _1 )\n# 28895 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 28916 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 28930 \"parsing/parser.ml\"\n \n in\n \n# 2214 \"parsing/parser.mly\"\n ( Ppat_var _1 )\n# 28936 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 28945 \"parsing/parser.ml\"\n \n in\n \n# 2216 \"parsing/parser.mly\"\n ( _1 )\n# 28951 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 = \n# 2215 \"parsing/parser.mly\"\n ( Ppat_any )\n# 28977 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 28985 \"parsing/parser.ml\"\n \n in\n \n# 2216 \"parsing/parser.mly\"\n ( _1 )\n# 28991 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.structure) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.payload) = \n# 3879 \"parsing/parser.mly\"\n ( PStr _1 )\n# 29016 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.signature) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.payload) = \n# 3880 \"parsing/parser.mly\"\n ( PSig _2 )\n# 29048 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.core_type) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.payload) = \n# 3881 \"parsing/parser.mly\"\n ( PTyp _2 )\n# 29080 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.payload) = \n# 3882 \"parsing/parser.mly\"\n ( PPat (_2, None) )\n# 29112 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.payload) = \n# 3883 \"parsing/parser.mly\"\n ( PPat (_2, Some _4) )\n# 29158 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = \n# 3276 \"parsing/parser.mly\"\n ( _1 )\n# 29183 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.core_type) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let xs : (Asttypes.label Asttypes.loc list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 29226 \"parsing/parser.ml\"\n in\n \n# 989 \"parsing/parser.mly\"\n ( xs )\n# 29231 \"parsing/parser.ml\"\n \n in\n \n# 3268 \"parsing/parser.mly\"\n ( _1 )\n# 29237 \"parsing/parser.ml\"\n \n in\n \n# 3272 \"parsing/parser.mly\"\n ( Ptyp_poly(_1, _3) )\n# 29243 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos__3_, _startpos_xs_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 29253 \"parsing/parser.ml\"\n \n in\n \n# 3278 \"parsing/parser.mly\"\n ( _1 )\n# 29259 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = let _1 = \n# 3307 \"parsing/parser.mly\"\n ( _1 )\n# 29284 \"parsing/parser.ml\"\n in\n \n# 3276 \"parsing/parser.mly\"\n ( _1 )\n# 29289 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _2 : unit = Obj.magic _2 in\n let xs : (Asttypes.label Asttypes.loc list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let _3 = \n# 3307 \"parsing/parser.mly\"\n ( _1 )\n# 29330 \"parsing/parser.ml\"\n in\n let _1 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 29337 \"parsing/parser.ml\"\n in\n \n# 989 \"parsing/parser.mly\"\n ( xs )\n# 29342 \"parsing/parser.ml\"\n \n in\n \n# 3268 \"parsing/parser.mly\"\n ( _1 )\n# 29348 \"parsing/parser.ml\"\n \n in\n \n# 3272 \"parsing/parser.mly\"\n ( Ptyp_poly(_1, _3) )\n# 29354 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos_xs_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 29364 \"parsing/parser.ml\"\n \n in\n \n# 3278 \"parsing/parser.mly\"\n ( _1 )\n# 29370 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.payload) = Obj.magic _3 in\n let _2 : (string Asttypes.loc) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.attribute) = let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3840 \"parsing/parser.mly\"\n ( Attr.mk ~loc:(make_loc _sloc) _2 _3 )\n# 29419 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = prim;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_prim_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_prim_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let prim : (string list) = Obj.magic prim in\n let _7 : unit = Obj.magic _7 in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.value_description * string Asttypes.loc option) = let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 29502 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 29514 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 29522 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2904 \"parsing/parser.mly\"\n ( let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Val.mk id ty ~prim ~attrs ~loc ~docs,\n ext )\n# 29535 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Asttypes.private_flag) = let _1 = \n# 3708 \"parsing/parser.mly\"\n ( Public )\n# 29553 \"parsing/parser.ml\"\n in\n \n# 3705 \"parsing/parser.mly\"\n ( _1 )\n# 29558 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.private_flag) = let _1 = \n# 3709 \"parsing/parser.mly\"\n ( Private )\n# 29583 \"parsing/parser.ml\"\n in\n \n# 3705 \"parsing/parser.mly\"\n ( _1 )\n# 29588 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = \n# 3731 \"parsing/parser.mly\"\n ( Public, Concrete )\n# 29606 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = \n# 3732 \"parsing/parser.mly\"\n ( Private, Concrete )\n# 29631 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = \n# 3733 \"parsing/parser.mly\"\n ( Public, Virtual )\n# 29656 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = \n# 3734 \"parsing/parser.mly\"\n ( Private, Virtual )\n# 29688 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.private_flag * Asttypes.virtual_flag) = \n# 3735 \"parsing/parser.mly\"\n ( Private, Virtual )\n# 29720 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Asttypes.rec_flag) = \n# 3686 \"parsing/parser.mly\"\n ( Nonrecursive )\n# 29738 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.rec_flag) = \n# 3687 \"parsing/parser.mly\"\n ( Recursive )\n# 29763 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = fields;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_fields_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_fields_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let fields : ((Longident.t Asttypes.loc * Parsetree.expression) list) = Obj.magic fields in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_fields_ in\n let _endpos = _endpos_fields_ in\n let _v : (Parsetree.expression option *\n (Longident.t Asttypes.loc * Parsetree.expression) list) = let eo = \n# 124 \"\"\n ( None )\n# 29789 \"parsing/parser.ml\"\n in\n \n# 2643 \"parsing/parser.mly\"\n ( eo, fields )\n# 29794 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = fields;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_fields_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_fields_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let fields : ((Longident.t Asttypes.loc * Parsetree.expression) list) = Obj.magic fields in\n let _2 : unit = Obj.magic _2 in\n let x : (Parsetree.expression) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_fields_ in\n let _v : (Parsetree.expression option *\n (Longident.t Asttypes.loc * Parsetree.expression) list) = let eo =\n let x = \n# 191 \"\"\n ( x )\n# 29835 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 29840 \"parsing/parser.ml\"\n \n in\n \n# 2643 \"parsing/parser.mly\"\n ( eo, fields )\n# 29846 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let d : (Ast_helper.str * Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option * Parsetree.attributes * Location.t *\n Docstrings.info) = Obj.magic d in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_d_ in\n let _endpos = _endpos_d_ in\n let _v : (Parsetree.constructor_declaration list) = let x = \n# 3089 \"parsing/parser.mly\"\n (\n let cid, vars, args, res, attrs, loc, info = d in\n Type.constructor cid ~vars ~args ?res ~attrs ~loc ~info\n )\n# 29876 \"parsing/parser.ml\"\n in\n \n# 1099 \"parsing/parser.mly\"\n ( [x] )\n# 29881 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let d : (Ast_helper.str * Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option * Parsetree.attributes * Location.t *\n Docstrings.info) = Obj.magic d in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_d_ in\n let _endpos = _endpos_d_ in\n let _v : (Parsetree.constructor_declaration list) = let x = \n# 3089 \"parsing/parser.mly\"\n (\n let cid, vars, args, res, attrs, loc, info = d in\n Type.constructor cid ~vars ~args ?res ~attrs ~loc ~info\n )\n# 29911 \"parsing/parser.ml\"\n in\n \n# 1102 \"parsing/parser.mly\"\n ( [x] )\n# 29916 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let d : (Ast_helper.str * Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option * Parsetree.attributes * Location.t *\n Docstrings.info) = Obj.magic d in\n let xs : (Parsetree.constructor_declaration list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_d_ in\n let _v : (Parsetree.constructor_declaration list) = let x = \n# 3089 \"parsing/parser.mly\"\n (\n let cid, vars, args, res, attrs, loc, info = d in\n Type.constructor cid ~vars ~args ?res ~attrs ~loc ~info\n )\n# 29953 \"parsing/parser.ml\"\n in\n \n# 1106 \"parsing/parser.mly\"\n ( x :: xs )\n# 29958 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let d : (Ast_helper.str * Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option * Parsetree.attributes * Location.t *\n Docstrings.info) = Obj.magic d in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_d_ in\n let _endpos = _endpos_d_ in\n let _v : (Parsetree.extension_constructor list) = let x =\n let _1 = \n# 3206 \"parsing/parser.mly\"\n (\n let cid, vars, args, res, attrs, loc, info = d in\n Te.decl cid ~vars ~args ?res ~attrs ~loc ~info\n )\n# 29989 \"parsing/parser.ml\"\n in\n \n# 3200 \"parsing/parser.mly\"\n ( _1 )\n# 29994 \"parsing/parser.ml\"\n \n in\n \n# 1099 \"parsing/parser.mly\"\n ( [x] )\n# 30000 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.extension_constructor) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.extension_constructor list) = let x = \n# 3202 \"parsing/parser.mly\"\n ( _1 )\n# 30025 \"parsing/parser.ml\"\n in\n \n# 1099 \"parsing/parser.mly\"\n ( [x] )\n# 30030 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let d : (Ast_helper.str * Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option * Parsetree.attributes * Location.t *\n Docstrings.info) = Obj.magic d in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_d_ in\n let _endpos = _endpos_d_ in\n let _v : (Parsetree.extension_constructor list) = let x =\n let _1 = \n# 3206 \"parsing/parser.mly\"\n (\n let cid, vars, args, res, attrs, loc, info = d in\n Te.decl cid ~vars ~args ?res ~attrs ~loc ~info\n )\n# 30061 \"parsing/parser.ml\"\n in\n \n# 3200 \"parsing/parser.mly\"\n ( _1 )\n# 30066 \"parsing/parser.ml\"\n \n in\n \n# 1102 \"parsing/parser.mly\"\n ( [x] )\n# 30072 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.extension_constructor) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.extension_constructor list) = let x = \n# 3202 \"parsing/parser.mly\"\n ( _1 )\n# 30097 \"parsing/parser.ml\"\n in\n \n# 1102 \"parsing/parser.mly\"\n ( [x] )\n# 30102 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let d : (Ast_helper.str * Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option * Parsetree.attributes * Location.t *\n Docstrings.info) = Obj.magic d in\n let xs : (Parsetree.extension_constructor list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_d_ in\n let _v : (Parsetree.extension_constructor list) = let x =\n let _1 = \n# 3206 \"parsing/parser.mly\"\n (\n let cid, vars, args, res, attrs, loc, info = d in\n Te.decl cid ~vars ~args ?res ~attrs ~loc ~info\n )\n# 30140 \"parsing/parser.ml\"\n in\n \n# 3200 \"parsing/parser.mly\"\n ( _1 )\n# 30145 \"parsing/parser.ml\"\n \n in\n \n# 1106 \"parsing/parser.mly\"\n ( x :: xs )\n# 30151 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1 : (Parsetree.extension_constructor) = Obj.magic _1 in\n let xs : (Parsetree.extension_constructor list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.extension_constructor list) = let x = \n# 3202 \"parsing/parser.mly\"\n ( _1 )\n# 30183 \"parsing/parser.ml\"\n in\n \n# 1106 \"parsing/parser.mly\"\n ( x :: xs )\n# 30188 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let d : (Ast_helper.str * Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option * Parsetree.attributes * Location.t *\n Docstrings.info) = Obj.magic d in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_d_ in\n let _endpos = _endpos_d_ in\n let _v : (Parsetree.extension_constructor list) = let x = \n# 3206 \"parsing/parser.mly\"\n (\n let cid, vars, args, res, attrs, loc, info = d in\n Te.decl cid ~vars ~args ?res ~attrs ~loc ~info\n )\n# 30218 \"parsing/parser.ml\"\n in\n \n# 1099 \"parsing/parser.mly\"\n ( [x] )\n# 30223 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let d : (Ast_helper.str * Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option * Parsetree.attributes * Location.t *\n Docstrings.info) = Obj.magic d in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_d_ in\n let _endpos = _endpos_d_ in\n let _v : (Parsetree.extension_constructor list) = let x = \n# 3206 \"parsing/parser.mly\"\n (\n let cid, vars, args, res, attrs, loc, info = d in\n Te.decl cid ~vars ~args ?res ~attrs ~loc ~info\n )\n# 30253 \"parsing/parser.ml\"\n in\n \n# 1102 \"parsing/parser.mly\"\n ( [x] )\n# 30258 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let d : (Ast_helper.str * Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option * Parsetree.attributes * Location.t *\n Docstrings.info) = Obj.magic d in\n let xs : (Parsetree.extension_constructor list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_d_ in\n let _v : (Parsetree.extension_constructor list) = let x = \n# 3206 \"parsing/parser.mly\"\n (\n let cid, vars, args, res, attrs, loc, info = d in\n Te.decl cid ~vars ~args ?res ~attrs ~loc ~info\n )\n# 30295 \"parsing/parser.ml\"\n in\n \n# 1106 \"parsing/parser.mly\"\n ( x :: xs )\n# 30300 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = \n# 965 \"parsing/parser.mly\"\n ( [] )\n# 30318 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.core_type) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1_inlined1 : (Parsetree.core_type) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let xs : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos__3_ in\n let _v : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = let x =\n let x =\n let (_startpos__1_, _1) = (_startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2094 \"parsing/parser.mly\"\n ( _1, _3, make_loc _sloc )\n# 30377 \"parsing/parser.ml\"\n \n in\n \n# 183 \"\"\n ( x )\n# 30383 \"parsing/parser.ml\"\n \n in\n \n# 967 \"parsing/parser.mly\"\n ( x :: xs )\n# 30389 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Lexing.position * Parsetree.functor_parameter) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : ((Lexing.position * Parsetree.functor_parameter) list) = \n# 979 \"parsing/parser.mly\"\n ( [ x ] )\n# 30414 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let x : (Lexing.position * Parsetree.functor_parameter) = Obj.magic x in\n let xs : ((Lexing.position * Parsetree.functor_parameter) list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : ((Lexing.position * Parsetree.functor_parameter) list) = \n# 981 \"parsing/parser.mly\"\n ( x :: xs )\n# 30446 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Asttypes.arg_label * Parsetree.expression) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : ((Asttypes.arg_label * Parsetree.expression) list) = \n# 979 \"parsing/parser.mly\"\n ( [ x ] )\n# 30471 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let x : (Asttypes.arg_label * Parsetree.expression) = Obj.magic x in\n let xs : ((Asttypes.arg_label * Parsetree.expression) list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : ((Asttypes.arg_label * Parsetree.expression) list) = \n# 981 \"parsing/parser.mly\"\n ( x :: xs )\n# 30503 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Asttypes.label) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (Asttypes.label list) = \n# 979 \"parsing/parser.mly\"\n ( [ x ] )\n# 30528 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let x : (Asttypes.label) = Obj.magic x in\n let xs : (Asttypes.label list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : (Asttypes.label list) = \n# 981 \"parsing/parser.mly\"\n ( x :: xs )\n# 30560 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Asttypes.label Asttypes.loc list) = let x =\n let _2 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 30598 \"parsing/parser.ml\"\n \n in\n \n# 3264 \"parsing/parser.mly\"\n ( _2 )\n# 30604 \"parsing/parser.ml\"\n \n in\n \n# 979 \"parsing/parser.mly\"\n ( [ x ] )\n# 30610 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let xs : (Asttypes.label Asttypes.loc list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Asttypes.label Asttypes.loc list) = let x =\n let _2 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 30655 \"parsing/parser.ml\"\n \n in\n \n# 3264 \"parsing/parser.mly\"\n ( _2 )\n# 30661 \"parsing/parser.ml\"\n \n in\n \n# 981 \"parsing/parser.mly\"\n ( x :: xs )\n# 30667 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Parsetree.case) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.case list) = let _1 = \n# 124 \"\"\n ( None )\n# 30692 \"parsing/parser.ml\"\n in\n \n# 1070 \"parsing/parser.mly\"\n ( [x] )\n# 30697 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let x : (Parsetree.case) = Obj.magic x in\n let x_inlined1 : unit = Obj.magic x_inlined1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_inlined1_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.case list) = let _1 =\n let x = x_inlined1 in\n \n# 126 \"\"\n ( Some x )\n# 30731 \"parsing/parser.ml\"\n \n in\n \n# 1070 \"parsing/parser.mly\"\n ( [x] )\n# 30737 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x : (Parsetree.case) = Obj.magic x in\n let _2 : unit = Obj.magic _2 in\n let xs : (Parsetree.case list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.case list) = \n# 1074 \"parsing/parser.mly\"\n ( x :: xs )\n# 30776 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type list) = let xs =\n let x = \n# 3307 \"parsing/parser.mly\"\n ( _1 )\n# 30802 \"parsing/parser.ml\"\n in\n \n# 1005 \"parsing/parser.mly\"\n ( [ x ] )\n# 30807 \"parsing/parser.ml\"\n \n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 30813 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _2 : unit = Obj.magic _2 in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type list) = let xs =\n let x = \n# 3307 \"parsing/parser.mly\"\n ( _1 )\n# 30853 \"parsing/parser.ml\"\n in\n \n# 1009 \"parsing/parser.mly\"\n ( x :: xs )\n# 30858 \"parsing/parser.ml\"\n \n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 30864 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Parsetree.with_constraint) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.with_constraint list) = let xs = \n# 1005 \"parsing/parser.mly\"\n ( [ x ] )\n# 30889 \"parsing/parser.ml\"\n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 30894 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x : (Parsetree.with_constraint) = Obj.magic x in\n let _2 : unit = Obj.magic _2 in\n let xs : (Parsetree.with_constraint list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.with_constraint list) = let xs = \n# 1009 \"parsing/parser.mly\"\n ( x :: xs )\n# 30933 \"parsing/parser.ml\"\n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 30938 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Parsetree.row_field) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.row_field list) = let xs = \n# 1005 \"parsing/parser.mly\"\n ( [ x ] )\n# 30963 \"parsing/parser.ml\"\n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 30968 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x : (Parsetree.row_field) = Obj.magic x in\n let _2 : unit = Obj.magic _2 in\n let xs : (Parsetree.row_field list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.row_field list) = let xs = \n# 1009 \"parsing/parser.mly\"\n ( x :: xs )\n# 31007 \"parsing/parser.ml\"\n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 31012 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.core_type list) = let xs = \n# 1005 \"parsing/parser.mly\"\n ( [ x ] )\n# 31037 \"parsing/parser.ml\"\n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 31042 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _2 : unit = Obj.magic _2 in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.core_type list) = let xs = \n# 1009 \"parsing/parser.mly\"\n ( x :: xs )\n# 31081 \"parsing/parser.ml\"\n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 31086 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = let xs = \n# 1005 \"parsing/parser.mly\"\n ( [ x ] )\n# 31111 \"parsing/parser.ml\"\n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 31116 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x : (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) = Obj.magic x in\n let _2 : unit = Obj.magic _2 in\n let xs : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = let xs = \n# 1009 \"parsing/parser.mly\"\n ( x :: xs )\n# 31155 \"parsing/parser.ml\"\n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 31160 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.core_type list) = let xs = \n# 1005 \"parsing/parser.mly\"\n ( [ x ] )\n# 31185 \"parsing/parser.ml\"\n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 31190 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _2 : unit = Obj.magic _2 in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.core_type list) = let xs = \n# 1009 \"parsing/parser.mly\"\n ( x :: xs )\n# 31229 \"parsing/parser.ml\"\n in\n \n# 1013 \"parsing/parser.mly\"\n ( xs )\n# 31234 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _2 : unit = Obj.magic _2 in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.core_type list) = \n# 1036 \"parsing/parser.mly\"\n ( x :: xs )\n# 31273 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x2 : (Parsetree.core_type) = Obj.magic x2 in\n let _2 : unit = Obj.magic _2 in\n let x1 : (Parsetree.core_type) = Obj.magic x1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x1_ in\n let _endpos = _endpos_x2_ in\n let _v : (Parsetree.core_type list) = \n# 1040 \"parsing/parser.mly\"\n ( [ x2; x1 ] )\n# 31312 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x : (Parsetree.expression) = Obj.magic x in\n let _2 : unit = Obj.magic _2 in\n let xs : (Parsetree.expression list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.expression list) = \n# 1036 \"parsing/parser.mly\"\n ( x :: xs )\n# 31351 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x2 : (Parsetree.expression) = Obj.magic x2 in\n let _2 : unit = Obj.magic _2 in\n let x1 : (Parsetree.expression) = Obj.magic x1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x1_ in\n let _endpos = _endpos_x2_ in\n let _v : (Parsetree.expression list) = \n# 1040 \"parsing/parser.mly\"\n ( [ x2; x1 ] )\n# 31390 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x : (Parsetree.core_type) = Obj.magic x in\n let _2 : unit = Obj.magic _2 in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.core_type list) = \n# 1036 \"parsing/parser.mly\"\n ( x :: xs )\n# 31429 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x2 : (Parsetree.core_type) = Obj.magic x2 in\n let _2 : unit = Obj.magic _2 in\n let x1 : (Parsetree.core_type) = Obj.magic x1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x1_ in\n let _endpos = _endpos_x2_ in\n let _v : (Parsetree.core_type list) = \n# 1040 \"parsing/parser.mly\"\n ( [ x2; x1 ] )\n# 31468 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.row_field) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.row_field) = \n# 3447 \"parsing/parser.mly\"\n ( _1 )\n# 31493 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.core_type) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.row_field) = let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3449 \"parsing/parser.mly\"\n ( Rf.inherit_ ~loc:(make_loc _sloc) _1 )\n# 31521 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Parsetree.expression) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.expression list) = let _2 = \n# 124 \"\"\n ( None )\n# 31546 \"parsing/parser.ml\"\n in\n \n# 1057 \"parsing/parser.mly\"\n ( [x] )\n# 31551 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let x_inlined1 : unit = Obj.magic x_inlined1 in\n let x : (Parsetree.expression) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_inlined1_ in\n let _v : (Parsetree.expression list) = let _2 =\n let x = x_inlined1 in\n \n# 126 \"\"\n ( Some x )\n# 31585 \"parsing/parser.ml\"\n \n in\n \n# 1057 \"parsing/parser.mly\"\n ( [x] )\n# 31591 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.expression list) = Obj.magic xs in\n let _2 : unit = Obj.magic _2 in\n let x : (Parsetree.expression) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.expression list) = \n# 1061 \"parsing/parser.mly\"\n ( x :: xs )\n# 31630 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = oe;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_oe_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_oe_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let oe : (Parsetree.expression option) = Obj.magic oe in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 31658 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_oe_ in\n let _v : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = let _2 = \n# 124 \"\"\n ( None )\n# 31666 \"parsing/parser.ml\"\n in\n let x =\n let label =\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 31673 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 31681 \"parsing/parser.ml\"\n \n in\n \n# 2666 \"parsing/parser.mly\"\n ( let label, e =\n match oe with\n | None ->\n (* No expression; this is a pun. Desugar it. *)\n make_ghost label, exp_of_label label\n | Some e ->\n label, e\n in\n label, e )\n# 31695 \"parsing/parser.ml\"\n \n in\n \n# 1057 \"parsing/parser.mly\"\n ( [x] )\n# 31701 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = oe;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_oe_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_oe_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let x : unit = Obj.magic x in\n let oe : (Parsetree.expression option) = Obj.magic oe in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 31736 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_x_ in\n let _v : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = let _2 = \n# 126 \"\"\n ( Some x )\n# 31744 \"parsing/parser.ml\"\n in\n let x =\n let label =\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 31751 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 31759 \"parsing/parser.ml\"\n \n in\n \n# 2666 \"parsing/parser.mly\"\n ( let label, e =\n match oe with\n | None ->\n (* No expression; this is a pun. Desugar it. *)\n make_ghost label, exp_of_label label\n | Some e ->\n label, e\n in\n label, e )\n# 31773 \"parsing/parser.ml\"\n \n in\n \n# 1057 \"parsing/parser.mly\"\n ( [x] )\n# 31779 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = oe;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_oe_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_oe_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let xs : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = Obj.magic xs in\n let _2 : unit = Obj.magic _2 in\n let oe : (Parsetree.expression option) = Obj.magic oe in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 31821 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = let x =\n let label =\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 31831 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 31839 \"parsing/parser.ml\"\n \n in\n \n# 2666 \"parsing/parser.mly\"\n ( let label, e =\n match oe with\n | None ->\n (* No expression; this is a pun. Desugar it. *)\n make_ghost label, exp_of_label label\n | Some e ->\n label, e\n in\n label, e )\n# 31853 \"parsing/parser.ml\"\n \n in\n \n# 1061 \"parsing/parser.mly\"\n ( x :: xs )\n# 31859 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let x : (Parsetree.pattern) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_ in\n let _v : (Parsetree.pattern list) = let _2 = \n# 124 \"\"\n ( None )\n# 31884 \"parsing/parser.ml\"\n in\n \n# 1057 \"parsing/parser.mly\"\n ( [x] )\n# 31889 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let x_inlined1 : unit = Obj.magic x_inlined1 in\n let x : (Parsetree.pattern) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_x_inlined1_ in\n let _v : (Parsetree.pattern list) = let _2 =\n let x = x_inlined1 in\n \n# 126 \"\"\n ( Some x )\n# 31923 \"parsing/parser.ml\"\n \n in\n \n# 1057 \"parsing/parser.mly\"\n ( [x] )\n# 31929 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let xs : (Parsetree.pattern list) = Obj.magic xs in\n let _2 : unit = Obj.magic _2 in\n let x : (Parsetree.pattern) = Obj.magic x in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_x_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.pattern list) = \n# 1061 \"parsing/parser.mly\"\n ( x :: xs )\n# 31968 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = eo;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_eo_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_eo_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = c;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_c_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_c_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let eo : (Parsetree.expression option) = Obj.magic eo in\n let c : ((Parsetree.core_type option * Parsetree.core_type option) option) = Obj.magic c in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_eo_ in\n let _v : ((Longident.t Asttypes.loc * Parsetree.expression) list) = let _2 = \n# 124 \"\"\n ( None )\n# 32007 \"parsing/parser.ml\"\n in\n let x =\n let label =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 32017 \"parsing/parser.ml\"\n \n in\n let _startpos_label_ = _startpos__1_ in\n let _endpos = _endpos_eo_ in\n let _symbolstartpos = _startpos_label_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2649 \"parsing/parser.mly\"\n ( let constraint_loc, label, e =\n match eo with\n | None ->\n (* No pattern; this is a pun. Desugar it. *)\n _sloc, make_ghost label, exp_of_longident label\n | Some e ->\n (_startpos_c_, _endpos), label, e\n in\n label, mkexp_opt_constraint ~loc:constraint_loc e c )\n# 32035 \"parsing/parser.ml\"\n \n in\n \n# 1057 \"parsing/parser.mly\"\n ( [x] )\n# 32041 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = x;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_x_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_x_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = eo;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_eo_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_eo_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = c;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_c_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_c_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let x : unit = Obj.magic x in\n let eo : (Parsetree.expression option) = Obj.magic eo in\n let c : ((Parsetree.core_type option * Parsetree.core_type option) option) = Obj.magic c in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_x_ in\n let _v : ((Longident.t Asttypes.loc * Parsetree.expression) list) = let _2 = \n# 126 \"\"\n ( Some x )\n# 32087 \"parsing/parser.ml\"\n in\n let x =\n let label =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 32097 \"parsing/parser.ml\"\n \n in\n let _startpos_label_ = _startpos__1_ in\n let _endpos = _endpos_eo_ in\n let _symbolstartpos = _startpos_label_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2649 \"parsing/parser.mly\"\n ( let constraint_loc, label, e =\n match eo with\n | None ->\n (* No pattern; this is a pun. Desugar it. *)\n _sloc, make_ghost label, exp_of_longident label\n | Some e ->\n (_startpos_c_, _endpos), label, e\n in\n label, mkexp_opt_constraint ~loc:constraint_loc e c )\n# 32115 \"parsing/parser.ml\"\n \n in\n \n# 1057 \"parsing/parser.mly\"\n ( [x] )\n# 32121 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = eo;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_eo_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_eo_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = c;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_c_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_c_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let xs : ((Longident.t Asttypes.loc * Parsetree.expression) list) = Obj.magic xs in\n let _2 : unit = Obj.magic _2 in\n let eo : (Parsetree.expression option) = Obj.magic eo in\n let c : ((Parsetree.core_type option * Parsetree.core_type option) option) = Obj.magic c in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : ((Longident.t Asttypes.loc * Parsetree.expression) list) = let x =\n let label =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 32179 \"parsing/parser.ml\"\n \n in\n let _startpos_label_ = _startpos__1_ in\n let _endpos = _endpos_eo_ in\n let _symbolstartpos = _startpos_label_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2649 \"parsing/parser.mly\"\n ( let constraint_loc, label, e =\n match eo with\n | None ->\n (* No pattern; this is a pun. Desugar it. *)\n _sloc, make_ghost label, exp_of_longident label\n | Some e ->\n (_startpos_c_, _endpos), label, e\n in\n label, mkexp_opt_constraint ~loc:constraint_loc e c )\n# 32197 \"parsing/parser.ml\"\n \n in\n \n# 1061 \"parsing/parser.mly\"\n ( x :: xs )\n# 32203 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.expression) = \n# 2183 \"parsing/parser.mly\"\n ( _1 )\n# 32228 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = \n# 2184 \"parsing/parser.mly\"\n ( _1 )\n# 32260 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 = \n# 2186 \"parsing/parser.mly\"\n ( Pexp_sequence(_1, _3) )\n# 32300 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 32309 \"parsing/parser.ml\"\n \n in\n \n# 2187 \"parsing/parser.mly\"\n ( _1 )\n# 32315 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _4 : (string Asttypes.loc) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2189 \"parsing/parser.mly\"\n ( let seq = mkexp ~loc:_sloc (Pexp_sequence (_1, _5)) in\n let payload = PStr [mkstrexp seq []] in\n mkexp ~loc:_sloc (Pexp_extension (_4, payload)) )\n# 32373 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = vars_args_res;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_vars_args_res_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_vars_args_res_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let vars_args_res : (Ast_helper.str list * Parsetree.constructor_arguments *\n Parsetree.core_type option) = Obj.magic vars_args_res in\n let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined4_ in\n let _v : (Parsetree.type_exception * string Asttypes.loc option) = let attrs =\n let _1 = _1_inlined4 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 32443 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs_ = _endpos__1_inlined4_ in\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 32452 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 32464 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 32472 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs_ in\n let _startpos = _startpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3119 \"parsing/parser.mly\"\n ( let vars, args, res = vars_args_res in\n let loc = make_loc (_startpos, _endpos_attrs2_) in\n let docs = symbol_docs _sloc in\n Te.mk_exception ~attrs\n (Te.decl id ~vars ~args ?res ~attrs:(attrs1 @ attrs2) ~loc ~docs)\n , ext )\n# 32487 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let xss : (Parsetree.signature_item list list) = Obj.magic xss in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xss_ in\n let _endpos = _endpos_xss_ in\n let _v : (Parsetree.signature) = let _1 =\n let _1 = \n# 260 \"\"\n ( List.flatten xss )\n# 32513 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 880 \"parsing/parser.mly\"\n ( extra_sig _startpos _endpos _1 )\n# 32521 \"parsing/parser.ml\"\n \n in\n \n# 1632 \"parsing/parser.mly\"\n ( _1 )\n# 32527 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : (Parsetree.extension) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.signature_item) = let _2 =\n let _1 = _1_inlined1 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 32561 \"parsing/parser.ml\"\n \n in\n let _endpos__2_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1647 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n mksig ~loc:_sloc (Psig_extension (_1, (add_docs_attrs docs _2))) )\n# 32572 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.attribute) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 = \n# 1651 \"parsing/parser.mly\"\n ( Psig_attribute _1 )\n# 32598 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 928 \"parsing/parser.mly\"\n ( mksig ~loc:_sloc _1 )\n# 32606 \"parsing/parser.ml\"\n \n in\n \n# 1653 \"parsing/parser.mly\"\n ( _1 )\n# 32612 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.value_description * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 = \n# 1656 \"parsing/parser.mly\"\n ( psig_value _1 )\n# 32638 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 32646 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 32652 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.value_description * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 = \n# 1658 \"parsing/parser.mly\"\n ( psig_value _1 )\n# 32678 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 32686 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 32692 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = bs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_bs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_bs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = a;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_a_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_a_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let bs : (Parsetree.type_declaration list) = Obj.magic bs in\n let a : ((Asttypes.rec_flag * string Asttypes.loc option) *\n Parsetree.type_declaration) = Obj.magic a in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_a_ in\n let _endpos = _endpos_bs_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let _1 = \n# 1118 \"parsing/parser.mly\"\n ( let (x, b) = a in x, b :: bs )\n# 32729 \"parsing/parser.ml\"\n in\n \n# 2940 \"parsing/parser.mly\"\n ( _1 )\n# 32734 \"parsing/parser.ml\"\n \n in\n \n# 2923 \"parsing/parser.mly\"\n ( _1 )\n# 32740 \"parsing/parser.ml\"\n \n in\n \n# 1660 \"parsing/parser.mly\"\n ( psig_type _1 )\n# 32746 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 32756 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 32762 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = bs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_bs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_bs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = a;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_a_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_a_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let bs : (Parsetree.type_declaration list) = Obj.magic bs in\n let a : ((Asttypes.rec_flag * string Asttypes.loc option) *\n Parsetree.type_declaration) = Obj.magic a in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_a_ in\n let _endpos = _endpos_bs_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let _1 = \n# 1118 \"parsing/parser.mly\"\n ( let (x, b) = a in x, b :: bs )\n# 32799 \"parsing/parser.ml\"\n in\n \n# 2940 \"parsing/parser.mly\"\n ( _1 )\n# 32804 \"parsing/parser.ml\"\n \n in\n \n# 2928 \"parsing/parser.mly\"\n ( _1 )\n# 32810 \"parsing/parser.ml\"\n \n in\n \n# 1662 \"parsing/parser.mly\"\n ( psig_typesubst _1 )\n# 32816 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 32826 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 32832 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = priv;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_priv_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_priv_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let xs : (Parsetree.extension_constructor list) = Obj.magic xs in\n let priv : (Asttypes.private_flag) = Obj.magic priv in\n let _7 : unit = Obj.magic _7 in\n let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 32919 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let cs = \n# 1110 \"parsing/parser.mly\"\n ( List.rev xs )\n# 32926 \"parsing/parser.ml\"\n in\n let tid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 32936 \"parsing/parser.ml\"\n \n in\n let _4 = \n# 3694 \"parsing/parser.mly\"\n ( Recursive )\n# 32942 \"parsing/parser.ml\"\n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 32949 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3193 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n let attrs = attrs1 @ attrs2 in\n Te.mk tid cs ~params ~priv ~attrs ~docs,\n ext )\n# 32961 \"parsing/parser.ml\"\n \n in\n \n# 3180 \"parsing/parser.mly\"\n ( _1 )\n# 32967 \"parsing/parser.ml\"\n \n in\n \n# 1664 \"parsing/parser.mly\"\n ( psig_typext _1 )\n# 32973 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 32983 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 32989 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = priv;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_priv_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_priv_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let xs : (Parsetree.extension_constructor list) = Obj.magic xs in\n let priv : (Asttypes.private_flag) = Obj.magic priv in\n let _7 : unit = Obj.magic _7 in\n let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let _1_inlined2 : unit = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined4_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let attrs2 =\n let _1 = _1_inlined4 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 33083 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined4_ in\n let cs = \n# 1110 \"parsing/parser.mly\"\n ( List.rev xs )\n# 33090 \"parsing/parser.ml\"\n in\n let tid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 33100 \"parsing/parser.ml\"\n \n in\n let _4 =\n let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined2_, _startpos__1_inlined2_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n let _loc = (_startpos, _endpos) in\n \n# 3696 \"parsing/parser.mly\"\n ( not_expecting _loc \"nonrec flag\" )\n# 33111 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 33119 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3193 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n let attrs = attrs1 @ attrs2 in\n Te.mk tid cs ~params ~priv ~attrs ~docs,\n ext )\n# 33131 \"parsing/parser.ml\"\n \n in\n \n# 3180 \"parsing/parser.mly\"\n ( _1 )\n# 33137 \"parsing/parser.ml\"\n \n in\n \n# 1664 \"parsing/parser.mly\"\n ( psig_typext _1 )\n# 33143 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 33153 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 33159 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.type_exception * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 = \n# 1666 \"parsing/parser.mly\"\n ( psig_exception _1 )\n# 33185 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 33193 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 33199 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let body : (Parsetree.module_type) = Obj.magic body in\n let _1_inlined2 : (string option) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 =\n let _1 =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 33264 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let name =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 33276 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 33284 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1697 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Md.mk name body ~attrs ~loc ~docs, ext\n )\n# 33298 \"parsing/parser.ml\"\n \n in\n \n# 1668 \"parsing/parser.mly\"\n ( let (body, ext) = _1 in (Psig_module body, ext) )\n# 33304 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 33314 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 33320 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (string option) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined4_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 =\n let _1 =\n let attrs2 =\n let _1 = _1_inlined4 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 33392 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined4_ in\n let body =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let id =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 33405 \"parsing/parser.ml\"\n \n in\n let (_endpos_id_, _startpos_id_) = (_endpos__1_, _startpos__1_) in\n let _endpos = _endpos_id_ in\n let _symbolstartpos = _startpos_id_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1734 \"parsing/parser.mly\"\n ( Mty.alias ~loc:(make_loc _sloc) id )\n# 33415 \"parsing/parser.ml\"\n \n in\n let name =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 33426 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 33434 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1725 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Md.mk name body ~attrs ~loc ~docs, ext\n )\n# 33448 \"parsing/parser.ml\"\n \n in\n \n# 1670 \"parsing/parser.mly\"\n ( let (body, ext) = _1 in (Psig_module body, ext) )\n# 33454 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 33464 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 33470 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.module_substitution * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 = \n# 1672 \"parsing/parser.mly\"\n ( let (body, ext) = _1 in (Psig_modsubst body, ext) )\n# 33496 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 33504 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 33510 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = bs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_bs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_bs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = mty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_mty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_mty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let bs : (Parsetree.module_declaration list) = Obj.magic bs in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let mty : (Parsetree.module_type) = Obj.magic mty in\n let _6 : unit = Obj.magic _6 in\n let _1_inlined2 : (string option) = Obj.magic _1_inlined2 in\n let _4 : unit = Obj.magic _4 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_bs_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let a =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 33598 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let name =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 33610 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 33618 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1768 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n ext, Md.mk name mty ~attrs ~loc ~docs\n )\n# 33632 \"parsing/parser.ml\"\n \n in\n \n# 1118 \"parsing/parser.mly\"\n ( let (x, b) = a in x, b :: bs )\n# 33638 \"parsing/parser.ml\"\n \n in\n \n# 1757 \"parsing/parser.mly\"\n ( _1 )\n# 33644 \"parsing/parser.ml\"\n \n in\n \n# 1674 \"parsing/parser.mly\"\n ( let (ext, l) = _1 in (Psig_recmodule l, ext) )\n# 33650 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_bs_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 33660 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 33666 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.module_type_declaration * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 = \n# 1676 \"parsing/parser.mly\"\n ( let (body, ext) = _1 in (Psig_modtype body, ext) )\n# 33692 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 33700 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 33706 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.module_type_declaration * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 = \n# 1678 \"parsing/parser.mly\"\n ( let (body, ext) = _1 in (Psig_modtypesubst body, ext) )\n# 33732 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 33740 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 33746 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.open_description * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 = \n# 1680 \"parsing/parser.mly\"\n ( let (body, ext) = _1 in (Psig_open body, ext) )\n# 33772 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 33780 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 33786 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = thing;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_thing_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_thing_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let thing : (Parsetree.module_type) = Obj.magic thing in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 =\n let _1 =\n let attrs2 =\n let _1 = _1_inlined2 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 33844 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined2_ in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 33853 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1524 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Incl.mk thing ~attrs ~loc ~docs, ext\n )\n# 33867 \"parsing/parser.ml\"\n \n in\n \n# 1682 \"parsing/parser.mly\"\n ( psig_include _1 )\n# 33873 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 33883 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 33889 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = bs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_bs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_bs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = cty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_cty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_cty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = virt;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_virt_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_virt_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let bs : (Parsetree.class_description list) = Obj.magic bs in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let cty : (Parsetree.class_type) = Obj.magic cty in\n let _7 : unit = Obj.magic _7 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 33968 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let virt : (Asttypes.virtual_flag) = Obj.magic virt in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_bs_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let a =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 33988 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 34000 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 34008 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2115 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n ext,\n Ci.mk id cty ~virt ~params ~attrs ~loc ~docs\n )\n# 34023 \"parsing/parser.ml\"\n \n in\n \n# 1118 \"parsing/parser.mly\"\n ( let (x, b) = a in x, b :: bs )\n# 34029 \"parsing/parser.ml\"\n \n in\n \n# 2103 \"parsing/parser.mly\"\n ( _1 )\n# 34035 \"parsing/parser.ml\"\n \n in\n \n# 1684 \"parsing/parser.mly\"\n ( let (ext, l) = _1 in (Psig_class l, ext) )\n# 34041 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_bs_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 34051 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 34057 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (string Asttypes.loc option * Parsetree.class_type_declaration list) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.signature_item) = let _1 =\n let _1 = \n# 1686 \"parsing/parser.mly\"\n ( let (ext, l) = _1 in (Psig_class_type l, ext) )\n# 34083 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 945 \"parsing/parser.mly\"\n ( wrap_mksig_ext ~loc:_sloc _1 )\n# 34091 \"parsing/parser.ml\"\n \n in\n \n# 1688 \"parsing/parser.mly\"\n ( _1 )\n# 34097 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.constant) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.constant) = \n# 3523 \"parsing/parser.mly\"\n ( _1 )\n# 34122 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (\n# 691 \"parsing/parser.mly\"\n (string * char option)\n# 34149 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.constant) = \n# 3524 \"parsing/parser.mly\"\n ( let (n, m) = _2 in Pconst_integer(\"-\" ^ n, m) )\n# 34158 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (\n# 670 \"parsing/parser.mly\"\n (string * char option)\n# 34185 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.constant) = \n# 3525 \"parsing/parser.mly\"\n ( let (f, m) = _2 in Pconst_float(\"-\" ^ f, m) )\n# 34194 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (\n# 691 \"parsing/parser.mly\"\n (string * char option)\n# 34221 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.constant) = \n# 3526 \"parsing/parser.mly\"\n ( let (n, m) = _2 in Pconst_integer (n, m) )\n# 34230 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (\n# 670 \"parsing/parser.mly\"\n (string * char option)\n# 34257 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.constant) = \n# 3527 \"parsing/parser.mly\"\n ( let (f, m) = _2 in Pconst_float(f, m) )\n# 34266 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _1_inlined1 : ((Longident.t Asttypes.loc * Parsetree.pattern) list * unit option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _2 =\n let _1 = _1_inlined1 in\n \n# 2852 \"parsing/parser.mly\"\n ( let fields, closed = _1 in\n let closed = match closed with Some () -> Open | None -> Closed in\n fields, closed )\n# 34311 \"parsing/parser.ml\"\n \n in\n \n# 2823 \"parsing/parser.mly\"\n ( let (fields, closed) = _2 in\n Ppat_record(fields, closed) )\n# 34318 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 34328 \"parsing/parser.ml\"\n \n in\n \n# 2837 \"parsing/parser.mly\"\n ( _1 )\n# 34334 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _1_inlined1 : ((Longident.t Asttypes.loc * Parsetree.pattern) list * unit option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _2 =\n let _1 = _1_inlined1 in\n \n# 2852 \"parsing/parser.mly\"\n ( let fields, closed = _1 in\n let closed = match closed with Some () -> Open | None -> Closed in\n fields, closed )\n# 34379 \"parsing/parser.ml\"\n \n in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2826 \"parsing/parser.mly\"\n ( unclosed \"{\" _loc__1_ \"}\" _loc__3_ )\n# 34387 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 34397 \"parsing/parser.ml\"\n \n in\n \n# 2837 \"parsing/parser.mly\"\n ( _1 )\n# 34403 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ps;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ps_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ps_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let ps : (Parsetree.pattern list) = Obj.magic ps in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _2 = \n# 2846 \"parsing/parser.mly\"\n ( ps )\n# 34444 \"parsing/parser.ml\"\n in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2828 \"parsing/parser.mly\"\n ( fst (mktailpat _loc__3_ _2) )\n# 34450 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 34460 \"parsing/parser.ml\"\n \n in\n \n# 2837 \"parsing/parser.mly\"\n ( _1 )\n# 34466 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ps;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ps_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ps_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let ps : (Parsetree.pattern list) = Obj.magic ps in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _2 = \n# 2846 \"parsing/parser.mly\"\n ( ps )\n# 34507 \"parsing/parser.ml\"\n in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2830 \"parsing/parser.mly\"\n ( unclosed \"[\" _loc__1_ \"]\" _loc__3_ )\n# 34514 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 34524 \"parsing/parser.ml\"\n \n in\n \n# 2837 \"parsing/parser.mly\"\n ( _1 )\n# 34530 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ps;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ps_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ps_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let ps : (Parsetree.pattern list) = Obj.magic ps in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _2 = \n# 2846 \"parsing/parser.mly\"\n ( ps )\n# 34571 \"parsing/parser.ml\"\n in\n \n# 2832 \"parsing/parser.mly\"\n ( Ppat_array _2 )\n# 34576 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 34586 \"parsing/parser.ml\"\n \n in\n \n# 2837 \"parsing/parser.mly\"\n ( _1 )\n# 34592 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 = \n# 2834 \"parsing/parser.mly\"\n ( Ppat_array [] )\n# 34625 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 34634 \"parsing/parser.ml\"\n \n in\n \n# 2837 \"parsing/parser.mly\"\n ( _1 )\n# 34640 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ps;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ps_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ps_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let ps : (Parsetree.pattern list) = Obj.magic ps in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _2 = \n# 2846 \"parsing/parser.mly\"\n ( ps )\n# 34681 \"parsing/parser.ml\"\n in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2836 \"parsing/parser.mly\"\n ( unclosed \"[|\" _loc__1_ \"|]\" _loc__3_ )\n# 34688 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 34698 \"parsing/parser.ml\"\n \n in\n \n# 2837 \"parsing/parser.mly\"\n ( _1 )\n# 34704 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2351 \"parsing/parser.mly\"\n ( reloc_exp ~loc:_sloc _2 )\n# 34746 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2353 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__3_ )\n# 34787 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _3 in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.expression) = let _endpos = _endpos__4_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2355 \"parsing/parser.mly\"\n ( mkexp_constraint ~loc:_sloc _2 _3 )\n# 34836 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = i;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_i_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_i_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let i : (Parsetree.expression) = Obj.magic i in\n let _3 : unit = Obj.magic _3 in\n let d : unit = Obj.magic d in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2356 \"parsing/parser.mly\"\n ( None )\n# 34890 \"parsing/parser.ml\"\n in\n \n# 2245 \"parsing/parser.mly\"\n ( array, d, Paren, i, r )\n# 34895 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2357 \"parsing/parser.mly\"\n ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 )\n# 34905 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = i;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_i_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_i_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let i : (Parsetree.expression) = Obj.magic i in\n let _3 : unit = Obj.magic _3 in\n let d : unit = Obj.magic d in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2356 \"parsing/parser.mly\"\n ( None )\n# 34959 \"parsing/parser.ml\"\n in\n \n# 2247 \"parsing/parser.mly\"\n ( array, d, Brace, i, r )\n# 34964 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2357 \"parsing/parser.mly\"\n ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 )\n# 34974 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = i;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_i_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_i_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = d;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_d_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_d_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let i : (Parsetree.expression) = Obj.magic i in\n let _3 : unit = Obj.magic _3 in\n let d : unit = Obj.magic d in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2356 \"parsing/parser.mly\"\n ( None )\n# 35028 \"parsing/parser.ml\"\n in\n \n# 2249 \"parsing/parser.mly\"\n ( array, d, Bracket, i, r )\n# 35033 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2357 \"parsing/parser.mly\"\n ( mk_indexop_expr builtin_indexing_operators ~loc:_sloc _1 )\n# 35043 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 35091 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2358 \"parsing/parser.mly\"\n ( None )\n# 35101 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 35106 \"parsing/parser.ml\"\n in\n let d =\n let _1 = \n# 124 \"\"\n ( None )\n# 35112 \"parsing/parser.ml\"\n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 35117 \"parsing/parser.ml\"\n \n in\n \n# 2245 \"parsing/parser.mly\"\n ( array, d, Paren, i, r )\n# 35123 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2359 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 35133 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 35193 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2358 \"parsing/parser.mly\"\n ( None )\n# 35205 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 35210 \"parsing/parser.ml\"\n in\n let d =\n let _1 =\n let _2 = _2_inlined1 in\n let x = \n# 2261 \"parsing/parser.mly\"\n (_2)\n# 35218 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 35223 \"parsing/parser.ml\"\n \n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 35229 \"parsing/parser.ml\"\n \n in\n \n# 2245 \"parsing/parser.mly\"\n ( array, d, Paren, i, r )\n# 35235 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2359 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 35245 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 35293 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2358 \"parsing/parser.mly\"\n ( None )\n# 35303 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 35308 \"parsing/parser.ml\"\n in\n let d =\n let _1 = \n# 124 \"\"\n ( None )\n# 35314 \"parsing/parser.ml\"\n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 35319 \"parsing/parser.ml\"\n \n in\n \n# 2247 \"parsing/parser.mly\"\n ( array, d, Brace, i, r )\n# 35325 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2359 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 35335 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 35395 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2358 \"parsing/parser.mly\"\n ( None )\n# 35407 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 35412 \"parsing/parser.ml\"\n in\n let d =\n let _1 =\n let _2 = _2_inlined1 in\n let x = \n# 2261 \"parsing/parser.mly\"\n (_2)\n# 35420 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 35425 \"parsing/parser.ml\"\n \n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 35431 \"parsing/parser.ml\"\n \n in\n \n# 2247 \"parsing/parser.mly\"\n ( array, d, Brace, i, r )\n# 35437 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2359 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 35447 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 35495 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2358 \"parsing/parser.mly\"\n ( None )\n# 35505 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 35510 \"parsing/parser.ml\"\n in\n let d =\n let _1 = \n# 124 \"\"\n ( None )\n# 35516 \"parsing/parser.ml\"\n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 35521 \"parsing/parser.ml\"\n \n in\n \n# 2249 \"parsing/parser.mly\"\n ( array, d, Bracket, i, r )\n# 35527 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2359 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 35537 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = array;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_array_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_array_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 35597 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let array : (Parsetree.expression) = Obj.magic array in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_array_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let r = \n# 2358 \"parsing/parser.mly\"\n ( None )\n# 35609 \"parsing/parser.ml\"\n in\n let i = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 35614 \"parsing/parser.ml\"\n in\n let d =\n let _1 =\n let _2 = _2_inlined1 in\n let x = \n# 2261 \"parsing/parser.mly\"\n (_2)\n# 35622 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 35627 \"parsing/parser.ml\"\n \n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 35633 \"parsing/parser.ml\"\n \n in\n \n# 2249 \"parsing/parser.mly\"\n ( array, d, Bracket, i, r )\n# 35639 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos__5_, _startpos_array_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2359 \"parsing/parser.mly\"\n ( mk_indexop_expr user_indexing_operators ~loc:_sloc _1 )\n# 35649 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _p;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__p_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__p_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _e : unit = Obj.magic _e in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _p : unit = Obj.magic _p in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__e_ in\n let _v : (Parsetree.expression) = let _1 =\n let _loc__p_ = (_startpos__p_, _endpos__p_) in\n let _loc__e_ = (_startpos__e_, _endpos__e_) in\n \n# 2254 \"parsing/parser.mly\"\n ( indexop_unclosed_error _loc__p_ Paren _loc__e_ )\n# 35705 \"parsing/parser.ml\"\n \n in\n \n# 2360 \"parsing/parser.mly\"\n ( _1 )\n# 35711 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _p;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__p_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__p_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _e : unit = Obj.magic _e in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _p : unit = Obj.magic _p in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__e_ in\n let _v : (Parsetree.expression) = let _1 =\n let _loc__p_ = (_startpos__p_, _endpos__p_) in\n let _loc__e_ = (_startpos__e_, _endpos__e_) in\n \n# 2256 \"parsing/parser.mly\"\n ( indexop_unclosed_error _loc__p_ Brace _loc__e_ )\n# 35767 \"parsing/parser.ml\"\n \n in\n \n# 2360 \"parsing/parser.mly\"\n ( _1 )\n# 35773 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _p;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__p_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__p_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _e : unit = Obj.magic _e in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _p : unit = Obj.magic _p in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__e_ in\n let _v : (Parsetree.expression) = let _1 =\n let _loc__p_ = (_startpos__p_, _endpos__p_) in\n let _loc__e_ = (_startpos__e_, _endpos__e_) in\n \n# 2258 \"parsing/parser.mly\"\n ( indexop_unclosed_error _loc__p_ Bracket _loc__e_ )\n# 35829 \"parsing/parser.ml\"\n \n in\n \n# 2360 \"parsing/parser.mly\"\n ( _1 )\n# 35835 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _p;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__p_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__p_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _e : unit = Obj.magic _e in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _p : unit = Obj.magic _p in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 35883 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__e_ in\n let _v : (Parsetree.expression) = let _1 =\n let _4 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 35893 \"parsing/parser.ml\"\n in\n let _2 =\n let _1 = \n# 124 \"\"\n ( None )\n# 35899 \"parsing/parser.ml\"\n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 35904 \"parsing/parser.ml\"\n \n in\n let _loc__p_ = (_startpos__p_, _endpos__p_) in\n let _loc__e_ = (_startpos__e_, _endpos__e_) in\n \n# 2254 \"parsing/parser.mly\"\n ( indexop_unclosed_error _loc__p_ Paren _loc__e_ )\n# 35912 \"parsing/parser.ml\"\n \n in\n \n# 2361 \"parsing/parser.mly\"\n ( _1 )\n# 35918 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _p;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__p_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__p_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _e : unit = Obj.magic _e in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _p : unit = Obj.magic _p in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 35978 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__e_ in\n let _v : (Parsetree.expression) = let _1 =\n let _4 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 35990 \"parsing/parser.ml\"\n in\n let _2 =\n let _1 =\n let _2 = _2_inlined1 in\n let x = \n# 2261 \"parsing/parser.mly\"\n (_2)\n# 35998 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 36003 \"parsing/parser.ml\"\n \n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 36009 \"parsing/parser.ml\"\n \n in\n let _loc__p_ = (_startpos__p_, _endpos__p_) in\n let _loc__e_ = (_startpos__e_, _endpos__e_) in\n \n# 2254 \"parsing/parser.mly\"\n ( indexop_unclosed_error _loc__p_ Paren _loc__e_ )\n# 36017 \"parsing/parser.ml\"\n \n in\n \n# 2361 \"parsing/parser.mly\"\n ( _1 )\n# 36023 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _p;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__p_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__p_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _e : unit = Obj.magic _e in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _p : unit = Obj.magic _p in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 36071 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__e_ in\n let _v : (Parsetree.expression) = let _1 =\n let _4 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 36081 \"parsing/parser.ml\"\n in\n let _2 =\n let _1 = \n# 124 \"\"\n ( None )\n# 36087 \"parsing/parser.ml\"\n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 36092 \"parsing/parser.ml\"\n \n in\n let _loc__p_ = (_startpos__p_, _endpos__p_) in\n let _loc__e_ = (_startpos__e_, _endpos__e_) in\n \n# 2256 \"parsing/parser.mly\"\n ( indexop_unclosed_error _loc__p_ Brace _loc__e_ )\n# 36100 \"parsing/parser.ml\"\n \n in\n \n# 2361 \"parsing/parser.mly\"\n ( _1 )\n# 36106 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _p;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__p_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__p_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _e : unit = Obj.magic _e in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _p : unit = Obj.magic _p in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 36166 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__e_ in\n let _v : (Parsetree.expression) = let _1 =\n let _4 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 36178 \"parsing/parser.ml\"\n in\n let _2 =\n let _1 =\n let _2 = _2_inlined1 in\n let x = \n# 2261 \"parsing/parser.mly\"\n (_2)\n# 36186 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 36191 \"parsing/parser.ml\"\n \n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 36197 \"parsing/parser.ml\"\n \n in\n let _loc__p_ = (_startpos__p_, _endpos__p_) in\n let _loc__e_ = (_startpos__e_, _endpos__e_) in\n \n# 2256 \"parsing/parser.mly\"\n ( indexop_unclosed_error _loc__p_ Brace _loc__e_ )\n# 36205 \"parsing/parser.ml\"\n \n in\n \n# 2361 \"parsing/parser.mly\"\n ( _1 )\n# 36211 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _p;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__p_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__p_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _e : unit = Obj.magic _e in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _p : unit = Obj.magic _p in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 36259 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__e_ in\n let _v : (Parsetree.expression) = let _1 =\n let _4 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 36269 \"parsing/parser.ml\"\n in\n let _2 =\n let _1 = \n# 124 \"\"\n ( None )\n# 36275 \"parsing/parser.ml\"\n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 36280 \"parsing/parser.ml\"\n \n in\n let _loc__p_ = (_startpos__p_, _endpos__p_) in\n let _loc__e_ = (_startpos__e_, _endpos__e_) in\n \n# 2258 \"parsing/parser.mly\"\n ( indexop_unclosed_error _loc__p_ Bracket _loc__e_ )\n# 36288 \"parsing/parser.ml\"\n \n in\n \n# 2361 \"parsing/parser.mly\"\n ( _1 )\n# 36294 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _p;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__p_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__p_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _e : unit = Obj.magic _e in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _p : unit = Obj.magic _p in\n let _2 : (\n# 686 \"parsing/parser.mly\"\n (string)\n# 36354 \"parsing/parser.ml\"\n ) = Obj.magic _2 in\n let _2_inlined1 : (Longident.t) = Obj.magic _2_inlined1 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__e_ in\n let _v : (Parsetree.expression) = let _1 =\n let _4 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 36366 \"parsing/parser.ml\"\n in\n let _2 =\n let _1 =\n let _2 = _2_inlined1 in\n let x = \n# 2261 \"parsing/parser.mly\"\n (_2)\n# 36374 \"parsing/parser.ml\"\n in\n \n# 126 \"\"\n ( Some x )\n# 36379 \"parsing/parser.ml\"\n \n in\n \n# 2261 \"parsing/parser.mly\"\n ( _1, _2 )\n# 36385 \"parsing/parser.ml\"\n \n in\n let _loc__p_ = (_startpos__p_, _endpos__p_) in\n let _loc__e_ = (_startpos__e_, _endpos__e_) in\n \n# 2258 \"parsing/parser.mly\"\n ( indexop_unclosed_error _loc__p_ Bracket _loc__e_ )\n# 36393 \"parsing/parser.ml\"\n \n in\n \n# 2361 \"parsing/parser.mly\"\n ( _1 )\n# 36399 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let e : (Parsetree.expression) = Obj.magic e in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let attrs =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 36455 \"parsing/parser.ml\"\n \n in\n \n# 2370 \"parsing/parser.mly\"\n ( e.pexp_desc, (ext, attrs @ e.pexp_attributes) )\n# 36461 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2363 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 36472 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 36523 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 36529 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2372 \"parsing/parser.mly\"\n ( Pexp_construct (mkloc (Lident \"()\") (make_loc _sloc), None), _2 )\n# 36538 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2363 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 36549 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.expression) = let _1 =\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 36607 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 36613 \"parsing/parser.ml\"\n \n in\n let _loc__4_ = (_startpos__4_, _endpos__4_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2374 \"parsing/parser.mly\"\n ( unclosed \"begin\" _loc__1_ \"end\" _loc__4_ )\n# 36621 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2363 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 36632 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _3 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 36684 \"parsing/parser.ml\"\n \n in\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 36694 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 36700 \"parsing/parser.ml\"\n \n in\n \n# 2376 \"parsing/parser.mly\"\n ( Pexp_new(_3), _2 )\n# 36706 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2363 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 36717 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.module_expr) = Obj.magic _4 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _3 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 36782 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 36788 \"parsing/parser.ml\"\n \n in\n \n# 2378 \"parsing/parser.mly\"\n ( Pexp_pack _4, _3 )\n# 36794 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2363 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 36805 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : unit = Obj.magic _7 in\n let _1_inlined3 : (Parsetree.module_type) = Obj.magic _1_inlined3 in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.module_expr) = Obj.magic _4 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.expression) = let _1 =\n let _6 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3437 \"parsing/parser.mly\"\n ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in\n let descr = Ptyp_package (lid, cstrs) in\n mktyp ~loc:_sloc ~attrs descr )\n# 36887 \"parsing/parser.ml\"\n \n in\n let _3 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 36897 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 36903 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__7_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2380 \"parsing/parser.mly\"\n ( Pexp_constraint (ghexp ~loc:_sloc (Pexp_pack _4), _6), _3 )\n# 36912 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__7_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2363 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 36923 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _6 : unit = Obj.magic _6 in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.module_expr) = Obj.magic _4 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__6_ in\n let _v : (Parsetree.expression) = let _1 =\n let _3 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 36995 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 37001 \"parsing/parser.ml\"\n \n in\n let _loc__6_ = (_startpos__6_, _endpos__6_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2382 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__6_ )\n# 37009 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__6_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2363 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 37020 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let xss : (Parsetree.class_field list list) = Obj.magic xss in\n let _1_inlined3 : (Parsetree.pattern) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.expression) = let _1 =\n let _3 =\n let _1 = _1_inlined3 in\n let _2 =\n let _1 =\n let _1 = \n# 260 \"\"\n ( List.flatten xss )\n# 37085 \"parsing/parser.ml\"\n in\n \n# 1931 \"parsing/parser.mly\"\n ( _1 )\n# 37090 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 881 \"parsing/parser.mly\"\n ( extra_cstr _startpos _endpos _1 )\n# 37099 \"parsing/parser.ml\"\n \n in\n \n# 1918 \"parsing/parser.mly\"\n ( Cstr.mk _1 _2 )\n# 37105 \"parsing/parser.ml\"\n \n in\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 37115 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 37121 \"parsing/parser.ml\"\n \n in\n \n# 2384 \"parsing/parser.mly\"\n ( Pexp_object _3, _2 )\n# 37127 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2363 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 37138 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let xss : (Parsetree.class_field list list) = Obj.magic xss in\n let _1_inlined3 : (Parsetree.pattern) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.expression) = let _1 =\n let _3 =\n let _1 = _1_inlined3 in\n let _2 =\n let _1 =\n let _1 = \n# 260 \"\"\n ( List.flatten xss )\n# 37203 \"parsing/parser.ml\"\n in\n \n# 1931 \"parsing/parser.mly\"\n ( _1 )\n# 37208 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 881 \"parsing/parser.mly\"\n ( extra_cstr _startpos _endpos _1 )\n# 37217 \"parsing/parser.ml\"\n \n in\n \n# 1918 \"parsing/parser.mly\"\n ( Cstr.mk _1 _2 )\n# 37223 \"parsing/parser.ml\"\n \n in\n let _2 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 37233 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 37239 \"parsing/parser.ml\"\n \n in\n let _loc__4_ = (_startpos__4_, _endpos__4_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2386 \"parsing/parser.mly\"\n ( unclosed \"object\" _loc__1_ \"end\" _loc__4_ )\n# 37247 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2363 \"parsing/parser.mly\"\n ( let desc, attrs = _1 in\n mkexp_attrs ~loc:_sloc desc attrs )\n# 37258 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 37289 \"parsing/parser.ml\"\n \n in\n \n# 2390 \"parsing/parser.mly\"\n ( Pexp_ident (_1) )\n# 37295 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37304 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 37310 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.constant) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 = \n# 2392 \"parsing/parser.mly\"\n ( Pexp_constant _1 )\n# 37336 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37344 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 37350 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 37381 \"parsing/parser.ml\"\n \n in\n \n# 2394 \"parsing/parser.mly\"\n ( Pexp_construct(_1, None) )\n# 37387 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37396 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 37402 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 = \n# 2396 \"parsing/parser.mly\"\n ( Pexp_variant(_1, None) )\n# 37428 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37436 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 37442 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : (\n# 729 \"parsing/parser.mly\"\n (string)\n# 37470 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 37484 \"parsing/parser.ml\"\n \n in\n \n# 2398 \"parsing/parser.mly\"\n ( Pexp_apply(_1, [Nolabel,_2]) )\n# 37490 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37500 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 37506 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _1 =\n let _1 = \n# 2399 \"parsing/parser.mly\"\n (\"!\")\n# 37541 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 37549 \"parsing/parser.ml\"\n \n in\n \n# 2400 \"parsing/parser.mly\"\n ( Pexp_apply(_1, [Nolabel,_2]) )\n# 37555 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37565 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 37571 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let xs : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _2 = \n# 2661 \"parsing/parser.mly\"\n ( xs )\n# 37612 \"parsing/parser.ml\"\n in\n \n# 2402 \"parsing/parser.mly\"\n ( Pexp_override _2 )\n# 37617 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37627 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 37633 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let xs : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _2 = \n# 2661 \"parsing/parser.mly\"\n ( xs )\n# 37674 \"parsing/parser.ml\"\n in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2404 \"parsing/parser.mly\"\n ( unclosed \"{<\" _loc__1_ \">}\" _loc__3_ )\n# 37681 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37691 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 37697 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 = \n# 2406 \"parsing/parser.mly\"\n ( Pexp_override [] )\n# 37730 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37739 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 37745 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _3 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 37791 \"parsing/parser.ml\"\n \n in\n \n# 2408 \"parsing/parser.mly\"\n ( Pexp_field(_1, _3) )\n# 37797 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37807 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 37813 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let od =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 37873 \"parsing/parser.ml\"\n \n in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1583 \"parsing/parser.mly\"\n ( let loc = make_loc _loc__1_ in\n let me = Mod.ident ~loc _1 in\n Opn.mk ~loc me )\n# 37882 \"parsing/parser.ml\"\n \n in\n \n# 2410 \"parsing/parser.mly\"\n ( Pexp_open(od, _4) )\n# 37888 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37898 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 37904 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let xs : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = Obj.magic xs in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _4 = \n# 2661 \"parsing/parser.mly\"\n ( xs )\n# 37959 \"parsing/parser.ml\"\n in\n let od =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 37969 \"parsing/parser.ml\"\n \n in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1583 \"parsing/parser.mly\"\n ( let loc = make_loc _loc__1_ in\n let me = Mod.ident ~loc _1 in\n Opn.mk ~loc me )\n# 37978 \"parsing/parser.ml\"\n \n in\n let _startpos_od_ = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos_od_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2412 \"parsing/parser.mly\"\n ( (* TODO: review the location of Pexp_override *)\n Pexp_open(od, mkexp ~loc:_sloc (Pexp_override _4)) )\n# 37989 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 37999 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38005 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let xs : ((Asttypes.label Asttypes.loc * Parsetree.expression) list) = Obj.magic xs in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _4 = \n# 2661 \"parsing/parser.mly\"\n ( xs )\n# 38060 \"parsing/parser.ml\"\n in\n let _loc__5_ = (_startpos__5_, _endpos__5_) in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2415 \"parsing/parser.mly\"\n ( unclosed \"{<\" _loc__3_ \">}\" _loc__5_ )\n# 38067 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38077 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38083 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 38116 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _3 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 38130 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 38138 \"parsing/parser.ml\"\n \n in\n \n# 2417 \"parsing/parser.mly\"\n ( Pexp_send(_1, _3) )\n# 38144 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38154 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38160 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.expression) = Obj.magic _3 in\n let _1_inlined1 : (\n# 740 \"parsing/parser.mly\"\n (string)\n# 38194 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _1 : (Parsetree.expression) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _2 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 914 \"parsing/parser.mly\"\n ( mkoperator ~loc:_sloc _1 )\n# 38210 \"parsing/parser.ml\"\n \n in\n \n# 2419 \"parsing/parser.mly\"\n ( mkinfix _1 _2 _3 )\n# 38216 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38226 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38232 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.extension) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 = \n# 2421 \"parsing/parser.mly\"\n ( Pexp_extension _1 )\n# 38258 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38266 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38272 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _2_inlined1 : unit = Obj.magic _2_inlined1 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_inlined1_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _3 =\n let (_endpos__2_, _startpos__1_) = (_endpos__2_inlined1_, _startpos__1_inlined1_) in\n let _1 = \n# 2422 \"parsing/parser.mly\"\n (Lident \"()\")\n# 38322 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 38331 \"parsing/parser.ml\"\n \n in\n let (_endpos__3_, _startpos__3_) = (_endpos__2_inlined1_, _startpos__1_inlined1_) in\n let od =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 38343 \"parsing/parser.ml\"\n \n in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1583 \"parsing/parser.mly\"\n ( let loc = make_loc _loc__1_ in\n let me = Mod.ident ~loc _1 in\n Opn.mk ~loc me )\n# 38352 \"parsing/parser.ml\"\n \n in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2423 \"parsing/parser.mly\"\n ( Pexp_open(od, mkexp ~loc:(_loc__3_) (Pexp_construct(_3, None))) )\n# 38359 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__2_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38369 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38375 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.expression) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _loc__5_ = (_startpos__5_, _endpos__5_) in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2425 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__3_ \")\" _loc__5_ )\n# 38432 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38442 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38448 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.expression option *\n (Longident.t Asttypes.loc * Parsetree.expression) list) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 = \n# 2427 \"parsing/parser.mly\"\n ( let (exten, fields) = _2 in\n Pexp_record(fields, exten) )\n# 38490 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38499 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38505 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.expression option *\n (Longident.t Asttypes.loc * Parsetree.expression) list) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2430 \"parsing/parser.mly\"\n ( unclosed \"{\" _loc__1_ \"}\" _loc__3_ )\n# 38549 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38559 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38565 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.expression option *\n (Longident.t Asttypes.loc * Parsetree.expression) list) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let od =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 38626 \"parsing/parser.ml\"\n \n in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1583 \"parsing/parser.mly\"\n ( let loc = make_loc _loc__1_ in\n let me = Mod.ident ~loc _1 in\n Opn.mk ~loc me )\n# 38635 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n \n# 2432 \"parsing/parser.mly\"\n ( let (exten, fields) = _4 in\n Pexp_open(od, mkexp ~loc:(_startpos__3_, _endpos)\n (Pexp_record(fields, exten))) )\n# 38644 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38654 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38660 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.expression option *\n (Longident.t Asttypes.loc * Parsetree.expression) list) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _loc__5_ = (_startpos__5_, _endpos__5_) in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2436 \"parsing/parser.mly\"\n ( unclosed \"{\" _loc__3_ \"}\" _loc__5_ )\n# 38718 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38728 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38734 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _2 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 38775 \"parsing/parser.ml\"\n in\n \n# 2438 \"parsing/parser.mly\"\n ( Pexp_array(_2) )\n# 38780 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38790 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38796 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _2 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 38837 \"parsing/parser.ml\"\n in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2440 \"parsing/parser.mly\"\n ( unclosed \"[|\" _loc__1_ \"|]\" _loc__3_ )\n# 38844 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38854 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38860 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 = \n# 2442 \"parsing/parser.mly\"\n ( Pexp_array [] )\n# 38893 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38902 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 38908 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _4 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 38963 \"parsing/parser.ml\"\n in\n let od =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 38973 \"parsing/parser.ml\"\n \n in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1583 \"parsing/parser.mly\"\n ( let loc = make_loc _loc__1_ in\n let me = Mod.ident ~loc _1 in\n Opn.mk ~loc me )\n# 38982 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n \n# 2444 \"parsing/parser.mly\"\n ( Pexp_open(od, mkexp ~loc:(_startpos__3_, _endpos) (Pexp_array(_4))) )\n# 38989 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 38999 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 39005 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let od =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 39058 \"parsing/parser.ml\"\n \n in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1583 \"parsing/parser.mly\"\n ( let loc = make_loc _loc__1_ in\n let me = Mod.ident ~loc _1 in\n Opn.mk ~loc me )\n# 39067 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__4_ in\n \n# 2446 \"parsing/parser.mly\"\n ( (* TODO: review the location of Pexp_array *)\n Pexp_open(od, mkexp ~loc:(_startpos__3_, _endpos) (Pexp_array [])) )\n# 39075 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 39085 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 39091 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _4 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 39146 \"parsing/parser.ml\"\n in\n let _loc__5_ = (_startpos__5_, _endpos__5_) in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2450 \"parsing/parser.mly\"\n ( unclosed \"[|\" _loc__3_ \"|]\" _loc__5_ )\n# 39153 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 39163 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 39169 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _2 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 39210 \"parsing/parser.ml\"\n in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2452 \"parsing/parser.mly\"\n ( fst (mktailexp _loc__3_ _2) )\n# 39216 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 39226 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 39232 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _2 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 39273 \"parsing/parser.ml\"\n in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2454 \"parsing/parser.mly\"\n ( unclosed \"[\" _loc__1_ \"]\" _loc__3_ )\n# 39280 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 39290 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 39296 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _4 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 39351 \"parsing/parser.ml\"\n in\n let od =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 39361 \"parsing/parser.ml\"\n \n in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1583 \"parsing/parser.mly\"\n ( let loc = make_loc _loc__1_ in\n let me = Mod.ident ~loc _1 in\n Opn.mk ~loc me )\n# 39370 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n let _loc__5_ = (_startpos__5_, _endpos__5_) in\n \n# 2456 \"parsing/parser.mly\"\n ( let list_exp =\n (* TODO: review the location of list_exp *)\n let tail_exp, _tail_loc = mktailexp _loc__5_ _4 in\n mkexp ~loc:(_startpos__3_, _endpos) tail_exp in\n Pexp_open(od, list_exp) )\n# 39382 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 39392 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 39398 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _2_inlined1 : unit = Obj.magic _2_inlined1 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_inlined1_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _3 =\n let (_endpos__2_, _startpos__1_) = (_endpos__2_inlined1_, _startpos__1_inlined1_) in\n let _1 = \n# 2461 \"parsing/parser.mly\"\n (Lident \"[]\")\n# 39448 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 39457 \"parsing/parser.ml\"\n \n in\n let (_endpos__3_, _startpos__3_) = (_endpos__2_inlined1_, _startpos__1_inlined1_) in\n let od =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 39469 \"parsing/parser.ml\"\n \n in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1583 \"parsing/parser.mly\"\n ( let loc = make_loc _loc__1_ in\n let me = Mod.ident ~loc _1 in\n Opn.mk ~loc me )\n# 39478 \"parsing/parser.ml\"\n \n in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2462 \"parsing/parser.mly\"\n ( Pexp_open(od, mkexp ~loc:_loc__3_ (Pexp_construct(_3, None))) )\n# 39485 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__2_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 39495 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 39501 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = es;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_es_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_es_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let es : (Parsetree.expression list) = Obj.magic es in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _4 = \n# 2678 \"parsing/parser.mly\"\n ( es )\n# 39556 \"parsing/parser.ml\"\n in\n let _loc__5_ = (_startpos__5_, _endpos__5_) in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2465 \"parsing/parser.mly\"\n ( unclosed \"[\" _loc__3_ \"]\" _loc__5_ )\n# 39563 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 39573 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 39579 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _9;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__9_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__9_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _9 : unit = Obj.magic _9 in\n let _1_inlined3 : (Parsetree.module_type) = Obj.magic _1_inlined3 in\n let _7 : unit = Obj.magic _7 in\n let _6 : (Parsetree.module_expr) = Obj.magic _6 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _4 : unit = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__9_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _8 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3437 \"parsing/parser.mly\"\n ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in\n let descr = Ptyp_package (lid, cstrs) in\n mktyp ~loc:_sloc ~attrs descr )\n# 39676 \"parsing/parser.ml\"\n \n in\n let _5 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 39686 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 39692 \"parsing/parser.ml\"\n \n in\n let od =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 39703 \"parsing/parser.ml\"\n \n in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 1583 \"parsing/parser.mly\"\n ( let loc = make_loc _loc__1_ in\n let me = Mod.ident ~loc _1 in\n Opn.mk ~loc me )\n# 39712 \"parsing/parser.ml\"\n \n in\n let _startpos_od_ = _startpos__1_ in\n let _endpos = _endpos__9_ in\n let _symbolstartpos = _startpos_od_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2468 \"parsing/parser.mly\"\n ( let modexp =\n mkexp_attrs ~loc:(_startpos__3_, _endpos)\n (Pexp_constraint (ghexp ~loc:_sloc (Pexp_pack _6), _8)) _5 in\n Pexp_open(od, modexp) )\n# 39725 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__9_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 39735 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 39741 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _8;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__8_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__8_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _8 : unit = Obj.magic _8 in\n let _7 : unit = Obj.magic _7 in\n let _6 : (Parsetree.module_expr) = Obj.magic _6 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _4 : unit = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__8_ in\n let _v : (Parsetree.expression) = let _1 =\n let _1 =\n let _5 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 39828 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 39834 \"parsing/parser.ml\"\n \n in\n let _loc__8_ = (_startpos__8_, _endpos__8_) in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2474 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__3_ \")\" _loc__8_ )\n# 39842 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__8_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 920 \"parsing/parser.mly\"\n ( mkexp ~loc:_sloc _1 )\n# 39852 \"parsing/parser.ml\"\n \n in\n \n# 2366 \"parsing/parser.mly\"\n ( _1 )\n# 39858 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 39889 \"parsing/parser.ml\"\n \n in\n \n# 2761 \"parsing/parser.mly\"\n ( Ppat_var (_1) )\n# 39895 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 39904 \"parsing/parser.ml\"\n \n in\n \n# 2762 \"parsing/parser.mly\"\n ( _1 )\n# 39910 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = \n# 2763 \"parsing/parser.mly\"\n ( _1 )\n# 39935 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2768 \"parsing/parser.mly\"\n ( reloc_pat ~loc:_sloc _2 )\n# 39977 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = \n# 2770 \"parsing/parser.mly\"\n ( _1 )\n# 40002 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined3 : (string option) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.pattern) = let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 40067 \"parsing/parser.ml\"\n \n in\n let _3 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 40077 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 40083 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2772 \"parsing/parser.mly\"\n ( mkpat_attrs ~loc:_sloc (Ppat_unpack _4) _3 )\n# 40092 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : unit = Obj.magic _7 in\n let _1_inlined4 : (Parsetree.module_type) = Obj.magic _1_inlined4 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined3 : (string option) = Obj.magic _1_inlined3 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.pattern) = let _6 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined4_, _startpos__1_inlined4_, _1_inlined4) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3437 \"parsing/parser.mly\"\n ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in\n let descr = Ptyp_package (lid, cstrs) in\n mktyp ~loc:_sloc ~attrs descr )\n# 40173 \"parsing/parser.ml\"\n \n in\n let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 40184 \"parsing/parser.ml\"\n \n in\n let (_endpos__4_, _startpos__4_) = (_endpos__1_inlined3_, _startpos__1_inlined3_) in\n let _3 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 40195 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 40201 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__7_ in\n let _symbolstartpos = _startpos__1_ in\n let _loc__4_ = (_startpos__4_, _endpos__4_) in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2774 \"parsing/parser.mly\"\n ( mkpat_attrs ~loc:_sloc\n (Ppat_constraint(mkpat ~loc:_loc__4_ (Ppat_unpack _4), _6))\n _3 )\n# 40213 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 = \n# 2782 \"parsing/parser.mly\"\n ( Ppat_any )\n# 40239 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40247 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40253 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.constant) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 = \n# 2784 \"parsing/parser.mly\"\n ( Ppat_constant _1 )\n# 40279 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40287 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40293 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.constant) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.constant) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 = \n# 2786 \"parsing/parser.mly\"\n ( Ppat_interval (_1, _3) )\n# 40333 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40342 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40348 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 40379 \"parsing/parser.ml\"\n \n in\n \n# 2788 \"parsing/parser.mly\"\n ( Ppat_construct(_1, None) )\n# 40385 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40394 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40400 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 = \n# 2790 \"parsing/parser.mly\"\n ( Ppat_variant(_1, None) )\n# 40426 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40434 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40440 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _2 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 40479 \"parsing/parser.ml\"\n \n in\n \n# 2792 \"parsing/parser.mly\"\n ( Ppat_type (_2) )\n# 40485 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40495 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40501 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : (Parsetree.pattern) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 40546 \"parsing/parser.ml\"\n \n in\n \n# 2794 \"parsing/parser.mly\"\n ( Ppat_open(_1, _3) )\n# 40552 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40562 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40568 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _2_inlined1 : unit = Obj.magic _2_inlined1 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_inlined1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _3 =\n let (_endpos__2_, _startpos__1_) = (_endpos__2_inlined1_, _startpos__1_inlined1_) in\n let _1 = \n# 2795 \"parsing/parser.mly\"\n (Lident \"[]\")\n# 40618 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 40627 \"parsing/parser.ml\"\n \n in\n let _endpos__3_ = _endpos__2_inlined1_ in\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 40638 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2796 \"parsing/parser.mly\"\n ( Ppat_open(_1, mkpat ~loc:_sloc (Ppat_construct(_3, None))) )\n# 40647 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__2_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40657 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40663 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _2_inlined1 : unit = Obj.magic _2_inlined1 in\n let _1_inlined1 : unit = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_inlined1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _3 =\n let (_endpos__2_, _startpos__1_) = (_endpos__2_inlined1_, _startpos__1_inlined1_) in\n let _1 = \n# 2797 \"parsing/parser.mly\"\n (Lident \"()\")\n# 40713 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 40722 \"parsing/parser.ml\"\n \n in\n let _endpos__3_ = _endpos__2_inlined1_ in\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 40733 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__3_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2798 \"parsing/parser.mly\"\n ( Ppat_open(_1, mkpat ~loc:_sloc (Ppat_construct(_3, None))) )\n# 40742 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__2_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40752 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40758 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.pattern) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 40817 \"parsing/parser.ml\"\n \n in\n \n# 2800 \"parsing/parser.mly\"\n ( Ppat_open (_1, _4) )\n# 40823 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40833 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40839 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.pattern) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _loc__5_ = (_startpos__5_, _endpos__5_) in\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 2802 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__3_ \")\" _loc__5_ )\n# 40896 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40906 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40912 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _loc__4_ = (_startpos__4_, _endpos__4_) in\n \n# 2804 \"parsing/parser.mly\"\n ( expecting _loc__4_ \"pattern\" )\n# 40961 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 40971 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 40977 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2806 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__3_ )\n# 41020 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 41030 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 41036 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.core_type) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 = \n# 2808 \"parsing/parser.mly\"\n ( Ppat_constraint(_2, _4) )\n# 41090 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 41099 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 41105 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : unit = Obj.magic _5 in\n let _4 : (Parsetree.core_type) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _loc__5_ = (_startpos__5_, _endpos__5_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2810 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__5_ )\n# 41162 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__5_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 41172 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 41178 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : unit = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.pattern) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _loc__4_ = (_startpos__4_, _endpos__4_) in\n \n# 2812 \"parsing/parser.mly\"\n ( expecting _loc__4_ \"type\" )\n# 41227 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 41237 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 41243 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : unit = Obj.magic _7 in\n let _1_inlined3 : (Parsetree.module_type) = Obj.magic _1_inlined3 in\n let _5 : unit = Obj.magic _5 in\n let _4 : (string option) = Obj.magic _4 in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (string Asttypes.loc option) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 =\n let _6 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3437 \"parsing/parser.mly\"\n ( let (lid, cstrs, attrs) = package_type_of_module_type _1 in\n let descr = Ptyp_package (lid, cstrs) in\n mktyp ~loc:_sloc ~attrs descr )\n# 41326 \"parsing/parser.ml\"\n \n in\n let _3 =\n let (_1_inlined1, _1) = (_1_inlined2, _1_inlined1) in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 41336 \"parsing/parser.ml\"\n \n in\n \n# 3866 \"parsing/parser.mly\"\n ( _1, _2 )\n# 41342 \"parsing/parser.ml\"\n \n in\n let _loc__7_ = (_startpos__7_, _endpos__7_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 2815 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__7_ )\n# 41350 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__7_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 41360 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 41366 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.extension) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.pattern) = let _1 =\n let _1 = \n# 2817 \"parsing/parser.mly\"\n ( Ppat_extension _1 )\n# 41392 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 922 \"parsing/parser.mly\"\n ( mkpat ~loc:_sloc _1 )\n# 41400 \"parsing/parser.ml\"\n \n in\n \n# 2778 \"parsing/parser.mly\"\n ( _1 )\n# 41406 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 41427 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3774 \"parsing/parser.mly\"\n ( _1 )\n# 41435 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 756 \"parsing/parser.mly\"\n (string)\n# 41456 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3775 \"parsing/parser.mly\"\n ( _1 )\n# 41464 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3776 \"parsing/parser.mly\"\n ( \"and\" )\n# 41489 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3777 \"parsing/parser.mly\"\n ( \"as\" )\n# 41514 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3778 \"parsing/parser.mly\"\n ( \"assert\" )\n# 41539 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3779 \"parsing/parser.mly\"\n ( \"begin\" )\n# 41564 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3780 \"parsing/parser.mly\"\n ( \"class\" )\n# 41589 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3781 \"parsing/parser.mly\"\n ( \"constraint\" )\n# 41614 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3782 \"parsing/parser.mly\"\n ( \"do\" )\n# 41639 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3783 \"parsing/parser.mly\"\n ( \"done\" )\n# 41664 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3784 \"parsing/parser.mly\"\n ( \"downto\" )\n# 41689 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3785 \"parsing/parser.mly\"\n ( \"else\" )\n# 41714 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3786 \"parsing/parser.mly\"\n ( \"end\" )\n# 41739 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3787 \"parsing/parser.mly\"\n ( \"exception\" )\n# 41764 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3788 \"parsing/parser.mly\"\n ( \"external\" )\n# 41789 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3789 \"parsing/parser.mly\"\n ( \"false\" )\n# 41814 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3790 \"parsing/parser.mly\"\n ( \"for\" )\n# 41839 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3791 \"parsing/parser.mly\"\n ( \"fun\" )\n# 41864 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3792 \"parsing/parser.mly\"\n ( \"function\" )\n# 41889 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3793 \"parsing/parser.mly\"\n ( \"functor\" )\n# 41914 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3794 \"parsing/parser.mly\"\n ( \"if\" )\n# 41939 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3795 \"parsing/parser.mly\"\n ( \"in\" )\n# 41964 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3796 \"parsing/parser.mly\"\n ( \"include\" )\n# 41989 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3797 \"parsing/parser.mly\"\n ( \"inherit\" )\n# 42014 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3798 \"parsing/parser.mly\"\n ( \"initializer\" )\n# 42039 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3799 \"parsing/parser.mly\"\n ( \"lazy\" )\n# 42064 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3800 \"parsing/parser.mly\"\n ( \"let\" )\n# 42089 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3801 \"parsing/parser.mly\"\n ( \"match\" )\n# 42114 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3802 \"parsing/parser.mly\"\n ( \"method\" )\n# 42139 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3803 \"parsing/parser.mly\"\n ( \"module\" )\n# 42164 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3804 \"parsing/parser.mly\"\n ( \"mutable\" )\n# 42189 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3805 \"parsing/parser.mly\"\n ( \"new\" )\n# 42214 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3806 \"parsing/parser.mly\"\n ( \"nonrec\" )\n# 42239 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3807 \"parsing/parser.mly\"\n ( \"object\" )\n# 42264 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3808 \"parsing/parser.mly\"\n ( \"of\" )\n# 42289 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3809 \"parsing/parser.mly\"\n ( \"open\" )\n# 42314 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3810 \"parsing/parser.mly\"\n ( \"or\" )\n# 42339 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3811 \"parsing/parser.mly\"\n ( \"private\" )\n# 42364 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3812 \"parsing/parser.mly\"\n ( \"rec\" )\n# 42389 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3813 \"parsing/parser.mly\"\n ( \"sig\" )\n# 42414 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3814 \"parsing/parser.mly\"\n ( \"struct\" )\n# 42439 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3815 \"parsing/parser.mly\"\n ( \"then\" )\n# 42464 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3816 \"parsing/parser.mly\"\n ( \"to\" )\n# 42489 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3817 \"parsing/parser.mly\"\n ( \"true\" )\n# 42514 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3818 \"parsing/parser.mly\"\n ( \"try\" )\n# 42539 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3819 \"parsing/parser.mly\"\n ( \"type\" )\n# 42564 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3820 \"parsing/parser.mly\"\n ( \"val\" )\n# 42589 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3821 \"parsing/parser.mly\"\n ( \"virtual\" )\n# 42614 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3822 \"parsing/parser.mly\"\n ( \"when\" )\n# 42639 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3823 \"parsing/parser.mly\"\n ( \"while\" )\n# 42664 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3824 \"parsing/parser.mly\"\n ( \"with\" )\n# 42689 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.type_exception * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.type_exception * string Asttypes.loc option) = \n# 3096 \"parsing/parser.mly\"\n ( _1 )\n# 42714 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined5 : (Parsetree.attributes) = Obj.magic _1_inlined5 in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined5_ in\n let _v : (Parsetree.type_exception * string Asttypes.loc option) = let attrs =\n let _1 = _1_inlined5 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 42790 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs_ = _endpos__1_inlined5_ in\n let attrs2 =\n let _1 = _1_inlined4 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 42799 \"parsing/parser.ml\"\n \n in\n let lid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 42810 \"parsing/parser.ml\"\n \n in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 42821 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 42829 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3105 \"parsing/parser.mly\"\n ( let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Te.mk_exception ~attrs\n (Te.rebind id lid ~attrs:(attrs1 @ attrs2) ~loc ~docs)\n , ext )\n# 42842 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = \n# 2603 \"parsing/parser.mly\"\n ( _2 )\n# 42874 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.expression) = Obj.magic _2 in\n let _1 : (Asttypes.arg_label * Parsetree.expression option * Parsetree.pattern) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.expression) = let _endpos = _endpos__2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2605 \"parsing/parser.mly\"\n ( let (l, o, p) = _1 in ghexp ~loc:_sloc (Pexp_fun(l, o, p, _2)) )\n# 42909 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _5 : (Parsetree.expression) = Obj.magic _5 in\n let _4 : unit = Obj.magic _4 in\n let xs : (string Asttypes.loc list) = Obj.magic xs in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__5_ in\n let _v : (Parsetree.expression) = let _3 = \n# 2495 \"parsing/parser.mly\"\n ( xs )\n# 42962 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2607 \"parsing/parser.mly\"\n ( mk_newtypes ~loc:_sloc _3 _5 )\n# 42970 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let xss : (Parsetree.structure_item list list) = Obj.magic xss in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xss_ in\n let _endpos = _endpos_xss_ in\n let _v : (Parsetree.structure) = let _1 =\n let _1 =\n let ys = \n# 260 \"\"\n ( List.flatten xss )\n# 42997 \"parsing/parser.ml\"\n in\n let xs =\n let items = \n# 957 \"parsing/parser.mly\"\n ( [] )\n# 43003 \"parsing/parser.ml\"\n in\n \n# 1386 \"parsing/parser.mly\"\n ( items )\n# 43008 \"parsing/parser.ml\"\n \n in\n \n# 267 \"\"\n ( xs @ ys )\n# 43014 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 879 \"parsing/parser.mly\"\n ( extra_str _startpos _endpos _1 )\n# 43023 \"parsing/parser.ml\"\n \n in\n \n# 1379 \"parsing/parser.mly\"\n ( _1 )\n# 43029 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let xss : (Parsetree.structure_item list list) = Obj.magic xss in\n let _1 : (Parsetree.attributes) = Obj.magic _1 in\n let e : (Parsetree.expression) = Obj.magic e in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e_ in\n let _endpos = _endpos_xss_ in\n let _v : (Parsetree.structure) = let _1 =\n let _1 =\n let ys = \n# 260 \"\"\n ( List.flatten xss )\n# 43070 \"parsing/parser.ml\"\n in\n let xs =\n let items =\n let x =\n let _1 =\n let _1 =\n let attrs = \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 43080 \"parsing/parser.ml\"\n in\n \n# 1393 \"parsing/parser.mly\"\n ( mkstrexp e attrs )\n# 43085 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos_e_ in\n let _startpos = _startpos__1_ in\n \n# 891 \"parsing/parser.mly\"\n ( text_str _startpos @ [_1] )\n# 43093 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos_e_ in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 910 \"parsing/parser.mly\"\n ( mark_rhs_docs _startpos _endpos;\n _1 )\n# 43103 \"parsing/parser.ml\"\n \n in\n \n# 959 \"parsing/parser.mly\"\n ( x )\n# 43109 \"parsing/parser.ml\"\n \n in\n \n# 1386 \"parsing/parser.mly\"\n ( items )\n# 43115 \"parsing/parser.ml\"\n \n in\n \n# 267 \"\"\n ( xs @ ys )\n# 43121 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_e_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 879 \"parsing/parser.mly\"\n ( extra_str _startpos _endpos _1 )\n# 43130 \"parsing/parser.ml\"\n \n in\n \n# 1379 \"parsing/parser.mly\"\n ( _1 )\n# 43136 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (let_bindings) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.structure_item) = let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1408 \"parsing/parser.mly\"\n ( val_of_let_bindings ~loc:_sloc _1 )\n# 43164 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : (Parsetree.extension) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 =\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 43200 \"parsing/parser.ml\"\n \n in\n let _endpos__2_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1411 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n Pstr_extension (_1, add_docs_attrs docs _2) )\n# 43211 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined1_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 926 \"parsing/parser.mly\"\n ( mkstr ~loc:_sloc _1 )\n# 43221 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 43227 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.attribute) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 = \n# 1414 \"parsing/parser.mly\"\n ( Pstr_attribute _1 )\n# 43253 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 926 \"parsing/parser.mly\"\n ( mkstr ~loc:_sloc _1 )\n# 43261 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 43267 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.value_description * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 = \n# 1418 \"parsing/parser.mly\"\n ( pstr_primitive _1 )\n# 43293 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 43301 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 43307 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.value_description * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 = \n# 1420 \"parsing/parser.mly\"\n ( pstr_primitive _1 )\n# 43333 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 43341 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 43347 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = bs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_bs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_bs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = a;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_a_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_a_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let bs : (Parsetree.type_declaration list) = Obj.magic bs in\n let a : ((Asttypes.rec_flag * string Asttypes.loc option) *\n Parsetree.type_declaration) = Obj.magic a in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_a_ in\n let _endpos = _endpos_bs_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let _1 = \n# 1118 \"parsing/parser.mly\"\n ( let (x, b) = a in x, b :: bs )\n# 43384 \"parsing/parser.ml\"\n in\n \n# 2940 \"parsing/parser.mly\"\n ( _1 )\n# 43389 \"parsing/parser.ml\"\n \n in\n \n# 2923 \"parsing/parser.mly\"\n ( _1 )\n# 43395 \"parsing/parser.ml\"\n \n in\n \n# 1422 \"parsing/parser.mly\"\n ( pstr_type _1 )\n# 43401 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_bs_, _startpos_a_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 43411 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 43417 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = priv;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_priv_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_priv_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let xs : (Parsetree.extension_constructor list) = Obj.magic xs in\n let priv : (Asttypes.private_flag) = Obj.magic priv in\n let _7 : unit = Obj.magic _7 in\n let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 43504 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let cs = \n# 1110 \"parsing/parser.mly\"\n ( List.rev xs )\n# 43511 \"parsing/parser.ml\"\n in\n let tid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 43521 \"parsing/parser.ml\"\n \n in\n let _4 = \n# 3694 \"parsing/parser.mly\"\n ( Recursive )\n# 43527 \"parsing/parser.ml\"\n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 43534 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3193 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n let attrs = attrs1 @ attrs2 in\n Te.mk tid cs ~params ~priv ~attrs ~docs,\n ext )\n# 43546 \"parsing/parser.ml\"\n \n in\n \n# 3176 \"parsing/parser.mly\"\n ( _1 )\n# 43552 \"parsing/parser.ml\"\n \n in\n \n# 1424 \"parsing/parser.mly\"\n ( pstr_typext _1 )\n# 43558 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 43568 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 43574 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = priv;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_priv_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_priv_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined4 : (Parsetree.attributes) = Obj.magic _1_inlined4 in\n let xs : (Parsetree.extension_constructor list) = Obj.magic xs in\n let priv : (Asttypes.private_flag) = Obj.magic priv in\n let _7 : unit = Obj.magic _7 in\n let _1_inlined3 : (Longident.t) = Obj.magic _1_inlined3 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let _1_inlined2 : unit = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined4_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let attrs2 =\n let _1 = _1_inlined4 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 43668 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined4_ in\n let cs = \n# 1110 \"parsing/parser.mly\"\n ( List.rev xs )\n# 43675 \"parsing/parser.ml\"\n in\n let tid =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined3_, _startpos__1_inlined3_, _1_inlined3) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 43685 \"parsing/parser.ml\"\n \n in\n let _4 =\n let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined2_, _startpos__1_inlined2_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n let _loc = (_startpos, _endpos) in\n \n# 3696 \"parsing/parser.mly\"\n ( not_expecting _loc \"nonrec flag\" )\n# 43696 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 43704 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3193 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n let attrs = attrs1 @ attrs2 in\n Te.mk tid cs ~params ~priv ~attrs ~docs,\n ext )\n# 43716 \"parsing/parser.ml\"\n \n in\n \n# 3176 \"parsing/parser.mly\"\n ( _1 )\n# 43722 \"parsing/parser.ml\"\n \n in\n \n# 1424 \"parsing/parser.mly\"\n ( pstr_typext _1 )\n# 43728 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined4_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 43738 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 43744 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.type_exception * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 = \n# 1426 \"parsing/parser.mly\"\n ( pstr_exception _1 )\n# 43770 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 43778 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 43784 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let body : (Parsetree.module_expr) = Obj.magic body in\n let _1_inlined2 : (string option) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 =\n let _1 =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 43849 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let name =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 43861 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 43869 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1452 \"parsing/parser.mly\"\n ( let docs = symbol_docs _sloc in\n let loc = make_loc _sloc in\n let attrs = attrs1 @ attrs2 in\n let body = Mb.mk name body ~attrs ~loc ~docs in\n Pstr_module body, ext )\n# 43882 \"parsing/parser.ml\"\n \n in\n \n# 1428 \"parsing/parser.mly\"\n ( _1 )\n# 43888 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined3_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 43898 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 43904 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = bs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_bs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_bs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let bs : (Parsetree.module_binding list) = Obj.magic bs in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let body : (Parsetree.module_expr) = Obj.magic body in\n let _1_inlined2 : (string option) = Obj.magic _1_inlined2 in\n let _4 : unit = Obj.magic _4 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_bs_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let a =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 43985 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let name =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 43997 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 44005 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1487 \"parsing/parser.mly\"\n (\n let loc = make_loc _sloc in\n let attrs = attrs1 @ attrs2 in\n let docs = symbol_docs _sloc in\n ext,\n Mb.mk name body ~attrs ~loc ~docs\n )\n# 44020 \"parsing/parser.ml\"\n \n in\n \n# 1118 \"parsing/parser.mly\"\n ( let (x, b) = a in x, b :: bs )\n# 44026 \"parsing/parser.ml\"\n \n in\n \n# 1475 \"parsing/parser.mly\"\n ( _1 )\n# 44032 \"parsing/parser.ml\"\n \n in\n \n# 1430 \"parsing/parser.mly\"\n ( pstr_recmodule _1 )\n# 44038 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_bs_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 44048 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 44054 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.module_type_declaration * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 = \n# 1432 \"parsing/parser.mly\"\n ( let (body, ext) = _1 in (Pstr_modtype body, ext) )\n# 44080 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 44088 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 44094 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Parsetree.open_declaration * string Asttypes.loc option) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 = \n# 1434 \"parsing/parser.mly\"\n ( let (body, ext) = _1 in (Pstr_open body, ext) )\n# 44120 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 44128 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 44134 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = bs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_bs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_bs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = body;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_body_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_body_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = params;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_params_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_params_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = virt;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_virt_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_virt_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let bs : (Parsetree.class_declaration list) = Obj.magic bs in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let body : (Parsetree.class_expr) = Obj.magic body in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 44206 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let params : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic params in\n let virt : (Asttypes.virtual_flag) = Obj.magic virt in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_bs_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 =\n let _1 =\n let _1 =\n let a =\n let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 44226 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 44238 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 44246 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1825 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n ext,\n Ci.mk id body ~virt ~params ~attrs ~loc ~docs\n )\n# 44261 \"parsing/parser.ml\"\n \n in\n \n# 1118 \"parsing/parser.mly\"\n ( let (x, b) = a in x, b :: bs )\n# 44267 \"parsing/parser.ml\"\n \n in\n \n# 1814 \"parsing/parser.mly\"\n ( _1 )\n# 44273 \"parsing/parser.ml\"\n \n in\n \n# 1436 \"parsing/parser.mly\"\n ( let (ext, l) = _1 in (Pstr_class l, ext) )\n# 44279 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos_bs_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 44289 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 44295 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (string Asttypes.loc option * Parsetree.class_type_declaration list) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 = \n# 1438 \"parsing/parser.mly\"\n ( let (ext, l) = _1 in (Pstr_class_type l, ext) )\n# 44321 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 44329 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 44335 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = thing;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_thing_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_thing_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.attributes) = Obj.magic _1_inlined2 in\n let thing : (Parsetree.module_expr) = Obj.magic thing in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.structure_item) = let _1 =\n let _1 =\n let _1 =\n let attrs2 =\n let _1 = _1_inlined2 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 44393 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined2_ in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 44402 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1524 \"parsing/parser.mly\"\n (\n let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Incl.mk thing ~attrs ~loc ~docs, ext\n )\n# 44416 \"parsing/parser.ml\"\n \n in\n \n# 1440 \"parsing/parser.mly\"\n ( pstr_include _1 )\n# 44422 \"parsing/parser.ml\"\n \n in\n let _endpos__1_ = _endpos__1_inlined2_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 943 \"parsing/parser.mly\"\n ( wrap_mkstr_ext ~loc:_sloc _1 )\n# 44432 \"parsing/parser.ml\"\n \n in\n \n# 1442 \"parsing/parser.mly\"\n ( _1 )\n# 44438 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3759 \"parsing/parser.mly\"\n ( \"-\" )\n# 44463 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (string) = \n# 3760 \"parsing/parser.mly\"\n ( \"-.\" )\n# 44488 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _3 : (bool) = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.row_field) = let _5 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 44543 \"parsing/parser.ml\"\n \n in\n let _endpos__5_ = _endpos__1_inlined1_ in\n let _4 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 44552 \"parsing/parser.ml\"\n in\n \n# 1021 \"parsing/parser.mly\"\n ( xs )\n# 44557 \"parsing/parser.ml\"\n \n in\n \n# 3467 \"parsing/parser.mly\"\n ( _1 )\n# 44563 \"parsing/parser.ml\"\n \n in\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 44573 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3453 \"parsing/parser.mly\"\n ( let info = symbol_info _endpos in\n let attrs = add_info_attrs info _5 in\n Rf.tag ~loc:(make_loc _sloc) ~attrs _1 _3 _4 )\n# 44584 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.row_field) = let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 44618 \"parsing/parser.ml\"\n \n in\n let _endpos__2_ = _endpos__1_inlined1_ in\n let _1 =\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 44629 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3457 \"parsing/parser.mly\"\n ( let info = symbol_info _endpos in\n let attrs = add_info_attrs info _2 in\n Rf.tag ~loc:(make_loc _sloc) ~attrs _1 true [] )\n# 44640 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined1_ in\n let _v : (Parsetree.toplevel_phrase) = let arg = \n# 124 \"\"\n ( None )\n# 44672 \"parsing/parser.ml\"\n in\n let _endpos_arg_ = _endpos__1_inlined1_ in\n let dir =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 44683 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_arg_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3657 \"parsing/parser.mly\"\n ( mk_directive ~loc:_sloc dir arg )\n# 44692 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (\n# 743 \"parsing/parser.mly\"\n (string * Location.t * string option)\n# 44725 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.toplevel_phrase) = let arg =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let x =\n let _1 = \n# 3661 \"parsing/parser.mly\"\n ( let (s, _, _) = _1 in Pdir_string s )\n# 44738 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 948 \"parsing/parser.mly\"\n ( mk_directive_arg ~loc:_sloc _1 )\n# 44746 \"parsing/parser.ml\"\n \n in\n \n# 126 \"\"\n ( Some x )\n# 44752 \"parsing/parser.ml\"\n \n in\n let _endpos_arg_ = _endpos__1_inlined2_ in\n let dir =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 44764 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_arg_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3657 \"parsing/parser.mly\"\n ( mk_directive ~loc:_sloc dir arg )\n# 44773 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (\n# 691 \"parsing/parser.mly\"\n (string * char option)\n# 44806 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.toplevel_phrase) = let arg =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let x =\n let _1 = \n# 3662 \"parsing/parser.mly\"\n ( let (n, m) = _1 in Pdir_int (n ,m) )\n# 44819 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 948 \"parsing/parser.mly\"\n ( mk_directive_arg ~loc:_sloc _1 )\n# 44827 \"parsing/parser.ml\"\n \n in\n \n# 126 \"\"\n ( Some x )\n# 44833 \"parsing/parser.ml\"\n \n in\n let _endpos_arg_ = _endpos__1_inlined2_ in\n let dir =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 44845 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_arg_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3657 \"parsing/parser.mly\"\n ( mk_directive ~loc:_sloc dir arg )\n# 44854 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.toplevel_phrase) = let arg =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let x =\n let _1 = \n# 3663 \"parsing/parser.mly\"\n ( Pdir_ident _1 )\n# 44896 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 948 \"parsing/parser.mly\"\n ( mk_directive_arg ~loc:_sloc _1 )\n# 44904 \"parsing/parser.ml\"\n \n in\n \n# 126 \"\"\n ( Some x )\n# 44910 \"parsing/parser.ml\"\n \n in\n let _endpos_arg_ = _endpos__1_inlined2_ in\n let dir =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 44922 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_arg_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3657 \"parsing/parser.mly\"\n ( mk_directive ~loc:_sloc dir arg )\n# 44931 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.toplevel_phrase) = let arg =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let x =\n let _1 = \n# 3664 \"parsing/parser.mly\"\n ( Pdir_ident _1 )\n# 44973 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 948 \"parsing/parser.mly\"\n ( mk_directive_arg ~loc:_sloc _1 )\n# 44981 \"parsing/parser.ml\"\n \n in\n \n# 126 \"\"\n ( Some x )\n# 44987 \"parsing/parser.ml\"\n \n in\n let _endpos_arg_ = _endpos__1_inlined2_ in\n let dir =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 44999 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_arg_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3657 \"parsing/parser.mly\"\n ( mk_directive ~loc:_sloc dir arg )\n# 45008 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : unit = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.toplevel_phrase) = let arg =\n let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined2_, _startpos__1_inlined2_) in\n let x =\n let _1 = \n# 3665 \"parsing/parser.mly\"\n ( Pdir_bool false )\n# 45050 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 948 \"parsing/parser.mly\"\n ( mk_directive_arg ~loc:_sloc _1 )\n# 45058 \"parsing/parser.ml\"\n \n in\n \n# 126 \"\"\n ( Some x )\n# 45064 \"parsing/parser.ml\"\n \n in\n let _endpos_arg_ = _endpos__1_inlined2_ in\n let dir =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 45076 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_arg_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3657 \"parsing/parser.mly\"\n ( mk_directive ~loc:_sloc dir arg )\n# 45085 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : unit = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Asttypes.label) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.toplevel_phrase) = let arg =\n let (_endpos__1_, _startpos__1_) = (_endpos__1_inlined2_, _startpos__1_inlined2_) in\n let x =\n let _1 = \n# 3666 \"parsing/parser.mly\"\n ( Pdir_bool true )\n# 45127 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 948 \"parsing/parser.mly\"\n ( mk_directive_arg ~loc:_sloc _1 )\n# 45135 \"parsing/parser.ml\"\n \n in\n \n# 126 \"\"\n ( Some x )\n# 45141 \"parsing/parser.ml\"\n \n in\n let _endpos_arg_ = _endpos__1_inlined2_ in\n let dir =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 45153 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_arg_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3657 \"parsing/parser.mly\"\n ( mk_directive ~loc:_sloc dir arg )\n# 45162 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.attributes) = Obj.magic _1 in\n let e : (Parsetree.expression) = Obj.magic e in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.toplevel_phrase) = let _1 =\n let _1 =\n let _1 =\n let attrs = \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 45204 \"parsing/parser.ml\"\n in\n \n# 1393 \"parsing/parser.mly\"\n ( mkstrexp e attrs )\n# 45209 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos_e_ in\n let _startpos = _startpos__1_ in\n \n# 891 \"parsing/parser.mly\"\n ( text_str _startpos @ [_1] )\n# 45217 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos_e_ in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 879 \"parsing/parser.mly\"\n ( extra_str _startpos _endpos _1 )\n# 45226 \"parsing/parser.ml\"\n \n in\n \n# 1158 \"parsing/parser.mly\"\n ( Ptop_def _1 )\n# 45232 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let xss : (Parsetree.structure_item list list) = Obj.magic xss in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xss_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.toplevel_phrase) = let _1 =\n let _1 = \n# 260 \"\"\n ( List.flatten xss )\n# 45265 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 879 \"parsing/parser.mly\"\n ( extra_str _startpos _endpos _1 )\n# 45273 \"parsing/parser.ml\"\n \n in\n \n# 1162 \"parsing/parser.mly\"\n ( Ptop_def _1 )\n# 45279 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : (Parsetree.toplevel_phrase) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.toplevel_phrase) = \n# 1166 \"parsing/parser.mly\"\n ( _1 )\n# 45311 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.toplevel_phrase) = \n# 1169 \"parsing/parser.mly\"\n ( raise End_of_file )\n# 45336 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_ty_ in\n let _endpos = _endpos_ty_ in\n let _v : (Parsetree.core_type) = \n# 3359 \"parsing/parser.mly\"\n ( ty )\n# 45361 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let xs : (Parsetree.core_type list) = Obj.magic xs in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xs_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 =\n let tys =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 45389 \"parsing/parser.ml\"\n in\n \n# 1049 \"parsing/parser.mly\"\n ( xs )\n# 45394 \"parsing/parser.ml\"\n \n in\n \n# 3362 \"parsing/parser.mly\"\n ( Ptyp_tuple tys )\n# 45400 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xs_, _startpos_xs_) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 45410 \"parsing/parser.ml\"\n \n in\n \n# 3364 \"parsing/parser.mly\"\n ( _1 )\n# 45416 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.core_type) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.core_type option * Parsetree.core_type option) = \n# 2681 \"parsing/parser.mly\"\n ( (Some _2, None) )\n# 45448 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _4 : (Parsetree.core_type) = Obj.magic _4 in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Parsetree.core_type) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__4_ in\n let _v : (Parsetree.core_type option * Parsetree.core_type option) = \n# 2682 \"parsing/parser.mly\"\n ( (Some _2, Some _4) )\n# 45494 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.core_type) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.core_type option * Parsetree.core_type option) = \n# 2683 \"parsing/parser.mly\"\n ( (None, Some _2) )\n# 45526 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.core_type option * Parsetree.core_type option) = \n# 2684 \"parsing/parser.mly\"\n ( syntax_error() )\n# 45558 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.core_type option * Parsetree.core_type option) = \n# 2685 \"parsing/parser.mly\"\n ( syntax_error() )\n# 45590 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = \n# 3014 \"parsing/parser.mly\"\n ( (Ptype_abstract, Public, None) )\n# 45608 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.type_kind * Asttypes.private_flag * Parsetree.core_type option) = \n# 3016 \"parsing/parser.mly\"\n ( _2 )\n# 45640 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3618 \"parsing/parser.mly\"\n ( _1 )\n# 45665 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : (Parsetree.core_type) = Obj.magic _2 in\n let _1 : (Asttypes.variance * Asttypes.injectivity) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) = \n# 3031 \"parsing/parser.mly\"\n ( _2, _1 )\n# 45697 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = \n# 3024 \"parsing/parser.mly\"\n ( [] )\n# 45715 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = p;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_p_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_p_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let p : (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) = Obj.magic p in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_p_ in\n let _endpos = _endpos_p_ in\n let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = \n# 3026 \"parsing/parser.mly\"\n ( [p] )\n# 45740 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let xs : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic xs in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = let ps =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 45780 \"parsing/parser.ml\"\n in\n \n# 1021 \"parsing/parser.mly\"\n ( xs )\n# 45785 \"parsing/parser.ml\"\n \n in\n \n# 3028 \"parsing/parser.mly\"\n ( ps )\n# 45791 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = tyvar;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_tyvar_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_tyvar_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let tyvar : (Asttypes.label) = Obj.magic tyvar in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_tyvar_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 = \n# 3036 \"parsing/parser.mly\"\n ( Ptyp_var tyvar )\n# 45824 \"parsing/parser.ml\"\n in\n let _endpos__1_ = _endpos_tyvar_ in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 45833 \"parsing/parser.ml\"\n \n in\n \n# 3039 \"parsing/parser.mly\"\n ( _1 )\n# 45839 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Parsetree.core_type) = let _1 =\n let _1 = \n# 3038 \"parsing/parser.mly\"\n ( Ptyp_any )\n# 45865 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 924 \"parsing/parser.mly\"\n ( mktyp ~loc:_sloc _1 )\n# 45873 \"parsing/parser.ml\"\n \n in\n \n# 3039 \"parsing/parser.mly\"\n ( _1 )\n# 45879 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Asttypes.variance * Asttypes.injectivity) = \n# 3043 \"parsing/parser.mly\"\n ( NoVariance, NoInjectivity )\n# 45897 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.variance * Asttypes.injectivity) = \n# 3044 \"parsing/parser.mly\"\n ( Covariant, NoInjectivity )\n# 45922 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.variance * Asttypes.injectivity) = \n# 3045 \"parsing/parser.mly\"\n ( Contravariant, NoInjectivity )\n# 45947 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.variance * Asttypes.injectivity) = \n# 3046 \"parsing/parser.mly\"\n ( NoVariance, Injective )\n# 45972 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.variance * Asttypes.injectivity) = \n# 3047 \"parsing/parser.mly\"\n ( Covariant, Injective )\n# 46004 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.variance * Asttypes.injectivity) = \n# 3047 \"parsing/parser.mly\"\n ( Covariant, Injective )\n# 46036 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.variance * Asttypes.injectivity) = \n# 3048 \"parsing/parser.mly\"\n ( Contravariant, Injective )\n# 46068 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.variance * Asttypes.injectivity) = \n# 3048 \"parsing/parser.mly\"\n ( Contravariant, Injective )\n# 46100 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 683 \"parsing/parser.mly\"\n (string)\n# 46121 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.variance * Asttypes.injectivity) = let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 3050 \"parsing/parser.mly\"\n ( if _1 = \"+!\" then Covariant, Injective else\n if _1 = \"-!\" then Contravariant, Injective else\n expecting _loc__1_ \"type_variance\" )\n# 46132 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 729 \"parsing/parser.mly\"\n (string)\n# 46153 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.variance * Asttypes.injectivity) = let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 3054 \"parsing/parser.mly\"\n ( if _1 = \"!+\" then Covariant, Injective else\n if _1 = \"!-\" then Contravariant, Injective else\n expecting _loc__1_ \"type_variance\" )\n# 46164 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let xss : (Parsetree.toplevel_phrase list list) = Obj.magic xss in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_xss_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.toplevel_phrase list) = let _1 =\n let _1 =\n let ys = \n# 260 \"\"\n ( List.flatten xss )\n# 46198 \"parsing/parser.ml\"\n in\n let xs =\n let _1 = \n# 957 \"parsing/parser.mly\"\n ( [] )\n# 46204 \"parsing/parser.ml\"\n in\n \n# 1189 \"parsing/parser.mly\"\n ( _1 )\n# 46209 \"parsing/parser.ml\"\n \n in\n \n# 267 \"\"\n ( xs @ ys )\n# 46215 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_xss_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 883 \"parsing/parser.mly\"\n ( extra_def _startpos _endpos _1 )\n# 46224 \"parsing/parser.ml\"\n \n in\n \n# 1182 \"parsing/parser.mly\"\n ( _1 )\n# 46230 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xss;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xss_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xss_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = e;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_e_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_e_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let xss : (Parsetree.toplevel_phrase list list) = Obj.magic xss in\n let _1 : (Parsetree.attributes) = Obj.magic _1 in\n let e : (Parsetree.expression) = Obj.magic e in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos_e_ in\n let _endpos = _endpos__2_ in\n let _v : (Parsetree.toplevel_phrase list) = let _1 =\n let _1 =\n let ys = \n# 260 \"\"\n ( List.flatten xss )\n# 46278 \"parsing/parser.ml\"\n in\n let xs =\n let _1 =\n let x =\n let _1 =\n let _1 =\n let attrs = \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 46288 \"parsing/parser.ml\"\n in\n \n# 1393 \"parsing/parser.mly\"\n ( mkstrexp e attrs )\n# 46293 \"parsing/parser.ml\"\n \n in\n \n# 901 \"parsing/parser.mly\"\n ( Ptop_def [_1] )\n# 46299 \"parsing/parser.ml\"\n \n in\n let _startpos__1_ = _startpos_e_ in\n let _startpos = _startpos__1_ in\n \n# 899 \"parsing/parser.mly\"\n ( text_def _startpos @ [_1] )\n# 46307 \"parsing/parser.ml\"\n \n in\n \n# 959 \"parsing/parser.mly\"\n ( x )\n# 46313 \"parsing/parser.ml\"\n \n in\n \n# 1189 \"parsing/parser.mly\"\n ( _1 )\n# 46319 \"parsing/parser.ml\"\n \n in\n \n# 267 \"\"\n ( xs @ ys )\n# 46325 \"parsing/parser.ml\"\n \n in\n let (_endpos__1_, _startpos__1_) = (_endpos_xss_, _startpos_e_) in\n let _endpos = _endpos__1_ in\n let _startpos = _startpos__1_ in\n \n# 883 \"parsing/parser.mly\"\n ( extra_def _startpos _endpos _1 )\n# 46334 \"parsing/parser.ml\"\n \n in\n \n# 1182 \"parsing/parser.mly\"\n ( _1 )\n# 46340 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Asttypes.label) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Asttypes.label) = \n# 3537 \"parsing/parser.mly\"\n ( _2 )\n# 46379 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : (Asttypes.label) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Asttypes.label) = let _loc__3_ = (_startpos__3_, _endpos__3_) in\n let _loc__1_ = (_startpos__1_, _endpos__1_) in\n \n# 3538 \"parsing/parser.mly\"\n ( unclosed \"(\" _loc__1_ \")\" _loc__3_ )\n# 46420 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.label) = let _loc__2_ = (_startpos__2_, _endpos__2_) in\n \n# 3539 \"parsing/parser.mly\"\n ( expecting _loc__2_ \"operator\" )\n# 46453 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n } = _menhir_stack in\n let _3 : unit = Obj.magic _3 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__3_ in\n let _v : (Asttypes.label) = let _loc__3_ = (_startpos__3_, _endpos__3_) in\n \n# 3540 \"parsing/parser.mly\"\n ( expecting _loc__3_ \"module-expr\" )\n# 46493 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 46514 \"parsing/parser.ml\"\n ) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3543 \"parsing/parser.mly\"\n ( _1 )\n# 46522 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Asttypes.label) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.label) = \n# 3544 \"parsing/parser.mly\"\n ( _1 )\n# 46547 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : (Longident.t) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Longident.t) = \n# 3612 \"parsing/parser.mly\"\n ( _1 )\n# 46572 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = mutable_;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_mutable__;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_mutable__;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 46619 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let mutable_ : (Asttypes.mutable_flag) = Obj.magic mutable_ in\n let _1 : (Parsetree.attributes) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_ty_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.mutable_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let label =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 46633 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 46641 \"parsing/parser.ml\"\n \n in\n let attrs = \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 46647 \"parsing/parser.ml\"\n in\n let _1 = \n# 3752 \"parsing/parser.mly\"\n ( Fresh )\n# 46652 \"parsing/parser.ml\"\n in\n \n# 1965 \"parsing/parser.mly\"\n ( (label, mutable_, Cfk_virtual ty), attrs )\n# 46657 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _6 : (Parsetree.expression) = Obj.magic _6 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 46704 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in\n let _1 : (Parsetree.attributes) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__6_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.mutable_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 46718 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 46726 \"parsing/parser.ml\"\n \n in\n let _2 = \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 46732 \"parsing/parser.ml\"\n in\n let _1 = \n# 3755 \"parsing/parser.mly\"\n ( Fresh )\n# 46737 \"parsing/parser.ml\"\n in\n \n# 1967 \"parsing/parser.mly\"\n ( (_4, _3, Cfk_concrete (_1, _6)), _2 )\n# 46742 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _6 : (Parsetree.expression) = Obj.magic _6 in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 46795 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__6_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.mutable_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 46810 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 46818 \"parsing/parser.ml\"\n \n in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 46826 \"parsing/parser.ml\"\n \n in\n let _1 = \n# 3756 \"parsing/parser.mly\"\n ( Override )\n# 46832 \"parsing/parser.ml\"\n in\n \n# 1967 \"parsing/parser.mly\"\n ( (_4, _3, Cfk_concrete (_1, _6)), _2 )\n# 46837 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : (Parsetree.expression) = Obj.magic _7 in\n let _6 : unit = Obj.magic _6 in\n let _5 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _5 in\n let _1_inlined1 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 46891 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined1 in\n let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in\n let _1 : (Parsetree.attributes) = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.mutable_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 46905 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 46913 \"parsing/parser.ml\"\n \n in\n let _startpos__4_ = _startpos__1_inlined1_ in\n let _2 = \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 46920 \"parsing/parser.ml\"\n in\n let (_endpos__2_, _startpos__2_) = (_endpos__1_, _startpos__1_) in\n let _1 = \n# 3755 \"parsing/parser.mly\"\n ( Fresh )\n# 46926 \"parsing/parser.ml\"\n in\n let (_endpos__1_, _startpos__1_) = (_endpos__0_, _endpos__0_) in\n let _endpos = _endpos__7_ in\n let _symbolstartpos = if _startpos__1_ != _endpos__1_ then\n _startpos__1_\n else\n if _startpos__2_ != _endpos__2_ then\n _startpos__2_\n else\n if _startpos__3_ != _endpos__3_ then\n _startpos__3_\n else\n _startpos__4_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1970 \"parsing/parser.mly\"\n ( let e = mkexp_constraint ~loc:_sloc _7 _5 in\n (_4, _3, Cfk_concrete (_1, e)), _2\n )\n# 46946 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _7;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__7_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__7_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _6;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__6_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__6_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _7 : (Parsetree.expression) = Obj.magic _7 in\n let _6 : unit = Obj.magic _6 in\n let _5 : (Parsetree.core_type option * Parsetree.core_type option) = Obj.magic _5 in\n let _1_inlined2 : (\n# 705 \"parsing/parser.mly\"\n (string)\n# 47006 \"parsing/parser.ml\"\n ) = Obj.magic _1_inlined2 in\n let _3 : (Asttypes.mutable_flag) = Obj.magic _3 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__7_ in\n let _v : ((Asttypes.label Asttypes.loc * Asttypes.mutable_flag *\n Parsetree.class_field_kind) *\n Parsetree.attributes) = let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _1 = \n# 3511 \"parsing/parser.mly\"\n ( _1 )\n# 47021 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 47029 \"parsing/parser.ml\"\n \n in\n let _startpos__4_ = _startpos__1_inlined2_ in\n let _2 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 47038 \"parsing/parser.ml\"\n \n in\n let (_endpos__2_, _startpos__2_) = (_endpos__1_inlined1_, _startpos__1_inlined1_) in\n let _1 = \n# 3756 \"parsing/parser.mly\"\n ( Override )\n# 47045 \"parsing/parser.ml\"\n in\n let _endpos = _endpos__7_ in\n let _symbolstartpos = if _startpos__1_ != _endpos__1_ then\n _startpos__1_\n else\n if _startpos__2_ != _endpos__2_ then\n _startpos__2_\n else\n if _startpos__3_ != _endpos__3_ then\n _startpos__3_\n else\n _startpos__4_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 1970 \"parsing/parser.mly\"\n ( let e = mkexp_constraint ~loc:_sloc _7 _5 in\n (_4, _3, Cfk_concrete (_1, e)), _2\n )\n# 47064 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ty;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ty_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ty_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _5;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__5_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__5_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = ext;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_ext_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_ext_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined3 : (Parsetree.attributes) = Obj.magic _1_inlined3 in\n let ty : (Parsetree.core_type) = Obj.magic ty in\n let _5 : unit = Obj.magic _5 in\n let _1_inlined2 : (Asttypes.label) = Obj.magic _1_inlined2 in\n let _1_inlined1 : (Parsetree.attributes) = Obj.magic _1_inlined1 in\n let ext : (string Asttypes.loc option) = Obj.magic ext in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined3_ in\n let _v : (Parsetree.value_description * string Asttypes.loc option) = let attrs2 =\n let _1 = _1_inlined3 in\n \n# 3849 \"parsing/parser.mly\"\n ( _1 )\n# 47133 \"parsing/parser.ml\"\n \n in\n let _endpos_attrs2_ = _endpos__1_inlined3_ in\n let id =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 47145 \"parsing/parser.ml\"\n \n in\n let attrs1 =\n let _1 = _1_inlined1 in\n \n# 3853 \"parsing/parser.mly\"\n ( _1 )\n# 47153 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos_attrs2_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 2885 \"parsing/parser.mly\"\n ( let attrs = attrs1 @ attrs2 in\n let loc = make_loc _sloc in\n let docs = symbol_docs _sloc in\n Val.mk id ty ~attrs ~loc ~docs,\n ext )\n# 47166 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let _menhir_s = _menhir_env.CamlinternalMenhirLib.EngineTypes.current in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _endpos = _startpos in\n let _v : (Asttypes.virtual_flag) = \n# 3716 \"parsing/parser.mly\"\n ( Concrete )\n# 47184 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.virtual_flag) = \n# 3717 \"parsing/parser.mly\"\n ( Virtual )\n# 47209 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.mutable_flag) = \n# 3740 \"parsing/parser.mly\"\n ( Immutable )\n# 47234 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.mutable_flag) = \n# 3741 \"parsing/parser.mly\"\n ( Mutable )\n# 47266 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.mutable_flag) = \n# 3742 \"parsing/parser.mly\"\n ( Mutable )\n# 47298 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.private_flag) = \n# 3747 \"parsing/parser.mly\"\n ( Public )\n# 47323 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.private_flag) = \n# 3748 \"parsing/parser.mly\"\n ( Private )\n# 47355 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.private_flag) = \n# 3749 \"parsing/parser.mly\"\n ( Private )\n# 47387 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = xs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_xs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_xs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n };\n } = _menhir_stack in\n let xs : ((Parsetree.core_type * Parsetree.core_type * Ast_helper.loc) list) = Obj.magic xs in\n let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in\n let _4 : (Asttypes.private_flag) = Obj.magic _4 in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _2 : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_xs_ in\n let _v : (Parsetree.with_constraint) = let _6 =\n let _1 =\n let xs = \n# 253 \"\"\n ( List.rev xs )\n# 47449 \"parsing/parser.ml\"\n in\n \n# 971 \"parsing/parser.mly\"\n ( xs )\n# 47454 \"parsing/parser.ml\"\n \n in\n \n# 2985 \"parsing/parser.mly\"\n ( _1 )\n# 47460 \"parsing/parser.ml\"\n \n in\n let _endpos__6_ = _endpos_xs_ in\n let _5 =\n let _1 = _1_inlined2 in\n \n# 3307 \"parsing/parser.mly\"\n ( _1 )\n# 47469 \"parsing/parser.ml\"\n \n in\n let _3 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 47480 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__6_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3226 \"parsing/parser.mly\"\n ( let lident = loc_last _3 in\n Pwith_type\n (_3,\n (Type.mk lident\n ~params:_2\n ~cstrs:_6\n ~manifest:_5\n ~priv:_4\n ~loc:(make_loc _sloc))) )\n# 47497 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Parsetree.core_type) = Obj.magic _1_inlined2 in\n let _4 : unit = Obj.magic _4 in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _2 : ((Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list) = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.with_constraint) = let _5 =\n let _1 = _1_inlined2 in\n \n# 3307 \"parsing/parser.mly\"\n ( _1 )\n# 47552 \"parsing/parser.ml\"\n \n in\n let _endpos__5_ = _endpos__1_inlined2_ in\n let _3 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 47564 \"parsing/parser.ml\"\n \n in\n let _endpos = _endpos__5_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 3239 \"parsing/parser.mly\"\n ( let lident = loc_last _3 in\n Pwith_typesubst\n (_3,\n (Type.mk lident\n ~params:_2\n ~manifest:_5\n ~loc:(make_loc _sloc))) )\n# 47579 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in\n let _3 : unit = Obj.magic _3 in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.with_constraint) = let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 47630 \"parsing/parser.ml\"\n \n in\n let _2 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 47641 \"parsing/parser.ml\"\n \n in\n \n# 3247 \"parsing/parser.mly\"\n ( Pwith_module (_2, _4) )\n# 47647 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _3;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__3_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__3_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n } = _menhir_stack in\n let _1_inlined2 : (Longident.t) = Obj.magic _1_inlined2 in\n let _3 : unit = Obj.magic _3 in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_inlined2_ in\n let _v : (Parsetree.with_constraint) = let _4 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined2_, _startpos__1_inlined2_, _1_inlined2) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 47698 \"parsing/parser.ml\"\n \n in\n let _2 =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 47709 \"parsing/parser.ml\"\n \n in\n \n# 3249 \"parsing/parser.mly\"\n ( Pwith_modsubst (_2, _4) )\n# 47715 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = rhs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_rhs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_rhs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let rhs : (Parsetree.module_type) = Obj.magic rhs in\n let _4 : unit = Obj.magic _4 in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_rhs_ in\n let _v : (Parsetree.with_constraint) = let l =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 47773 \"parsing/parser.ml\"\n \n in\n \n# 3251 \"parsing/parser.mly\"\n ( Pwith_modtype (l, rhs) )\n# 47779 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = rhs;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos_rhs_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos_rhs_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _4;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__4_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__4_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _1_inlined1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_inlined1_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n };\n };\n };\n } = _menhir_stack in\n let rhs : (Parsetree.module_type) = Obj.magic rhs in\n let _4 : unit = Obj.magic _4 in\n let _1_inlined1 : (Longident.t) = Obj.magic _1_inlined1 in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos_rhs_ in\n let _v : (Parsetree.with_constraint) = let l =\n let (_endpos__1_, _startpos__1_, _1) = (_endpos__1_inlined1_, _startpos__1_inlined1_, _1_inlined1) in\n let _endpos = _endpos__1_ in\n let _symbolstartpos = _startpos__1_ in\n let _sloc = (_symbolstartpos, _endpos) in\n \n# 887 \"parsing/parser.mly\"\n ( mkrhs _1 _sloc )\n# 47837 \"parsing/parser.ml\"\n \n in\n \n# 3253 \"parsing/parser.mly\"\n ( Pwith_modtypesubst (l, rhs) )\n# 47843 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n } = _menhir_stack in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__1_ in\n let _v : (Asttypes.private_flag) = \n# 3256 \"parsing/parser.mly\"\n ( Public )\n# 47868 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n (fun _menhir_env ->\n let _menhir_stack = _menhir_env.CamlinternalMenhirLib.EngineTypes.stack in\n let {\n CamlinternalMenhirLib.EngineTypes.state = _;\n CamlinternalMenhirLib.EngineTypes.semv = _2;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__2_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__2_;\n CamlinternalMenhirLib.EngineTypes.next = {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = _1;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos__1_;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos__1_;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n };\n } = _menhir_stack in\n let _2 : unit = Obj.magic _2 in\n let _1 : unit = Obj.magic _1 in\n let _endpos__0_ = _menhir_stack.CamlinternalMenhirLib.EngineTypes.endp in\n let _startpos = _startpos__1_ in\n let _endpos = _endpos__2_ in\n let _v : (Asttypes.private_flag) = \n# 3257 \"parsing/parser.mly\"\n ( Private )\n# 47900 \"parsing/parser.ml\"\n in\n {\n CamlinternalMenhirLib.EngineTypes.state = _menhir_s;\n CamlinternalMenhirLib.EngineTypes.semv = Obj.repr _v;\n CamlinternalMenhirLib.EngineTypes.startp = _startpos;\n CamlinternalMenhirLib.EngineTypes.endp = _endpos;\n CamlinternalMenhirLib.EngineTypes.next = _menhir_stack;\n });\n |]\n \n and trace =\n None\n \nend\n\nmodule MenhirInterpreter = struct\n \n module ET = CamlinternalMenhirLib.TableInterpreter.MakeEngineTable (Tables)\n \n module TI = CamlinternalMenhirLib.Engine.Make (ET)\n \n include TI\n \nend\n\nlet use_file =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1846 lexer lexbuf) : (Parsetree.toplevel_phrase list))\n\nand toplevel_phrase =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1826 lexer lexbuf) : (Parsetree.toplevel_phrase))\n\nand parse_val_longident =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1820 lexer lexbuf) : (Longident.t))\n\nand parse_pattern =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1816 lexer lexbuf) : (Parsetree.pattern))\n\nand parse_mty_longident =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1812 lexer lexbuf) : (Longident.t))\n\nand parse_module_type =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1808 lexer lexbuf) : (Parsetree.module_type))\n\nand parse_module_expr =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1804 lexer lexbuf) : (Parsetree.module_expr))\n\nand parse_mod_longident =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1800 lexer lexbuf) : (Longident.t))\n\nand parse_mod_ext_longident =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1796 lexer lexbuf) : (Longident.t))\n\nand parse_expression =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1792 lexer lexbuf) : (Parsetree.expression))\n\nand parse_core_type =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1788 lexer lexbuf) : (Parsetree.core_type))\n\nand parse_constr_longident =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1784 lexer lexbuf) : (Longident.t))\n\nand parse_any_longident =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1766 lexer lexbuf) : (Longident.t))\n\nand interface =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 1762 lexer lexbuf) : (Parsetree.signature))\n\nand implementation =\n fun lexer lexbuf ->\n (Obj.magic (MenhirInterpreter.entry `Simplified 0 lexer lexbuf) : (Parsetree.structure))\n\nmodule Incremental = struct\n \n let use_file =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1846 initial_position) : (Parsetree.toplevel_phrase list) MenhirInterpreter.checkpoint)\n \n and toplevel_phrase =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1826 initial_position) : (Parsetree.toplevel_phrase) MenhirInterpreter.checkpoint)\n \n and parse_val_longident =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1820 initial_position) : (Longident.t) MenhirInterpreter.checkpoint)\n \n and parse_pattern =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1816 initial_position) : (Parsetree.pattern) MenhirInterpreter.checkpoint)\n \n and parse_mty_longident =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1812 initial_position) : (Longident.t) MenhirInterpreter.checkpoint)\n \n and parse_module_type =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1808 initial_position) : (Parsetree.module_type) MenhirInterpreter.checkpoint)\n \n and parse_module_expr =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1804 initial_position) : (Parsetree.module_expr) MenhirInterpreter.checkpoint)\n \n and parse_mod_longident =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1800 initial_position) : (Longident.t) MenhirInterpreter.checkpoint)\n \n and parse_mod_ext_longident =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1796 initial_position) : (Longident.t) MenhirInterpreter.checkpoint)\n \n and parse_expression =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1792 initial_position) : (Parsetree.expression) MenhirInterpreter.checkpoint)\n \n and parse_core_type =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1788 initial_position) : (Parsetree.core_type) MenhirInterpreter.checkpoint)\n \n and parse_constr_longident =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1784 initial_position) : (Longident.t) MenhirInterpreter.checkpoint)\n \n and parse_any_longident =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1766 initial_position) : (Longident.t) MenhirInterpreter.checkpoint)\n \n and interface =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 1762 initial_position) : (Parsetree.signature) MenhirInterpreter.checkpoint)\n \n and implementation =\n fun initial_position ->\n (Obj.magic (MenhirInterpreter.start 0 initial_position) : (Parsetree.structure) MenhirInterpreter.checkpoint)\n \nend\n\n# 3885 \"parsing/parser.mly\"\n \n\n# 48053 \"parsing/parser.ml\"\n\n# 269 \"\"\n \n\n# 48058 \"parsing/parser.ml\"\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 lexer definition *)\n\n{\nopen Lexing\nopen Misc\nopen Parser\n\ntype error =\n | Illegal_character of char\n | Illegal_escape of string * string option\n | Reserved_sequence of string * string option\n | Unterminated_comment of Location.t\n | Unterminated_string\n | Unterminated_string_in_comment of Location.t * Location.t\n | Empty_character_literal\n | Keyword_as_label of string\n | Invalid_literal of string\n | Invalid_directive of string * string option\n;;\n\nexception Error of error * Location.t;;\n\n(* The table of keywords *)\n\nlet keyword_table =\n create_hashtable 149 [\n \"and\", AND;\n \"as\", AS;\n \"assert\", ASSERT;\n \"begin\", BEGIN;\n \"class\", CLASS;\n \"constraint\", CONSTRAINT;\n \"do\", DO;\n \"done\", DONE;\n \"downto\", DOWNTO;\n \"else\", ELSE;\n \"end\", END;\n \"exception\", EXCEPTION;\n \"external\", EXTERNAL;\n \"false\", FALSE;\n \"for\", FOR;\n \"fun\", FUN;\n \"function\", FUNCTION;\n \"functor\", FUNCTOR;\n \"if\", IF;\n \"in\", IN;\n \"include\", INCLUDE;\n \"inherit\", INHERIT;\n \"initializer\", INITIALIZER;\n \"lazy\", LAZY;\n \"let\", LET;\n \"match\", MATCH;\n \"method\", METHOD;\n \"module\", MODULE;\n \"mutable\", MUTABLE;\n \"new\", NEW;\n \"nonrec\", NONREC;\n \"object\", OBJECT;\n \"of\", OF;\n \"open\", OPEN;\n \"or\", OR;\n(* \"parser\", PARSER; *)\n \"private\", PRIVATE;\n \"rec\", REC;\n \"sig\", SIG;\n \"struct\", STRUCT;\n \"then\", THEN;\n \"to\", TO;\n \"true\", TRUE;\n \"try\", TRY;\n \"type\", TYPE;\n \"val\", VAL;\n \"virtual\", VIRTUAL;\n \"when\", WHEN;\n \"while\", WHILE;\n \"with\", WITH;\n\n \"lor\", INFIXOP3(\"lor\"); (* Should be INFIXOP2 *)\n \"lxor\", INFIXOP3(\"lxor\"); (* Should be INFIXOP2 *)\n \"mod\", INFIXOP3(\"mod\");\n \"land\", INFIXOP3(\"land\");\n \"lsl\", INFIXOP4(\"lsl\");\n \"lsr\", INFIXOP4(\"lsr\");\n \"asr\", INFIXOP4(\"asr\")\n]\n\n(* To buffer string literals *)\n\nlet string_buffer = Buffer.create 256\nlet reset_string_buffer () = Buffer.reset string_buffer\nlet get_stored_string () = Buffer.contents string_buffer\n\nlet store_string_char c = Buffer.add_char string_buffer c\nlet store_string_utf_8_uchar u = Buffer.add_utf_8_uchar string_buffer u\nlet store_string s = Buffer.add_string string_buffer s\nlet store_lexeme lexbuf = store_string (Lexing.lexeme lexbuf)\n\n(* To store the position of the beginning of a string and comment *)\nlet string_start_loc = ref Location.none;;\nlet comment_start_loc = ref [];;\nlet in_comment () = !comment_start_loc <> [];;\nlet is_in_string = ref false\nlet in_string () = !is_in_string\nlet print_warnings = ref true\n\n(* Escaped chars are interpreted in strings unless they are in comments. *)\nlet store_escaped_char lexbuf c =\n if in_comment () then store_lexeme lexbuf else store_string_char c\n\nlet store_escaped_uchar lexbuf u =\n if in_comment () then store_lexeme lexbuf else store_string_utf_8_uchar u\n\nlet compute_quoted_string_idloc {Location.loc_start = orig_loc } shift id =\n let id_start_pos = orig_loc.Lexing.pos_cnum + shift in\n let loc_start =\n Lexing.{orig_loc with pos_cnum = id_start_pos }\n in\n let loc_end =\n Lexing.{orig_loc with pos_cnum = id_start_pos + String.length id}\n in\n {Location. loc_start ; loc_end ; loc_ghost = false }\n\nlet wrap_string_lexer f lexbuf =\n let loc_start = lexbuf.lex_curr_p in\n reset_string_buffer();\n is_in_string := true;\n let string_start = lexbuf.lex_start_p in\n string_start_loc := Location.curr lexbuf;\n let loc_end = f lexbuf in\n is_in_string := false;\n lexbuf.lex_start_p <- string_start;\n let loc = Location.{loc_ghost= false; loc_start; loc_end} in\n get_stored_string (), loc\n\nlet wrap_comment_lexer comment lexbuf =\n let start_loc = Location.curr lexbuf in\n comment_start_loc := [start_loc];\n reset_string_buffer ();\n let end_loc = comment lexbuf in\n let s = get_stored_string () in\n reset_string_buffer ();\n s,\n { start_loc with Location.loc_end = end_loc.Location.loc_end }\n\nlet error lexbuf e = raise (Error(e, Location.curr lexbuf))\nlet error_loc loc e = raise (Error(e, loc))\n\n(* to translate escape sequences *)\n\nlet digit_value c =\n match c with\n | 'a' .. 'f' -> 10 + Char.code c - Char.code 'a'\n | 'A' .. 'F' -> 10 + Char.code c - Char.code 'A'\n | '0' .. '9' -> Char.code c - Char.code '0'\n | _ -> assert false\n\nlet num_value lexbuf ~base ~first ~last =\n let c = ref 0 in\n for i = first to last do\n let v = digit_value (Lexing.lexeme_char lexbuf i) in\n assert(v < base);\n c := (base * !c) + v\n done;\n !c\n\nlet char_for_backslash = function\n | 'n' -> '\\010'\n | 'r' -> '\\013'\n | 'b' -> '\\008'\n | 't' -> '\\009'\n | c -> c\n\nlet illegal_escape lexbuf reason =\n let error = Illegal_escape (Lexing.lexeme lexbuf, Some reason) in\n raise (Error (error, Location.curr lexbuf))\n\nlet char_for_decimal_code lexbuf i =\n let c = num_value lexbuf ~base:10 ~first:i ~last:(i+2) in\n if (c < 0 || c > 255) then\n if in_comment ()\n then 'x'\n else\n illegal_escape lexbuf\n (Printf.sprintf\n \"%d is outside the range of legal characters (0-255).\" c)\n else Char.chr c\n\nlet char_for_octal_code lexbuf i =\n let c = num_value lexbuf ~base:8 ~first:i ~last:(i+2) in\n if (c < 0 || c > 255) then\n if in_comment ()\n then 'x'\n else\n illegal_escape lexbuf\n (Printf.sprintf\n \"o%o (=%d) is outside the range of legal characters (0-255).\" c c)\n else Char.chr c\n\nlet char_for_hexadecimal_code lexbuf i =\n Char.chr (num_value lexbuf ~base:16 ~first:i ~last:(i+1))\n\nlet uchar_for_uchar_escape lexbuf =\n let len = Lexing.lexeme_end lexbuf - Lexing.lexeme_start lexbuf in\n let first = 3 (* skip opening \\u{ *) in\n let last = len - 2 (* skip closing } *) in\n let digit_count = last - first + 1 in\n match digit_count > 6 with\n | true ->\n illegal_escape lexbuf\n \"too many digits, expected 1 to 6 hexadecimal digits\"\n | false ->\n let cp = num_value lexbuf ~base:16 ~first ~last in\n if Uchar.is_valid cp then Uchar.unsafe_of_int cp else\n illegal_escape lexbuf\n (Printf.sprintf \"%X is not a Unicode scalar value\" cp)\n\nlet is_keyword name = Hashtbl.mem keyword_table name\n\nlet check_label_name lexbuf name =\n if is_keyword name then error lexbuf (Keyword_as_label name)\n\n(* Update the current location with file name and line number. *)\n\nlet update_loc lexbuf file line absolute chars =\n let pos = lexbuf.lex_curr_p in\n let new_file = match file with\n | None -> pos.pos_fname\n | Some s -> s\n in\n lexbuf.lex_curr_p <- { pos with\n pos_fname = new_file;\n pos_lnum = if absolute then line else pos.pos_lnum + line;\n pos_bol = pos.pos_cnum - chars;\n }\n;;\n\nlet preprocessor = ref None\n\nlet escaped_newlines = ref false\n\n(* Warn about Latin-1 characters used in idents *)\n\nlet warn_latin1 lexbuf =\n Location.deprecated\n (Location.curr lexbuf)\n \"ISO-Latin1 characters in identifiers\"\n\nlet handle_docstrings = ref true\nlet comment_list = ref []\n\nlet add_comment com =\n comment_list := com :: !comment_list\n\nlet add_docstring_comment ds =\n let com =\n (\"*\" ^ Docstrings.docstring_body ds, Docstrings.docstring_loc ds)\n in\n add_comment com\n\nlet comments () = List.rev !comment_list\n\n(* Error report *)\n\nopen Format\n\nlet prepare_error loc = function\n | Illegal_character c ->\n Location.errorf ~loc \"Illegal character (%s)\" (Char.escaped c)\n | Illegal_escape (s, explanation) ->\n Location.errorf ~loc\n \"Illegal backslash escape in string or character (%s)%t\" s\n (fun ppf -> match explanation with\n | None -> ()\n | Some expl -> fprintf ppf \": %s\" expl)\n | Reserved_sequence (s, explanation) ->\n Location.errorf ~loc\n \"Reserved character sequence: %s%t\" s\n (fun ppf -> match explanation with\n | None -> ()\n | Some expl -> fprintf ppf \" %s\" expl)\n | Unterminated_comment _ ->\n Location.errorf ~loc \"Comment not terminated\"\n | Unterminated_string ->\n Location.errorf ~loc \"String literal not terminated\"\n | Unterminated_string_in_comment (_, literal_loc) ->\n Location.errorf ~loc\n \"This comment contains an unterminated string literal\"\n ~sub:[Location.msg ~loc:literal_loc \"String literal begins here\"]\n | Empty_character_literal ->\n let msg = \"Illegal empty character literal ''\" in\n let sub =\n [Location.msg\n \"Hint: Did you mean ' ' or a type variable 'a?\"] in\n Location.error ~loc ~sub msg\n | Keyword_as_label kwd ->\n Location.errorf ~loc\n \"`%s' is a keyword, it cannot be used as label name\" kwd\n | Invalid_literal s ->\n Location.errorf ~loc \"Invalid literal %s\" s\n | Invalid_directive (dir, explanation) ->\n Location.errorf ~loc \"Invalid lexer directive %S%t\" dir\n (fun ppf -> match explanation with\n | None -> ()\n | Some expl -> fprintf ppf \": %s\" expl)\n\nlet () =\n Location.register_error_of_exn\n (function\n | Error (err, loc) ->\n Some (prepare_error loc err)\n | _ ->\n None\n )\n\n}\n\nlet newline = ('\\013'* '\\010')\nlet blank = [' ' '\\009' '\\012']\nlet lowercase = ['a'-'z' '_']\nlet uppercase = ['A'-'Z']\nlet identchar = ['A'-'Z' 'a'-'z' '_' '\\'' '0'-'9']\nlet lowercase_latin1 = ['a'-'z' '\\223'-'\\246' '\\248'-'\\255' '_']\nlet uppercase_latin1 = ['A'-'Z' '\\192'-'\\214' '\\216'-'\\222']\nlet identchar_latin1 =\n ['A'-'Z' 'a'-'z' '_' '\\192'-'\\214' '\\216'-'\\246' '\\248'-'\\255' '\\'' '0'-'9']\n(* This should be kept in sync with the [is_identchar] function in [env.ml] *)\n\nlet symbolchar =\n ['!' '$' '%' '&' '*' '+' '-' '.' '/' ':' '<' '=' '>' '?' '@' '^' '|' '~']\nlet dotsymbolchar =\n ['!' '$' '%' '&' '*' '+' '-' '/' ':' '=' '>' '?' '@' '^' '|']\nlet symbolchar_or_hash =\n symbolchar | '#'\nlet kwdopchar =\n ['$' '&' '*' '+' '-' '/' '<' '=' '>' '@' '^' '|']\n\nlet ident = (lowercase | uppercase) identchar*\nlet extattrident = ident ('.' ident)*\n\nlet decimal_literal =\n ['0'-'9'] ['0'-'9' '_']*\nlet hex_digit =\n ['0'-'9' 'A'-'F' 'a'-'f']\nlet hex_literal =\n '0' ['x' 'X'] ['0'-'9' 'A'-'F' 'a'-'f']['0'-'9' 'A'-'F' 'a'-'f' '_']*\nlet oct_literal =\n '0' ['o' 'O'] ['0'-'7'] ['0'-'7' '_']*\nlet bin_literal =\n '0' ['b' 'B'] ['0'-'1'] ['0'-'1' '_']*\nlet int_literal =\n decimal_literal | hex_literal | oct_literal | bin_literal\nlet float_literal =\n ['0'-'9'] ['0'-'9' '_']*\n ('.' ['0'-'9' '_']* )?\n (['e' 'E'] ['+' '-']? ['0'-'9'] ['0'-'9' '_']* )?\nlet hex_float_literal =\n '0' ['x' 'X']\n ['0'-'9' 'A'-'F' 'a'-'f'] ['0'-'9' 'A'-'F' 'a'-'f' '_']*\n ('.' ['0'-'9' 'A'-'F' 'a'-'f' '_']* )?\n (['p' 'P'] ['+' '-']? ['0'-'9'] ['0'-'9' '_']* )?\nlet literal_modifier = ['G'-'Z' 'g'-'z']\n\nrule token = parse\n | ('\\\\' as bs) newline {\n if not !escaped_newlines then error lexbuf (Illegal_character bs);\n update_loc lexbuf None 1 false 0;\n token lexbuf }\n | newline\n { update_loc lexbuf None 1 false 0;\n EOL }\n | blank +\n { token lexbuf }\n | \"_\"\n { UNDERSCORE }\n | \"~\"\n { TILDE }\n | \".~\"\n { error lexbuf\n (Reserved_sequence (\".~\", Some \"is reserved for use in MetaOCaml\")) }\n | \"~\" (lowercase identchar * as name) ':'\n { check_label_name lexbuf name;\n LABEL name }\n | \"~\" (lowercase_latin1 identchar_latin1 * as name) ':'\n { warn_latin1 lexbuf;\n LABEL name }\n | \"?\"\n { QUESTION }\n | \"?\" (lowercase identchar * as name) ':'\n { check_label_name lexbuf name;\n OPTLABEL name }\n | \"?\" (lowercase_latin1 identchar_latin1 * as name) ':'\n { warn_latin1 lexbuf;\n OPTLABEL name }\n | lowercase identchar * as name\n { try Hashtbl.find keyword_table name\n with Not_found -> LIDENT name }\n | lowercase_latin1 identchar_latin1 * as name\n { warn_latin1 lexbuf; LIDENT name }\n | uppercase identchar * as name\n { UIDENT name } (* No capitalized keywords *)\n | uppercase_latin1 identchar_latin1 * as name\n { warn_latin1 lexbuf; UIDENT name }\n | int_literal as lit { INT (lit, None) }\n | (int_literal as lit) (literal_modifier as modif)\n { INT (lit, Some modif) }\n | float_literal | hex_float_literal as lit\n { FLOAT (lit, None) }\n | (float_literal | hex_float_literal as lit) (literal_modifier as modif)\n { FLOAT (lit, Some modif) }\n | (float_literal | hex_float_literal | int_literal) identchar+ as invalid\n { error lexbuf (Invalid_literal invalid) }\n | \"\\\"\"\n { let s, loc = wrap_string_lexer string lexbuf in\n STRING (s, loc, None) }\n | \"{\" (lowercase* as delim) \"|\"\n { let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in\n STRING (s, loc, Some delim) }\n | \"{%\" (extattrident as id) \"|\"\n { let orig_loc = Location.curr lexbuf in\n let s, loc = wrap_string_lexer (quoted_string \"\") lexbuf in\n let idloc = compute_quoted_string_idloc orig_loc 2 id in\n QUOTED_STRING_EXPR (id, idloc, s, loc, Some \"\") }\n | \"{%\" (extattrident as id) blank+ (lowercase* as delim) \"|\"\n { let orig_loc = Location.curr lexbuf in\n let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in\n let idloc = compute_quoted_string_idloc orig_loc 2 id in\n QUOTED_STRING_EXPR (id, idloc, s, loc, Some delim) }\n | \"{%%\" (extattrident as id) \"|\"\n { let orig_loc = Location.curr lexbuf in\n let s, loc = wrap_string_lexer (quoted_string \"\") lexbuf in\n let idloc = compute_quoted_string_idloc orig_loc 3 id in\n QUOTED_STRING_ITEM (id, idloc, s, loc, Some \"\") }\n | \"{%%\" (extattrident as id) blank+ (lowercase* as delim) \"|\"\n { let orig_loc = Location.curr lexbuf in\n let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in\n let idloc = compute_quoted_string_idloc orig_loc 3 id in\n QUOTED_STRING_ITEM (id, idloc, s, loc, Some delim) }\n | \"\\'\" newline \"\\'\"\n { update_loc lexbuf None 1 false 1;\n (* newline is ('\\013'* '\\010') *)\n CHAR '\\n' }\n | \"\\'\" ([^ '\\\\' '\\'' '\\010' '\\013'] as c) \"\\'\"\n { CHAR c }\n | \"\\'\\\\\" (['\\\\' '\\'' '\\\"' 'n' 't' 'b' 'r' ' '] as c) \"\\'\"\n { CHAR (char_for_backslash c) }\n | \"\\'\\\\\" ['0'-'9'] ['0'-'9'] ['0'-'9'] \"\\'\"\n { CHAR(char_for_decimal_code lexbuf 2) }\n | \"\\'\\\\\" 'o' ['0'-'7'] ['0'-'7'] ['0'-'7'] \"\\'\"\n { CHAR(char_for_octal_code lexbuf 3) }\n | \"\\'\\\\\" 'x' ['0'-'9' 'a'-'f' 'A'-'F'] ['0'-'9' 'a'-'f' 'A'-'F'] \"\\'\"\n { CHAR(char_for_hexadecimal_code lexbuf 3) }\n | \"\\'\" (\"\\\\\" _ as esc)\n { error lexbuf (Illegal_escape (esc, None)) }\n | \"\\'\\'\"\n { error lexbuf Empty_character_literal }\n | \"(*\"\n { let s, loc = wrap_comment_lexer comment lexbuf in\n COMMENT (s, loc) }\n | \"(**\"\n { let s, loc = wrap_comment_lexer comment lexbuf in\n if !handle_docstrings then\n DOCSTRING (Docstrings.docstring s loc)\n else\n COMMENT (\"*\" ^ s, loc)\n }\n | \"(**\" (('*'+) as stars)\n { let s, loc =\n wrap_comment_lexer\n (fun lexbuf ->\n store_string (\"*\" ^ stars);\n comment lexbuf)\n lexbuf\n in\n COMMENT (s, loc) }\n | \"(*)\"\n { if !print_warnings then\n Location.prerr_warning (Location.curr lexbuf) Warnings.Comment_start;\n let s, loc = wrap_comment_lexer comment lexbuf in\n COMMENT (s, loc) }\n | \"(*\" (('*'*) as stars) \"*)\"\n { if !handle_docstrings && stars=\"\" then\n (* (**) is an empty docstring *)\n DOCSTRING(Docstrings.docstring \"\" (Location.curr lexbuf))\n else\n COMMENT (stars, Location.curr lexbuf) }\n | \"*)\"\n { let loc = Location.curr lexbuf in\n Location.prerr_warning loc Warnings.Comment_not_end;\n lexbuf.Lexing.lex_curr_pos <- lexbuf.Lexing.lex_curr_pos - 1;\n let curpos = lexbuf.lex_curr_p in\n lexbuf.lex_curr_p <- { curpos with pos_cnum = curpos.pos_cnum - 1 };\n STAR\n }\n | \"#\"\n { let at_beginning_of_line pos = (pos.pos_cnum = pos.pos_bol) in\n if not (at_beginning_of_line lexbuf.lex_start_p)\n then HASH\n else try directive lexbuf with Failure _ -> HASH\n }\n | \"&\" { AMPERSAND }\n | \"&&\" { AMPERAMPER }\n | \"`\" { BACKQUOTE }\n | \"\\'\" { QUOTE }\n | \"(\" { LPAREN }\n | \")\" { RPAREN }\n | \"*\" { STAR }\n | \",\" { COMMA }\n | \"->\" { MINUSGREATER }\n | \".\" { DOT }\n | \"..\" { DOTDOT }\n | \".\" (dotsymbolchar symbolchar* as op) { DOTOP op }\n | \":\" { COLON }\n | \"::\" { COLONCOLON }\n | \":=\" { COLONEQUAL }\n | \":>\" { COLONGREATER }\n | \";\" { SEMI }\n | \";;\" { SEMISEMI }\n | \"<\" { LESS }\n | \"<-\" { LESSMINUS }\n | \"=\" { EQUAL }\n | \"[\" { LBRACKET }\n | \"[|\" { LBRACKETBAR }\n | \"[<\" { LBRACKETLESS }\n | \"[>\" { LBRACKETGREATER }\n | \"]\" { RBRACKET }\n | \"{\" { LBRACE }\n | \"{<\" { LBRACELESS }\n | \"|\" { BAR }\n | \"||\" { BARBAR }\n | \"|]\" { BARRBRACKET }\n | \">\" { GREATER }\n | \">]\" { GREATERRBRACKET }\n | \"}\" { RBRACE }\n | \">}\" { GREATERRBRACE }\n | \"[@\" { LBRACKETAT }\n | \"[@@\" { LBRACKETATAT }\n | \"[@@@\" { LBRACKETATATAT }\n | \"[%\" { LBRACKETPERCENT }\n | \"[%%\" { LBRACKETPERCENTPERCENT }\n | \"!\" { BANG }\n | \"!=\" { INFIXOP0 \"!=\" }\n | \"+\" { PLUS }\n | \"+.\" { PLUSDOT }\n | \"+=\" { PLUSEQ }\n | \"-\" { MINUS }\n | \"-.\" { MINUSDOT }\n\n | \"!\" symbolchar_or_hash + as op\n { PREFIXOP op }\n | ['~' '?'] symbolchar_or_hash + as op\n { PREFIXOP op }\n | ['=' '<' '>' '|' '&' '$'] symbolchar * as op\n { INFIXOP0 op }\n | ['@' '^'] symbolchar * as op\n { INFIXOP1 op }\n | ['+' '-'] symbolchar * as op\n { INFIXOP2 op }\n | \"**\" symbolchar * as op\n { INFIXOP4 op }\n | '%' { PERCENT }\n | ['*' '/' '%'] symbolchar * as op\n { INFIXOP3 op }\n | '#' symbolchar_or_hash + as op\n { HASHOP op }\n | \"let\" kwdopchar dotsymbolchar * as op\n { LETOP op }\n | \"and\" kwdopchar dotsymbolchar * as op\n { ANDOP op }\n | eof { EOF }\n | (_ as illegal_char)\n { error lexbuf (Illegal_character illegal_char) }\n\nand directive = parse\n | ([' ' '\\t']* (['0'-'9']+ as num) [' ' '\\t']*\n (\"\\\"\" ([^ '\\010' '\\013' '\\\"' ] * as name) \"\\\"\") as directive)\n [^ '\\010' '\\013'] *\n {\n match int_of_string num with\n | exception _ ->\n (* PR#7165 *)\n let explanation = \"line number out of range\" in\n error lexbuf (Invalid_directive (\"#\" ^ directive, Some explanation))\n | line_num ->\n (* Documentation says that the line number should be\n positive, but we have never guarded against this and it\n might have useful hackish uses. *)\n update_loc lexbuf (Some name) (line_num - 1) true 0;\n token lexbuf\n }\nand comment = parse\n \"(*\"\n { comment_start_loc := (Location.curr lexbuf) :: !comment_start_loc;\n store_lexeme lexbuf;\n comment lexbuf\n }\n | \"*)\"\n { match !comment_start_loc with\n | [] -> assert false\n | [_] -> comment_start_loc := []; Location.curr lexbuf\n | _ :: l -> comment_start_loc := l;\n store_lexeme lexbuf;\n comment lexbuf\n }\n | \"\\\"\"\n {\n string_start_loc := Location.curr lexbuf;\n store_string_char '\\\"';\n is_in_string := true;\n let _loc = try string lexbuf\n with Error (Unterminated_string, str_start) ->\n match !comment_start_loc with\n | [] -> assert false\n | loc :: _ ->\n let start = List.hd (List.rev !comment_start_loc) in\n comment_start_loc := [];\n error_loc loc (Unterminated_string_in_comment (start, str_start))\n in\n is_in_string := false;\n store_string_char '\\\"';\n comment lexbuf }\n | \"{\" ('%' '%'? extattrident blank*)? (lowercase* as delim) \"|\"\n {\n string_start_loc := Location.curr lexbuf;\n store_lexeme lexbuf;\n is_in_string := true;\n let _loc = try quoted_string delim lexbuf\n with Error (Unterminated_string, str_start) ->\n match !comment_start_loc with\n | [] -> assert false\n | loc :: _ ->\n let start = List.hd (List.rev !comment_start_loc) in\n comment_start_loc := [];\n error_loc loc (Unterminated_string_in_comment (start, str_start))\n in\n is_in_string := false;\n store_string_char '|';\n store_string delim;\n store_string_char '}';\n comment lexbuf }\n | \"\\'\\'\"\n { store_lexeme lexbuf; comment lexbuf }\n | \"\\'\" newline \"\\'\"\n { update_loc lexbuf None 1 false 1;\n store_lexeme lexbuf;\n comment lexbuf\n }\n | \"\\'\" [^ '\\\\' '\\'' '\\010' '\\013' ] \"\\'\"\n { store_lexeme lexbuf; comment lexbuf }\n | \"\\'\\\\\" ['\\\\' '\\\"' '\\'' 'n' 't' 'b' 'r' ' '] \"\\'\"\n { store_lexeme lexbuf; comment lexbuf }\n | \"\\'\\\\\" ['0'-'9'] ['0'-'9'] ['0'-'9'] \"\\'\"\n { store_lexeme lexbuf; comment lexbuf }\n | \"\\'\\\\\" 'o' ['0'-'3'] ['0'-'7'] ['0'-'7'] \"\\'\"\n { store_lexeme lexbuf; comment lexbuf }\n | \"\\'\\\\\" 'x' ['0'-'9' 'a'-'f' 'A'-'F'] ['0'-'9' 'a'-'f' 'A'-'F'] \"\\'\"\n { store_lexeme lexbuf; comment lexbuf }\n | eof\n { match !comment_start_loc with\n | [] -> assert false\n | loc :: _ ->\n let start = List.hd (List.rev !comment_start_loc) in\n comment_start_loc := [];\n error_loc loc (Unterminated_comment start)\n }\n | newline\n { update_loc lexbuf None 1 false 0;\n store_lexeme lexbuf;\n comment lexbuf\n }\n | ident\n { store_lexeme lexbuf; comment lexbuf }\n | _\n { store_lexeme lexbuf; comment lexbuf }\n\nand string = parse\n '\\\"'\n { lexbuf.lex_start_p }\n | '\\\\' newline ([' ' '\\t'] * as space)\n { update_loc lexbuf None 1 false (String.length space);\n if in_comment () then store_lexeme lexbuf;\n string lexbuf\n }\n | '\\\\' (['\\\\' '\\'' '\\\"' 'n' 't' 'b' 'r' ' '] as c)\n { store_escaped_char lexbuf (char_for_backslash c);\n string lexbuf }\n | '\\\\' ['0'-'9'] ['0'-'9'] ['0'-'9']\n { store_escaped_char lexbuf (char_for_decimal_code lexbuf 1);\n string lexbuf }\n | '\\\\' 'o' ['0'-'7'] ['0'-'7'] ['0'-'7']\n { store_escaped_char lexbuf (char_for_octal_code lexbuf 2);\n string lexbuf }\n | '\\\\' 'x' ['0'-'9' 'a'-'f' 'A'-'F'] ['0'-'9' 'a'-'f' 'A'-'F']\n { store_escaped_char lexbuf (char_for_hexadecimal_code lexbuf 2);\n string lexbuf }\n | '\\\\' 'u' '{' hex_digit+ '}'\n { store_escaped_uchar lexbuf (uchar_for_uchar_escape lexbuf);\n string lexbuf }\n | '\\\\' _\n { if not (in_comment ()) then begin\n(* Should be an error, but we are very lax.\n error lexbuf (Illegal_escape (Lexing.lexeme lexbuf, None))\n*)\n let loc = Location.curr lexbuf in\n Location.prerr_warning loc Warnings.Illegal_backslash;\n end;\n store_lexeme lexbuf;\n string lexbuf\n }\n | newline\n { if not (in_comment ()) then\n Location.prerr_warning (Location.curr lexbuf) Warnings.Eol_in_string;\n update_loc lexbuf None 1 false 0;\n store_lexeme lexbuf;\n string lexbuf\n }\n | eof\n { is_in_string := false;\n error_loc !string_start_loc Unterminated_string }\n | (_ as c)\n { store_string_char c;\n string lexbuf }\n\nand quoted_string delim = parse\n | newline\n { update_loc lexbuf None 1 false 0;\n store_lexeme lexbuf;\n quoted_string delim lexbuf\n }\n | eof\n { is_in_string := false;\n error_loc !string_start_loc Unterminated_string }\n | \"|\" (lowercase* as edelim) \"}\"\n {\n if delim = edelim then lexbuf.lex_start_p\n else (store_lexeme lexbuf; quoted_string delim lexbuf)\n }\n | (_ as c)\n { store_string_char c;\n quoted_string delim lexbuf }\n\nand skip_hash_bang = parse\n | \"#!\" [^ '\\n']* '\\n' [^ '\\n']* \"\\n!#\\n\"\n { update_loc lexbuf None 3 false 0 }\n | \"#!\" [^ '\\n']* '\\n'\n { update_loc lexbuf None 1 false 0 }\n | \"\" { () }\n\n{\n\n let token_with_comments lexbuf =\n match !preprocessor with\n | None -> token lexbuf\n | Some (_init, preprocess) -> preprocess token lexbuf\n\n type newline_state =\n | NoLine (* There have been no blank lines yet. *)\n | NewLine\n (* There have been no blank lines, and the previous\n token was a newline. *)\n | BlankLine (* There have been blank lines. *)\n\n type doc_state =\n | Initial (* There have been no docstrings yet *)\n | After of docstring list\n (* There have been docstrings, none of which were\n preceded by a blank line *)\n | Before of docstring list * docstring list * docstring list\n (* There have been docstrings, some of which were\n preceded by a blank line *)\n\n and docstring = Docstrings.docstring\n\n let token lexbuf =\n let post_pos = lexeme_end_p lexbuf in\n let attach lines docs pre_pos =\n let open Docstrings in\n match docs, lines with\n | Initial, _ -> ()\n | After a, (NoLine | NewLine) ->\n set_post_docstrings post_pos (List.rev a);\n set_pre_docstrings pre_pos a;\n | After a, BlankLine ->\n set_post_docstrings post_pos (List.rev a);\n set_pre_extra_docstrings pre_pos (List.rev a)\n | Before(a, f, b), (NoLine | NewLine) ->\n set_post_docstrings post_pos (List.rev a);\n set_post_extra_docstrings post_pos\n (List.rev_append f (List.rev b));\n set_floating_docstrings pre_pos (List.rev f);\n set_pre_extra_docstrings pre_pos (List.rev a);\n set_pre_docstrings pre_pos b\n | Before(a, f, b), BlankLine ->\n set_post_docstrings post_pos (List.rev a);\n set_post_extra_docstrings post_pos\n (List.rev_append f (List.rev b));\n set_floating_docstrings pre_pos\n (List.rev_append f (List.rev b));\n set_pre_extra_docstrings pre_pos (List.rev a)\n in\n let rec loop lines docs lexbuf =\n match token_with_comments lexbuf with\n | COMMENT (s, loc) ->\n add_comment (s, loc);\n let lines' =\n match lines with\n | NoLine -> NoLine\n | NewLine -> NoLine\n | BlankLine -> BlankLine\n in\n loop lines' docs lexbuf\n | EOL ->\n let lines' =\n match lines with\n | NoLine -> NewLine\n | NewLine -> BlankLine\n | BlankLine -> BlankLine\n in\n loop lines' docs lexbuf\n | DOCSTRING doc ->\n Docstrings.register doc;\n add_docstring_comment doc;\n let docs' =\n if Docstrings.docstring_body doc = \"/*\" then\n match docs with\n | Initial -> Before([], [doc], [])\n | After a -> Before (a, [doc], [])\n | Before(a, f, b) -> Before(a, doc :: b @ f, [])\n else\n match docs, lines with\n | Initial, (NoLine | NewLine) -> After [doc]\n | Initial, BlankLine -> Before([], [], [doc])\n | After a, (NoLine | NewLine) -> After (doc :: a)\n | After a, BlankLine -> Before (a, [], [doc])\n | Before(a, f, b), (NoLine | NewLine) -> Before(a, f, doc :: b)\n | Before(a, f, b), BlankLine -> Before(a, b @ f, [doc])\n in\n loop NoLine docs' lexbuf\n | tok ->\n attach lines docs (lexeme_start_p lexbuf);\n tok\n in\n loop NoLine Initial lexbuf\n\n let init () =\n is_in_string := false;\n comment_start_loc := [];\n comment_list := [];\n match !preprocessor with\n | None -> ()\n | Some (init, _preprocess) -> init ()\n\n let set_preprocessor init preprocess =\n escaped_newlines := true;\n preprocessor := Some (init, preprocess)\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\nopen Lexing\n\ntype t = Warnings.loc =\n { loc_start: position; loc_end: position; loc_ghost: bool };;\n\nlet in_file name =\n let loc = { dummy_pos with pos_fname = name } in\n { loc_start = loc; loc_end = loc; loc_ghost = true }\n;;\n\nlet none = in_file \"_none_\";;\nlet is_none l = (l = none);;\n\nlet curr lexbuf = {\n loc_start = lexbuf.lex_start_p;\n loc_end = lexbuf.lex_curr_p;\n loc_ghost = false\n};;\n\nlet init lexbuf fname =\n lexbuf.lex_curr_p <- {\n pos_fname = fname;\n pos_lnum = 1;\n pos_bol = 0;\n pos_cnum = 0;\n }\n;;\n\nlet symbol_rloc () = {\n loc_start = Parsing.symbol_start_pos ();\n loc_end = Parsing.symbol_end_pos ();\n loc_ghost = false;\n};;\n\nlet symbol_gloc () = {\n loc_start = Parsing.symbol_start_pos ();\n loc_end = Parsing.symbol_end_pos ();\n loc_ghost = true;\n};;\n\nlet rhs_loc n = {\n loc_start = Parsing.rhs_start_pos n;\n loc_end = Parsing.rhs_end_pos n;\n loc_ghost = false;\n};;\n\nlet rhs_interval m n = {\n loc_start = Parsing.rhs_start_pos m;\n loc_end = Parsing.rhs_end_pos n;\n loc_ghost = false;\n};;\n\n(* return file, line, char from the given position *)\nlet get_pos_info pos =\n (pos.pos_fname, pos.pos_lnum, pos.pos_cnum - pos.pos_bol)\n;;\n\ntype 'a loc = {\n txt : 'a;\n loc : t;\n}\n\nlet mkloc txt loc = { txt ; loc }\nlet mknoloc txt = mkloc txt none\n\n(******************************************************************************)\n(* Input info *)\n\nlet input_name = ref \"_none_\"\nlet input_lexbuf = ref (None : lexbuf option)\nlet input_phrase_buffer = ref (None : Buffer.t option)\n\n(******************************************************************************)\n(* Terminal info *)\n\nlet status = ref Terminfo.Uninitialised\n\nlet setup_terminal () =\n if !status = Terminfo.Uninitialised then\n status := Terminfo.setup stdout\n\n(* The number of lines already printed after input.\n\n This is used by [highlight_terminfo] to identify the current position of the\n input in the terminal. This would not be possible without this information,\n since printing several warnings/errors adds text between the user input and\n the bottom of the terminal.\n*)\nlet num_loc_lines = ref 0\n\n(* This is used by the toplevel to reset [num_loc_lines] before each phrase *)\nlet reset () =\n num_loc_lines := 0\n\n(* This is used by the toplevel *)\nlet echo_eof () =\n print_newline ();\n incr num_loc_lines\n\n(* Code printing errors and warnings must be wrapped using this function, in\n order to update [num_loc_lines].\n\n [print_updating_num_loc_lines ppf f arg] is equivalent to calling [f ppf\n arg], and additionally updates [num_loc_lines]. *)\nlet print_updating_num_loc_lines ppf f arg =\n let open Format in\n let out_functions = pp_get_formatter_out_functions ppf () in\n let out_string str start len =\n let rec count i c =\n if i = start + len then c\n else if String.get str i = '\\n' then count (succ i) (succ c)\n else count (succ i) c in\n num_loc_lines := !num_loc_lines + count start 0 ;\n out_functions.out_string str start len in\n pp_set_formatter_out_functions ppf\n { out_functions with out_string } ;\n f ppf arg ;\n pp_print_flush ppf ();\n pp_set_formatter_out_functions ppf out_functions\n\nlet setup_colors () =\n Misc.Color.setup !Clflags.color\n\n(******************************************************************************)\n(* Printing locations, e.g. 'File \"foo.ml\", line 3, characters 10-12' *)\n\nlet rewrite_absolute_path path =\n match Misc.get_build_path_prefix_map () with\n | None -> path\n | Some map -> Build_path_prefix_map.rewrite map path\n\nlet absolute_path s = (* This function could go into Filename *)\n let open Filename in\n let s =\n if not (is_relative s) then s\n else (rewrite_absolute_path (concat (Sys.getcwd ()) s))\n in\n (* Now simplify . and .. components *)\n let rec aux s =\n let base = basename s in\n let dir = dirname s in\n if dir = s then dir\n else if base = current_dir_name then aux dir\n else if base = parent_dir_name then dirname (aux dir)\n else concat (aux dir) base\n in\n aux s\n\nlet show_filename file =\n if !Clflags.absname then absolute_path file else file\n\nlet print_filename ppf file =\n Format.pp_print_string ppf (show_filename file)\n\n(* Best-effort printing of the text describing a location, of the form\n 'File \"foo.ml\", line 3, characters 10-12'.\n\n Some of the information (filename, line number or characters numbers) in the\n location might be invalid; in which case we do not print it.\n *)\nlet print_loc ppf loc =\n setup_colors ();\n let file_valid = function\n | \"_none_\" ->\n (* This is a dummy placeholder, but we print it anyway to please editors\n that parse locations in error messages (e.g. Emacs). *)\n true\n | \"\" | \"//toplevel//\" -> false\n | _ -> true\n in\n let line_valid line = line > 0 in\n let chars_valid ~startchar ~endchar = startchar <> -1 && endchar <> -1 in\n\n let file =\n (* According to the comment in location.mli, if [pos_fname] is \"\", we must\n use [!input_name]. *)\n if loc.loc_start.pos_fname = \"\" then !input_name\n else loc.loc_start.pos_fname\n in\n let startline = loc.loc_start.pos_lnum in\n let endline = loc.loc_end.pos_lnum in\n let startchar = loc.loc_start.pos_cnum - loc.loc_start.pos_bol in\n let endchar = loc.loc_end.pos_cnum - loc.loc_end.pos_bol in\n\n let first = ref true in\n let capitalize s =\n if !first then (first := false; String.capitalize_ascii s)\n else s in\n let comma () =\n if !first then () else Format.fprintf ppf \", \" in\n\n Format.fprintf ppf \"@{\";\n\n if file_valid file then\n Format.fprintf ppf \"%s \\\"%a\\\"\" (capitalize \"file\") print_filename file;\n\n (* Print \"line 1\" in the case of a dummy line number. This is to please the\n existing setup of editors that parse locations in error messages (e.g.\n Emacs). *)\n comma ();\n let startline = if line_valid startline then startline else 1 in\n let endline = if line_valid endline then endline else startline in\n begin if startline = endline then\n Format.fprintf ppf \"%s %i\" (capitalize \"line\") startline\n else\n Format.fprintf ppf \"%s %i-%i\" (capitalize \"lines\") startline endline\n end;\n\n if chars_valid ~startchar ~endchar then (\n comma ();\n Format.fprintf ppf \"%s %i-%i\" (capitalize \"characters\") startchar endchar\n );\n\n Format.fprintf ppf \"@}\"\n\n(* Print a comma-separated list of locations *)\nlet print_locs ppf locs =\n Format.pp_print_list ~pp_sep:(fun ppf () -> Format.fprintf ppf \",@ \")\n print_loc ppf locs\n\n(******************************************************************************)\n(* An interval set structure; additionally, it stores user-provided information\n at interval boundaries.\n\n The implementation provided here is naive and assumes the number of intervals\n to be small, but the interface would allow for a more efficient\n implementation if needed.\n\n Note: the structure only stores maximal intervals (that therefore do not\n overlap).\n*)\n\nmodule ISet : sig\n type 'a bound = 'a * int\n type 'a t\n (* bounds are included *)\n val of_intervals : ('a bound * 'a bound) list -> 'a t\n\n val mem : 'a t -> pos:int -> bool\n val find_bound_in : 'a t -> range:(int * int) -> 'a bound option\n\n val is_start : 'a t -> pos:int -> 'a option\n val is_end : 'a t -> pos:int -> 'a option\n\n val extrema : 'a t -> ('a bound * 'a bound) option\nend\n=\nstruct\n type 'a bound = 'a * int\n\n (* non overlapping intervals *)\n type 'a t = ('a bound * 'a bound) list\n\n let of_intervals intervals =\n let pos =\n List.map (fun ((a, x), (b, y)) ->\n if x > y then [] else [((a, x), `S); ((b, y), `E)]\n ) intervals\n |> List.flatten\n |> List.sort (fun ((_, x), k) ((_, y), k') ->\n (* Make `S come before `E so that consecutive intervals get merged\n together in the fold below *)\n let kn = function `S -> 0 | `E -> 1 in\n compare (x, kn k) (y, kn k'))\n in\n let nesting, acc =\n List.fold_left (fun (nesting, acc) (a, kind) ->\n match kind, nesting with\n | `S, `Outside -> `Inside (a, 0), acc\n | `S, `Inside (s, n) -> `Inside (s, n+1), acc\n | `E, `Outside -> assert false\n | `E, `Inside (s, 0) -> `Outside, ((s, a) :: acc)\n | `E, `Inside (s, n) -> `Inside (s, n-1), acc\n ) (`Outside, []) pos in\n assert (nesting = `Outside);\n List.rev acc\n\n let mem iset ~pos =\n List.exists (fun ((_, s), (_, e)) -> s <= pos && pos <= e) iset\n\n let find_bound_in iset ~range:(start, end_) =\n List.find_map (fun ((a, x), (b, y)) ->\n if start <= x && x <= end_ then Some (a, x)\n else if start <= y && y <= end_ then Some (b, y)\n else None\n ) iset\n\n let is_start iset ~pos =\n List.find_map (fun ((a, x), _) ->\n if pos = x then Some a else None\n ) iset\n\n let is_end iset ~pos =\n List.find_map (fun (_, (b, y)) ->\n if pos = y then Some b else None\n ) iset\n\n let extrema iset =\n if iset = [] then None\n else Some (fst (List.hd iset), snd (List.hd (List.rev iset)))\nend\n\n(******************************************************************************)\n(* Toplevel: highlighting and quoting locations *)\n\n(* Highlight the locations using standout mode.\n\n If [locs] is empty, this function is a no-op.\n*)\nlet highlight_terminfo lb ppf locs =\n Format.pp_print_flush ppf (); (* avoid mixing Format and normal output *)\n (* Char 0 is at offset -lb.lex_abs_pos in lb.lex_buffer. *)\n let pos0 = -lb.lex_abs_pos in\n (* Do nothing if the buffer does not contain the whole phrase. *)\n if pos0 < 0 then raise Exit;\n (* Count number of lines in phrase *)\n let lines = ref !num_loc_lines in\n for i = pos0 to lb.lex_buffer_len - 1 do\n if Bytes.get lb.lex_buffer i = '\\n' then incr lines\n done;\n (* If too many lines, give up *)\n if !lines >= Terminfo.num_lines stdout - 2 then raise Exit;\n (* Move cursor up that number of lines *)\n flush stdout; Terminfo.backup stdout !lines;\n (* Print the input, switching to standout for the location *)\n let bol = ref false in\n print_string \"# \";\n for pos = 0 to lb.lex_buffer_len - pos0 - 1 do\n if !bol then (print_string \" \"; bol := false);\n if List.exists (fun loc -> pos = loc.loc_start.pos_cnum) locs then\n Terminfo.standout stdout true;\n if List.exists (fun loc -> pos = loc.loc_end.pos_cnum) locs then\n Terminfo.standout stdout false;\n let c = Bytes.get lb.lex_buffer (pos + pos0) in\n print_char c;\n bol := (c = '\\n')\n done;\n (* Make sure standout mode is over *)\n Terminfo.standout stdout false;\n (* Position cursor back to original location *)\n Terminfo.resume stdout !num_loc_lines;\n flush stdout\n\nlet highlight_terminfo lb ppf locs =\n try highlight_terminfo lb ppf locs\n with Exit -> ()\n\n(* Highlight the location by printing it again.\n\n There are two different styles for highlighting errors in \"dumb\" mode,\n depending if the error fits on a single line or spans across several lines.\n\n For single-line errors,\n\n foo the_error bar\n\n gets displayed as follows, where X is the line number:\n\n X | foo the_error bar\n ^^^^^^^^^\n\n\n For multi-line errors,\n\n foo the_\n error bar\n\n gets displayed as:\n\n X1 | ....the_\n X2 | error....\n\n An ellipsis hides the middle lines of the multi-line error if it has more\n than [max_lines] lines.\n\n If [locs] is empty then this function is a no-op.\n*)\n\ntype input_line = {\n text : string;\n start_pos : int;\n}\n\n(* Takes a list of lines with possibly missing line numbers.\n\n If the line numbers that are present are consistent with the number of lines\n between them, then infer the intermediate line numbers.\n\n This is not always the case, typically if lexer line directives are\n involved... *)\nlet infer_line_numbers\n (lines: (int option * input_line) list):\n (int option * input_line) list\n =\n let (_, offset, consistent) =\n List.fold_left (fun (i, offset, consistent) (lnum, _) ->\n match lnum, offset with\n | None, _ -> (i+1, offset, consistent)\n | Some n, None -> (i+1, Some (n - i), consistent)\n | Some n, Some m -> (i+1, offset, consistent && n = m + i)\n ) (0, None, true) lines\n in\n match offset, consistent with\n | Some m, true ->\n List.mapi (fun i (_, line) -> (Some (m + i), line)) lines\n | _, _ ->\n lines\n\n(* [get_lines] must return the lines to highlight, given starting and ending\n positions.\n\n See [lines_around_from_current_input] below for an instantiation of\n [get_lines] that reads from the current input.\n*)\nlet highlight_quote ppf\n ~(get_lines: start_pos:position -> end_pos:position -> input_line list)\n ?(max_lines = 10)\n highlight_tag\n locs\n =\n let iset = ISet.of_intervals @@ List.filter_map (fun loc ->\n let s, e = loc.loc_start, loc.loc_end in\n if s.pos_cnum = -1 || e.pos_cnum = -1 then None\n else Some ((s, s.pos_cnum), (e, e.pos_cnum - 1))\n ) locs in\n match ISet.extrema iset with\n | None -> ()\n | Some ((leftmost, _), (rightmost, _)) ->\n let lines =\n get_lines ~start_pos:leftmost ~end_pos:rightmost\n |> List.map (fun ({ text; start_pos } as line) ->\n let end_pos = start_pos + String.length text - 1 in\n let line_nb =\n match ISet.find_bound_in iset ~range:(start_pos, end_pos) with\n | None -> None\n | Some (p, _) -> Some p.pos_lnum\n in\n (line_nb, line))\n |> infer_line_numbers\n |> List.map (fun (lnum, { text; start_pos }) ->\n (text,\n Option.fold ~some:Int.to_string ~none:\"\" lnum,\n start_pos))\n in\n Format.fprintf ppf \"@[\";\n begin match lines with\n | [] | [(\"\", _, _)] -> ()\n | [(line, line_nb, line_start_cnum)] ->\n (* Single-line error *)\n Format.fprintf ppf \"%s | %s@,\" line_nb line;\n Format.fprintf ppf \"%*s \" (String.length line_nb) \"\";\n String.iteri (fun i c ->\n let pos = line_start_cnum + i in\n if ISet.is_start iset ~pos <> None then\n Format.fprintf ppf \"@{<%s>\" highlight_tag;\n if ISet.mem iset ~pos then Format.pp_print_char ppf '^'\n else if pos < rightmost.pos_cnum then begin\n (* For alignment purposes, align using a tab for each tab in the\n source code *)\n if c = '\\t' then Format.pp_print_char ppf '\\t'\n else Format.pp_print_char ppf ' '\n end;\n if ISet.is_end iset ~pos <> None then\n Format.fprintf ppf \"@}\"\n ) line;\n Format.fprintf ppf \"@}@,\"\n | _ ->\n (* Multi-line error *)\n Misc.pp_two_columns ~sep:\"|\" ~max_lines ppf\n @@ List.map (fun (line, line_nb, line_start_cnum) ->\n let line = String.mapi (fun i car ->\n if ISet.mem iset ~pos:(line_start_cnum + i) then car else '.'\n ) line in\n (line_nb, line)\n ) lines\n end;\n Format.fprintf ppf \"@]\"\n\n\n\nlet lines_around\n ~(start_pos: position) ~(end_pos: position)\n ~(seek: int -> unit)\n ~(read_char: unit -> char option):\n input_line list\n =\n seek start_pos.pos_bol;\n let lines = ref [] in\n let bol = ref start_pos.pos_bol in\n let cur = ref start_pos.pos_bol in\n let b = Buffer.create 80 in\n let add_line () =\n if !bol < !cur then begin\n let text = Buffer.contents b in\n Buffer.clear b;\n lines := { text; start_pos = !bol } :: !lines;\n bol := !cur\n end\n in\n let rec loop () =\n if !bol >= end_pos.pos_cnum then ()\n else begin\n match read_char () with\n | None ->\n (* end of input *)\n add_line ()\n | Some c ->\n incr cur;\n match c with\n | '\\r' -> loop ()\n | '\\n' -> add_line (); loop ()\n | _ -> Buffer.add_char b c; loop ()\n end\n in\n loop ();\n List.rev !lines\n\n(* Try to get lines from a lexbuf *)\nlet lines_around_from_lexbuf\n ~(start_pos: position) ~(end_pos: position)\n (lb: lexbuf):\n input_line list\n =\n (* Converts a global position to one that is relative to the lexing buffer *)\n let rel n = n - lb.lex_abs_pos in\n if rel start_pos.pos_bol < 0 then begin\n (* Do nothing if the buffer does not contain the input (because it has been\n refilled while lexing it) *)\n []\n end else begin\n let pos = ref 0 in (* relative position *)\n let seek n = pos := rel n in\n let read_char () =\n if !pos >= lb.lex_buffer_len then (* end of buffer *) None\n else\n let c = Bytes.get lb.lex_buffer !pos in\n incr pos; Some c\n in\n lines_around ~start_pos ~end_pos ~seek ~read_char\n end\n\n(* Attempt to get lines from the phrase buffer *)\nlet lines_around_from_phrasebuf\n ~(start_pos: position) ~(end_pos: position)\n (pb: Buffer.t):\n input_line list\n =\n let pos = ref 0 in\n let seek n = pos := n in\n let read_char () =\n if !pos >= Buffer.length pb then None\n else begin\n let c = Buffer.nth pb !pos in\n incr pos; Some c\n end\n in\n lines_around ~start_pos ~end_pos ~seek ~read_char\n\n(* Get lines from a file *)\nlet lines_around_from_file\n ~(start_pos: position) ~(end_pos: position)\n (filename: string):\n input_line list\n =\n try\n let cin = open_in_bin filename in\n let read_char () =\n try Some (input_char cin) with End_of_file -> None\n in\n let lines =\n lines_around ~start_pos ~end_pos ~seek:(seek_in cin) ~read_char\n in\n close_in cin;\n lines\n with Sys_error _ -> []\n\n(* A [get_lines] function for [highlight_quote] that reads from the current\n input.\n\n It first tries to read from [!input_lexbuf], then if that fails (because the\n lexbuf no longer contains the input we want), it reads from [!input_name]\n directly *)\nlet lines_around_from_current_input ~start_pos ~end_pos =\n (* Be a bit defensive, and do not try to open one of the possible\n [!input_name] values that we know do not denote valid filenames. *)\n let file_valid = function\n | \"//toplevel//\" | \"_none_\" | \"\" -> false\n | _ -> true\n in\n let from_file () =\n if file_valid !input_name then\n lines_around_from_file !input_name ~start_pos ~end_pos\n else\n []\n in\n match !input_lexbuf, !input_phrase_buffer, !input_name with\n | _, Some pb, \"//toplevel//\" ->\n begin match lines_around_from_phrasebuf pb ~start_pos ~end_pos with\n | [] -> (* Could not read the input from the phrase buffer. This is likely\n a sign that we were given a buggy location. *)\n []\n | lines ->\n lines\n end\n | Some lb, _, _ ->\n begin match lines_around_from_lexbuf lb ~start_pos ~end_pos with\n | [] -> (* The input is likely not in the lexbuf anymore *)\n from_file ()\n | lines ->\n lines\n end\n | None, _, _ ->\n from_file ()\n\n(******************************************************************************)\n(* Reporting errors and warnings *)\n\ntype msg = (Format.formatter -> unit) loc\n\nlet msg ?(loc = none) fmt =\n Format.kdprintf (fun txt -> { loc; txt }) fmt\n\ntype 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\ntype report = {\n kind : report_kind;\n main : msg;\n sub : msg list;\n}\n\ntype report_printer = {\n (* The entry point *)\n pp : report_printer ->\n Format.formatter -> report -> unit;\n\n pp_report_kind : report_printer -> report ->\n Format.formatter -> report_kind -> unit;\n pp_main_loc : report_printer -> report ->\n Format.formatter -> t -> unit;\n pp_main_txt : report_printer -> report ->\n Format.formatter -> (Format.formatter -> unit) -> unit;\n pp_submsgs : report_printer -> report ->\n Format.formatter -> msg list -> unit;\n pp_submsg : report_printer -> report ->\n Format.formatter -> msg -> unit;\n pp_submsg_loc : report_printer -> report ->\n Format.formatter -> t -> unit;\n pp_submsg_txt : report_printer -> report ->\n Format.formatter -> (Format.formatter -> unit) -> unit;\n}\n\nlet is_dummy_loc loc =\n (* Fixme: this should be just [loc.loc_ghost] and the function should be\n inlined below. However, currently, the compiler emits in some places ghost\n locations with valid ranges that should still be printed. These locations\n should be made non-ghost -- in the meantime we just check if the ranges are\n valid. *)\n loc.loc_start.pos_cnum = -1 || loc.loc_end.pos_cnum = -1\n\n(* It only makes sense to highlight (i.e. quote or underline the corresponding\n source code) locations that originate from the current input.\n\n As of now, this should only happen in the following cases:\n\n - if dummy locs or ghost locs leak out of the compiler or a buggy ppx;\n\n - more generally, if some code uses the compiler-libs API and feeds it\n locations that do not match the current values of [!Location.input_name],\n [!Location.input_lexbuf];\n\n - when calling the compiler on a .ml file that contains lexer line directives\n indicating an other file. This should happen relatively rarely in practice --\n in particular this is not what happens when using -pp or -ppx or a ppx\n driver.\n*)\nlet is_quotable_loc loc =\n not (is_dummy_loc loc)\n && loc.loc_start.pos_fname = !input_name\n && loc.loc_end.pos_fname = !input_name\n\nlet error_style () =\n match !Clflags.error_style with\n | Some setting -> setting\n | None -> Misc.Error_style.default_setting\n\nlet batch_mode_printer : report_printer =\n let pp_loc _self report ppf loc =\n let tag = match report.kind with\n | Report_warning_as_error _\n | Report_alert_as_error _\n | Report_error -> \"error\"\n | Report_warning _\n | Report_alert _ -> \"warning\"\n in\n let highlight ppf loc =\n match error_style () with\n | Misc.Error_style.Contextual ->\n if is_quotable_loc loc then\n highlight_quote ppf\n ~get_lines:lines_around_from_current_input\n tag [loc]\n | Misc.Error_style.Short ->\n ()\n in\n Format.fprintf ppf \"@[%a:@ %a@]\" print_loc loc highlight loc\n in\n let pp_txt ppf txt = Format.fprintf ppf \"@[%t@]\" txt in\n let pp self ppf report =\n setup_colors ();\n (* Make sure we keep [num_loc_lines] updated.\n The tabulation box is here to give submessage the option\n to be aligned with the main message box\n *)\n print_updating_num_loc_lines ppf (fun ppf () ->\n Format.fprintf ppf \"@[%a%a%a: %a%a%a%a@]@.\"\n Format.pp_open_tbox ()\n (self.pp_main_loc self report) report.main.loc\n (self.pp_report_kind self report) report.kind\n Format.pp_set_tab ()\n (self.pp_main_txt self report) report.main.txt\n (self.pp_submsgs self report) report.sub\n Format.pp_close_tbox ()\n ) ()\n in\n let pp_report_kind _self _ ppf = function\n | Report_error -> Format.fprintf ppf \"@{Error@}\"\n | Report_warning w -> Format.fprintf ppf \"@{Warning@} %s\" w\n | Report_warning_as_error w ->\n Format.fprintf ppf \"@{Error@} (warning %s)\" w\n | Report_alert w -> Format.fprintf ppf \"@{Alert@} %s\" w\n | Report_alert_as_error w ->\n Format.fprintf ppf \"@{Error@} (alert %s)\" w\n in\n let pp_main_loc self report ppf loc =\n pp_loc self report ppf loc\n in\n let pp_main_txt _self _ ppf txt =\n pp_txt ppf txt\n in\n let pp_submsgs self report ppf msgs =\n List.iter (fun msg ->\n Format.fprintf ppf \"@,%a\" (self.pp_submsg self report) msg\n ) msgs\n in\n let pp_submsg self report ppf { loc; txt } =\n Format.fprintf ppf \"@[%a %a@]\"\n (self.pp_submsg_loc self report) loc\n (self.pp_submsg_txt self report) txt\n in\n let pp_submsg_loc self report ppf loc =\n if not loc.loc_ghost then\n pp_loc self report ppf loc\n in\n let pp_submsg_txt _self _ ppf loc =\n pp_txt ppf loc\n in\n { pp; pp_report_kind; pp_main_loc; pp_main_txt;\n pp_submsgs; pp_submsg; pp_submsg_loc; pp_submsg_txt }\n\nlet terminfo_toplevel_printer (lb: lexbuf): report_printer =\n let pp self ppf err =\n setup_colors ();\n (* Highlight all toplevel locations of the report, instead of displaying\n the main location. Do it now instead of in [pp_main_loc], to avoid\n messing with Format boxes. *)\n let sub_locs = List.map (fun { loc; _ } -> loc) err.sub in\n let all_locs = err.main.loc :: sub_locs in\n let locs_highlighted = List.filter is_quotable_loc all_locs in\n highlight_terminfo lb ppf locs_highlighted;\n batch_mode_printer.pp self ppf err\n in\n let pp_main_loc _ _ _ _ = () in\n let pp_submsg_loc _ _ ppf loc =\n if not loc.loc_ghost then\n Format.fprintf ppf \"%a:@ \" print_loc loc in\n { batch_mode_printer with pp; pp_main_loc; pp_submsg_loc }\n\nlet best_toplevel_printer () =\n setup_terminal ();\n match !status, !input_lexbuf with\n | Terminfo.Good_term, Some lb ->\n terminfo_toplevel_printer lb\n | _, _ ->\n batch_mode_printer\n\n(* Creates a printer for the current input *)\nlet default_report_printer () : report_printer =\n if !input_name = \"//toplevel//\" then\n best_toplevel_printer ()\n else\n batch_mode_printer\n\nlet report_printer = ref default_report_printer\n\nlet print_report ppf report =\n let printer = !report_printer () in\n printer.pp printer ppf report\n\n(******************************************************************************)\n(* Reporting errors *)\n\ntype error = report\n\nlet report_error ppf err =\n print_report ppf err\n\nlet mkerror loc sub txt =\n { kind = Report_error; main = { loc; txt }; sub }\n\nlet errorf ?(loc = none) ?(sub = []) =\n Format.kdprintf (mkerror loc sub)\n\nlet error ?(loc = none) ?(sub = []) msg_str =\n mkerror loc sub (fun ppf -> Format.pp_print_string ppf msg_str)\n\nlet error_of_printer ?(loc = none) ?(sub = []) pp x =\n mkerror loc sub (fun ppf -> pp ppf x)\n\nlet error_of_printer_file print x =\n error_of_printer ~loc:(in_file !input_name) print x\n\n(******************************************************************************)\n(* Reporting warnings: generating a report from a warning number using the\n information in [Warnings] + convenience functions. *)\n\nlet default_warning_alert_reporter report mk (loc: t) w : report option =\n match report w with\n | `Inactive -> None\n | `Active { Warnings.id; message; is_error; sub_locs } ->\n let msg_of_str str = fun ppf -> Format.pp_print_string ppf str in\n let kind = mk is_error id in\n let main = { loc; txt = msg_of_str message } in\n let sub = List.map (fun (loc, sub_message) ->\n { loc; txt = msg_of_str sub_message }\n ) sub_locs in\n Some { kind; main; sub }\n\n\nlet default_warning_reporter =\n default_warning_alert_reporter\n Warnings.report\n (fun is_error id ->\n if is_error then Report_warning_as_error id\n else Report_warning id\n )\n\nlet warning_reporter = ref default_warning_reporter\nlet report_warning loc w = !warning_reporter loc w\n\nlet formatter_for_warnings = ref Format.err_formatter\n\nlet print_warning loc ppf w =\n match report_warning loc w with\n | None -> ()\n | Some report -> print_report ppf report\n\nlet prerr_warning loc w = print_warning loc !formatter_for_warnings w\n\nlet default_alert_reporter =\n default_warning_alert_reporter\n Warnings.report_alert\n (fun is_error id ->\n if is_error then Report_alert_as_error id\n else Report_alert id\n )\n\nlet alert_reporter = ref default_alert_reporter\nlet report_alert loc w = !alert_reporter loc w\n\nlet print_alert loc ppf w =\n match report_alert loc w with\n | None -> ()\n | Some report -> print_report ppf report\n\nlet prerr_alert loc w = print_alert loc !formatter_for_warnings w\n\nlet alert ?(def = none) ?(use = none) ~kind loc message =\n prerr_alert loc {Warnings.kind; message; def; use}\n\nlet deprecated ?def ?use loc message =\n alert ?def ?use ~kind:\"deprecated\" loc message\n\n(******************************************************************************)\n(* Reporting errors on exceptions *)\n\nlet error_of_exn : (exn -> error option) list ref = ref []\n\nlet register_error_of_exn f = error_of_exn := f :: !error_of_exn\n\nexception Already_displayed_error = Warnings.Errors\n\nlet error_of_exn exn =\n match exn with\n | Already_displayed_error -> Some `Already_displayed\n | _ ->\n let rec loop = function\n | [] -> None\n | f :: rest ->\n match f exn with\n | Some error -> Some (`Ok error)\n | None -> loop rest\n in\n loop !error_of_exn\n\nlet () =\n register_error_of_exn\n (function\n | Sys_error msg ->\n Some (errorf ~loc:(in_file !input_name) \"I/O error: %s\" msg)\n | _ -> None\n )\n\nexternal reraise : exn -> 'a = \"%reraise\"\n\nlet report_exception ppf exn =\n let rec loop n exn =\n match error_of_exn exn with\n | None -> reraise exn\n | Some `Already_displayed -> ()\n | Some (`Ok err) -> report_error ppf err\n | exception exn when n > 0 -> loop (n-1) exn\n in\n loop 5 exn\n\nexception Error of error\n\nlet () =\n register_error_of_exn\n (function\n | Error e -> Some e\n | _ -> None\n )\n\nlet raise_errorf ?(loc = none) ?(sub = []) =\n Format.kdprintf (fun txt -> raise (Error (mkerror loc sub txt)))\n","# 18 \"parsing/lexer.mll\"\n \nopen Lexing\nopen Misc\nopen Parser\n\ntype error =\n | Illegal_character of char\n | Illegal_escape of string * string option\n | Reserved_sequence of string * string option\n | Unterminated_comment of Location.t\n | Unterminated_string\n | Unterminated_string_in_comment of Location.t * Location.t\n | Empty_character_literal\n | Keyword_as_label of string\n | Invalid_literal of string\n | Invalid_directive of string * string option\n;;\n\nexception Error of error * Location.t;;\n\n(* The table of keywords *)\n\nlet keyword_table =\n create_hashtable 149 [\n \"and\", AND;\n \"as\", AS;\n \"assert\", ASSERT;\n \"begin\", BEGIN;\n \"class\", CLASS;\n \"constraint\", CONSTRAINT;\n \"do\", DO;\n \"done\", DONE;\n \"downto\", DOWNTO;\n \"else\", ELSE;\n \"end\", END;\n \"exception\", EXCEPTION;\n \"external\", EXTERNAL;\n \"false\", FALSE;\n \"for\", FOR;\n \"fun\", FUN;\n \"function\", FUNCTION;\n \"functor\", FUNCTOR;\n \"if\", IF;\n \"in\", IN;\n \"include\", INCLUDE;\n \"inherit\", INHERIT;\n \"initializer\", INITIALIZER;\n \"lazy\", LAZY;\n \"let\", LET;\n \"match\", MATCH;\n \"method\", METHOD;\n \"module\", MODULE;\n \"mutable\", MUTABLE;\n \"new\", NEW;\n \"nonrec\", NONREC;\n \"object\", OBJECT;\n \"of\", OF;\n \"open\", OPEN;\n \"or\", OR;\n(* \"parser\", PARSER; *)\n \"private\", PRIVATE;\n \"rec\", REC;\n \"sig\", SIG;\n \"struct\", STRUCT;\n \"then\", THEN;\n \"to\", TO;\n \"true\", TRUE;\n \"try\", TRY;\n \"type\", TYPE;\n \"val\", VAL;\n \"virtual\", VIRTUAL;\n \"when\", WHEN;\n \"while\", WHILE;\n \"with\", WITH;\n\n \"lor\", INFIXOP3(\"lor\"); (* Should be INFIXOP2 *)\n \"lxor\", INFIXOP3(\"lxor\"); (* Should be INFIXOP2 *)\n \"mod\", INFIXOP3(\"mod\");\n \"land\", INFIXOP3(\"land\");\n \"lsl\", INFIXOP4(\"lsl\");\n \"lsr\", INFIXOP4(\"lsr\");\n \"asr\", INFIXOP4(\"asr\")\n]\n\n(* To buffer string literals *)\n\nlet string_buffer = Buffer.create 256\nlet reset_string_buffer () = Buffer.reset string_buffer\nlet get_stored_string () = Buffer.contents string_buffer\n\nlet store_string_char c = Buffer.add_char string_buffer c\nlet store_string_utf_8_uchar u = Buffer.add_utf_8_uchar string_buffer u\nlet store_string s = Buffer.add_string string_buffer s\nlet store_lexeme lexbuf = store_string (Lexing.lexeme lexbuf)\n\n(* To store the position of the beginning of a string and comment *)\nlet string_start_loc = ref Location.none;;\nlet comment_start_loc = ref [];;\nlet in_comment () = !comment_start_loc <> [];;\nlet is_in_string = ref false\nlet in_string () = !is_in_string\nlet print_warnings = ref true\n\n(* Escaped chars are interpreted in strings unless they are in comments. *)\nlet store_escaped_char lexbuf c =\n if in_comment () then store_lexeme lexbuf else store_string_char c\n\nlet store_escaped_uchar lexbuf u =\n if in_comment () then store_lexeme lexbuf else store_string_utf_8_uchar u\n\nlet compute_quoted_string_idloc {Location.loc_start = orig_loc } shift id =\n let id_start_pos = orig_loc.Lexing.pos_cnum + shift in\n let loc_start =\n Lexing.{orig_loc with pos_cnum = id_start_pos }\n in\n let loc_end =\n Lexing.{orig_loc with pos_cnum = id_start_pos + String.length id}\n in\n {Location. loc_start ; loc_end ; loc_ghost = false }\n\nlet wrap_string_lexer f lexbuf =\n let loc_start = lexbuf.lex_curr_p in\n reset_string_buffer();\n is_in_string := true;\n let string_start = lexbuf.lex_start_p in\n string_start_loc := Location.curr lexbuf;\n let loc_end = f lexbuf in\n is_in_string := false;\n lexbuf.lex_start_p <- string_start;\n let loc = Location.{loc_ghost= false; loc_start; loc_end} in\n get_stored_string (), loc\n\nlet wrap_comment_lexer comment lexbuf =\n let start_loc = Location.curr lexbuf in\n comment_start_loc := [start_loc];\n reset_string_buffer ();\n let end_loc = comment lexbuf in\n let s = get_stored_string () in\n reset_string_buffer ();\n s,\n { start_loc with Location.loc_end = end_loc.Location.loc_end }\n\nlet error lexbuf e = raise (Error(e, Location.curr lexbuf))\nlet error_loc loc e = raise (Error(e, loc))\n\n(* to translate escape sequences *)\n\nlet digit_value c =\n match c with\n | 'a' .. 'f' -> 10 + Char.code c - Char.code 'a'\n | 'A' .. 'F' -> 10 + Char.code c - Char.code 'A'\n | '0' .. '9' -> Char.code c - Char.code '0'\n | _ -> assert false\n\nlet num_value lexbuf ~base ~first ~last =\n let c = ref 0 in\n for i = first to last do\n let v = digit_value (Lexing.lexeme_char lexbuf i) in\n assert(v < base);\n c := (base * !c) + v\n done;\n !c\n\nlet char_for_backslash = function\n | 'n' -> '\\010'\n | 'r' -> '\\013'\n | 'b' -> '\\008'\n | 't' -> '\\009'\n | c -> c\n\nlet illegal_escape lexbuf reason =\n let error = Illegal_escape (Lexing.lexeme lexbuf, Some reason) in\n raise (Error (error, Location.curr lexbuf))\n\nlet char_for_decimal_code lexbuf i =\n let c = num_value lexbuf ~base:10 ~first:i ~last:(i+2) in\n if (c < 0 || c > 255) then\n if in_comment ()\n then 'x'\n else\n illegal_escape lexbuf\n (Printf.sprintf\n \"%d is outside the range of legal characters (0-255).\" c)\n else Char.chr c\n\nlet char_for_octal_code lexbuf i =\n let c = num_value lexbuf ~base:8 ~first:i ~last:(i+2) in\n if (c < 0 || c > 255) then\n if in_comment ()\n then 'x'\n else\n illegal_escape lexbuf\n (Printf.sprintf\n \"o%o (=%d) is outside the range of legal characters (0-255).\" c c)\n else Char.chr c\n\nlet char_for_hexadecimal_code lexbuf i =\n Char.chr (num_value lexbuf ~base:16 ~first:i ~last:(i+1))\n\nlet uchar_for_uchar_escape lexbuf =\n let len = Lexing.lexeme_end lexbuf - Lexing.lexeme_start lexbuf in\n let first = 3 (* skip opening \\u{ *) in\n let last = len - 2 (* skip closing } *) in\n let digit_count = last - first + 1 in\n match digit_count > 6 with\n | true ->\n illegal_escape lexbuf\n \"too many digits, expected 1 to 6 hexadecimal digits\"\n | false ->\n let cp = num_value lexbuf ~base:16 ~first ~last in\n if Uchar.is_valid cp then Uchar.unsafe_of_int cp else\n illegal_escape lexbuf\n (Printf.sprintf \"%X is not a Unicode scalar value\" cp)\n\nlet is_keyword name = Hashtbl.mem keyword_table name\n\nlet check_label_name lexbuf name =\n if is_keyword name then error lexbuf (Keyword_as_label name)\n\n(* Update the current location with file name and line number. *)\n\nlet update_loc lexbuf file line absolute chars =\n let pos = lexbuf.lex_curr_p in\n let new_file = match file with\n | None -> pos.pos_fname\n | Some s -> s\n in\n lexbuf.lex_curr_p <- { pos with\n pos_fname = new_file;\n pos_lnum = if absolute then line else pos.pos_lnum + line;\n pos_bol = pos.pos_cnum - chars;\n }\n;;\n\nlet preprocessor = ref None\n\nlet escaped_newlines = ref false\n\n(* Warn about Latin-1 characters used in idents *)\n\nlet warn_latin1 lexbuf =\n Location.deprecated\n (Location.curr lexbuf)\n \"ISO-Latin1 characters in identifiers\"\n\nlet handle_docstrings = ref true\nlet comment_list = ref []\n\nlet add_comment com =\n comment_list := com :: !comment_list\n\nlet add_docstring_comment ds =\n let com =\n (\"*\" ^ Docstrings.docstring_body ds, Docstrings.docstring_loc ds)\n in\n add_comment com\n\nlet comments () = List.rev !comment_list\n\n(* Error report *)\n\nopen Format\n\nlet prepare_error loc = function\n | Illegal_character c ->\n Location.errorf ~loc \"Illegal character (%s)\" (Char.escaped c)\n | Illegal_escape (s, explanation) ->\n Location.errorf ~loc\n \"Illegal backslash escape in string or character (%s)%t\" s\n (fun ppf -> match explanation with\n | None -> ()\n | Some expl -> fprintf ppf \": %s\" expl)\n | Reserved_sequence (s, explanation) ->\n Location.errorf ~loc\n \"Reserved character sequence: %s%t\" s\n (fun ppf -> match explanation with\n | None -> ()\n | Some expl -> fprintf ppf \" %s\" expl)\n | Unterminated_comment _ ->\n Location.errorf ~loc \"Comment not terminated\"\n | Unterminated_string ->\n Location.errorf ~loc \"String literal not terminated\"\n | Unterminated_string_in_comment (_, literal_loc) ->\n Location.errorf ~loc\n \"This comment contains an unterminated string literal\"\n ~sub:[Location.msg ~loc:literal_loc \"String literal begins here\"]\n | Empty_character_literal ->\n let msg = \"Illegal empty character literal ''\" in\n let sub =\n [Location.msg\n \"Hint: Did you mean ' ' or a type variable 'a?\"] in\n Location.error ~loc ~sub msg\n | Keyword_as_label kwd ->\n Location.errorf ~loc\n \"`%s' is a keyword, it cannot be used as label name\" kwd\n | Invalid_literal s ->\n Location.errorf ~loc \"Invalid literal %s\" s\n | Invalid_directive (dir, explanation) ->\n Location.errorf ~loc \"Invalid lexer directive %S%t\" dir\n (fun ppf -> match explanation with\n | None -> ()\n | Some expl -> fprintf ppf \": %s\" expl)\n\nlet () =\n Location.register_error_of_exn\n (function\n | Error (err, loc) ->\n Some (prepare_error loc err)\n | _ ->\n None\n )\n\n\n# 316 \"parsing/lexer.ml\"\nlet __ocaml_lex_tables = {\n Lexing.lex_base =\n \"\\000\\000\\155\\255\\156\\255\\224\\000\\003\\001\\038\\001\\073\\001\\108\\001\\\n \\143\\001\\181\\255\\178\\001\\215\\001\\189\\255\\091\\000\\252\\001\\031\\002\\\n \\068\\000\\071\\000\\066\\002\\207\\255\\209\\255\\212\\255\\101\\002\\136\\002\\\n \\171\\002\\088\\000\\255\\000\\201\\002\\235\\255\\029\\003\\113\\003\\197\\003\\\n \\149\\004\\101\\005\\053\\006\\005\\007\\213\\007\\180\\008\\016\\009\\147\\009\\\n \\231\\009\\122\\000\\254\\255\\001\\000\\005\\000\\255\\255\\006\\000\\007\\000\\\n \\198\\010\\228\\010\\180\\011\\249\\255\\248\\255\\147\\012\\204\\255\\250\\255\\\n \\177\\012\\129\\013\\246\\255\\245\\255\\081\\014\\045\\015\\032\\004\\253\\015\\\n \\217\\016\\240\\004\\016\\009\\178\\017\\006\\018\\090\\018\\174\\018\\002\\019\\\n \\086\\019\\170\\019\\254\\019\\082\\020\\166\\020\\087\\000\\250\\020\\078\\021\\\n \\162\\021\\246\\021\\074\\022\\108\\000\\187\\255\\160\\005\\234\\255\\169\\002\\\n \\111\\006\\188\\022\\000\\011\\233\\255\\063\\007\\046\\023\\232\\255\\003\\004\\\n \\160\\023\\205\\012\\231\\255\\015\\008\\018\\024\\230\\255\\211\\004\\222\\255\\\n \\109\\024\\106\\000\\107\\000\\011\\000\\229\\255\\228\\255\\223\\255\\255\\011\\\n \\118\\000\\126\\000\\108\\000\\227\\255\\224\\000\\109\\000\\226\\255\\136\\000\\\n \\003\\001\\110\\000\\225\\255\\204\\013\\111\\000\\224\\255\\217\\000\\218\\255\\\n \\222\\000\\217\\255\\248\\000\\134\\024\\216\\255\\201\\024\\236\\024\\017\\025\\\n \\052\\025\\087\\025\\199\\255\\200\\255\\201\\255\\197\\255\\122\\025\\115\\000\\\n \\183\\000\\190\\255\\191\\255\\192\\255\\219\\000\\177\\255\\175\\255\\184\\255\\\n \\157\\025\\180\\255\\182\\255\\192\\025\\227\\025\\006\\026\\041\\026\\192\\002\\\n \\205\\008\\080\\001\\038\\001\\115\\001\\103\\026\\241\\255\\188\\026\\243\\255\\\n \\012\\000\\244\\255\\252\\013\\028\\011\\253\\255\\250\\000\\251\\000\\255\\255\\\n \\254\\255\\252\\255\\233\\012\\056\\016\\056\\027\\105\\015\\084\\027\\021\\017\\\n \\198\\027\\033\\028\\003\\001\\004\\001\\013\\000\\251\\255\\250\\255\\249\\255\\\n \\156\\014\\038\\001\\202\\002\\005\\001\\248\\255\\032\\004\\020\\001\\247\\255\\\n \\189\\003\\240\\004\\021\\001\\246\\255\\067\\028\\029\\001\\245\\255\\017\\000\\\n \\236\\001\\245\\255\\246\\255\\247\\255\\018\\000\\138\\028\\255\\255\\248\\255\\\n \\202\\000\\172\\028\\235\\005\\186\\006\\253\\255\\073\\001\\094\\001\\111\\001\\\n \\138\\007\\252\\255\\090\\008\\180\\008\\251\\255\\211\\028\\250\\255\\234\\028\\\n \\016\\029\\249\\255\\113\\001\\150\\001\\252\\255\\118\\009\\254\\255\\255\\255\\\n \\129\\001\\130\\001\\253\\255\\045\\029\\038\\001\\044\\001\\098\\001\\107\\001\\\n \\045\\001\\142\\001\\044\\001\\019\\000\\255\\255\";\n Lexing.lex_backtrk =\n \"\\255\\255\\255\\255\\255\\255\\095\\000\\094\\000\\091\\000\\090\\000\\083\\000\\\n \\081\\000\\255\\255\\072\\000\\069\\000\\255\\255\\062\\000\\061\\000\\059\\000\\\n \\057\\000\\053\\000\\086\\000\\255\\255\\255\\255\\255\\255\\041\\000\\040\\000\\\n \\047\\000\\045\\000\\044\\000\\067\\000\\255\\255\\015\\000\\015\\000\\014\\000\\\n \\013\\000\\012\\000\\011\\000\\011\\000\\011\\000\\008\\000\\050\\000\\004\\000\\\n \\003\\000\\002\\000\\255\\255\\100\\000\\100\\000\\255\\255\\255\\255\\255\\255\\\n \\089\\000\\255\\255\\255\\255\\255\\255\\255\\255\\052\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\011\\000\\011\\000\\097\\000\\011\\000\\\n \\011\\000\\098\\000\\019\\000\\019\\000\\017\\000\\016\\000\\019\\000\\016\\000\\\n \\016\\000\\015\\000\\017\\000\\016\\000\\017\\000\\255\\255\\018\\000\\018\\000\\\n \\015\\000\\015\\000\\017\\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\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\034\\000\\255\\255\\\n \\035\\000\\255\\255\\036\\000\\093\\000\\255\\255\\096\\000\\042\\000\\092\\000\\\n \\087\\000\\049\\000\\255\\255\\255\\255\\255\\255\\255\\255\\060\\000\\079\\000\\\n \\076\\000\\255\\255\\255\\255\\255\\255\\077\\000\\255\\255\\255\\255\\255\\255\\\n \\070\\000\\255\\255\\255\\255\\088\\000\\082\\000\\085\\000\\084\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\013\\000\\255\\255\\\n \\014\\000\\255\\255\\014\\000\\014\\000\\255\\255\\014\\000\\014\\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\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\010\\000\\010\\000\\255\\255\\255\\255\\\n \\007\\000\\007\\000\\007\\000\\007\\000\\255\\255\\001\\000\\007\\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\\003\\000\\255\\255\\255\\255\\\n \\003\\000\\255\\255\\255\\255\\255\\255\\002\\000\\255\\255\\255\\255\\001\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\";\n Lexing.lex_default =\n \"\\001\\000\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\105\\000\\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\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\\n \\255\\255\\255\\255\\000\\000\\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\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\\n \\110\\000\\255\\255\\255\\255\\255\\255\\000\\000\\000\\000\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\000\\000\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\255\\255\\000\\000\\000\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\161\\000\\255\\255\\163\\000\\165\\000\\000\\000\\255\\255\\000\\000\\\n \\255\\255\\000\\000\\186\\000\\255\\255\\000\\000\\255\\255\\255\\255\\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\\255\\255\\000\\000\\000\\000\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\\n \\209\\000\\000\\000\\000\\000\\000\\000\\255\\255\\215\\000\\000\\000\\000\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\255\\255\\000\\000\\255\\255\\000\\000\\255\\255\\\n \\255\\255\\000\\000\\255\\255\\236\\000\\000\\000\\255\\255\\000\\000\\000\\000\\\n \\255\\255\\255\\255\\000\\000\\255\\255\\255\\255\\255\\255\\246\\000\\249\\000\\\n \\255\\255\\249\\000\\255\\255\\255\\255\\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\\041\\000\\042\\000\\042\\000\\041\\000\\043\\000\\047\\000\\045\\000\\\n \\045\\000\\042\\000\\046\\000\\046\\000\\047\\000\\106\\000\\167\\000\\187\\000\\\n \\107\\000\\207\\000\\188\\000\\167\\000\\211\\000\\252\\000\\207\\000\\234\\000\\\n \\041\\000\\008\\000\\028\\000\\023\\000\\006\\000\\004\\000\\022\\000\\026\\000\\\n \\025\\000\\020\\000\\024\\000\\007\\000\\019\\000\\018\\000\\038\\000\\003\\000\\\n \\030\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\\n \\029\\000\\029\\000\\017\\000\\016\\000\\015\\000\\014\\000\\010\\000\\037\\000\\\n \\005\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\013\\000\\044\\000\\012\\000\\005\\000\\040\\000\\\n \\021\\000\\035\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\036\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\027\\000\\011\\000\\009\\000\\039\\000\\141\\000\\\n \\143\\000\\140\\000\\126\\000\\041\\000\\139\\000\\138\\000\\041\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\109\\000\\108\\000\\115\\000\\118\\000\\122\\000\\125\\000\\146\\000\\\n \\150\\000\\145\\000\\041\\000\\144\\000\\082\\000\\082\\000\\082\\000\\082\\000\\\n \\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\119\\000\\119\\000\\\n \\119\\000\\119\\000\\119\\000\\119\\000\\119\\000\\119\\000\\116\\000\\116\\000\\\n \\116\\000\\116\\000\\116\\000\\116\\000\\116\\000\\116\\000\\116\\000\\116\\000\\\n \\120\\000\\120\\000\\120\\000\\120\\000\\120\\000\\120\\000\\120\\000\\120\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\147\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\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\\033\\000\\033\\000\\033\\000\\033\\000\\148\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\002\\000\\003\\000\\127\\000\\128\\000\\003\\000\\003\\000\\003\\000\\129\\000\\\n \\130\\000\\106\\000\\003\\000\\003\\000\\107\\000\\003\\000\\003\\000\\003\\000\\\n \\117\\000\\117\\000\\117\\000\\117\\000\\117\\000\\117\\000\\117\\000\\117\\000\\\n \\117\\000\\117\\000\\003\\000\\149\\000\\003\\000\\003\\000\\003\\000\\003\\000\\\n \\003\\000\\129\\000\\130\\000\\176\\000\\003\\000\\175\\000\\103\\000\\003\\000\\\n \\003\\000\\003\\000\\191\\000\\190\\000\\196\\000\\003\\000\\003\\000\\162\\000\\\n \\003\\000\\003\\000\\003\\000\\121\\000\\121\\000\\121\\000\\121\\000\\121\\000\\\n \\121\\000\\121\\000\\121\\000\\199\\000\\203\\000\\003\\000\\003\\000\\003\\000\\\n \\003\\000\\003\\000\\003\\000\\003\\000\\206\\000\\231\\000\\162\\000\\005\\000\\\n \\161\\000\\245\\000\\005\\000\\005\\000\\005\\000\\246\\000\\250\\000\\251\\000\\\n \\005\\000\\005\\000\\221\\000\\005\\000\\005\\000\\005\\000\\200\\000\\200\\000\\\n \\200\\000\\200\\000\\255\\255\\104\\000\\003\\000\\255\\255\\003\\000\\000\\000\\\n \\005\\000\\003\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\000\\000\\\n \\221\\000\\221\\000\\006\\000\\223\\000\\247\\000\\006\\000\\006\\000\\006\\000\\\n \\000\\000\\000\\000\\163\\000\\006\\000\\006\\000\\248\\000\\006\\000\\006\\000\\\n \\006\\000\\221\\000\\000\\000\\211\\000\\223\\000\\255\\255\\234\\000\\003\\000\\\n \\255\\255\\003\\000\\000\\000\\006\\000\\005\\000\\006\\000\\006\\000\\006\\000\\\n \\006\\000\\006\\000\\000\\000\\239\\000\\239\\000\\135\\000\\241\\000\\241\\000\\\n \\135\\000\\135\\000\\135\\000\\000\\000\\000\\000\\000\\000\\135\\000\\135\\000\\\n \\248\\000\\135\\000\\158\\000\\135\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\239\\000\\000\\000\\005\\000\\240\\000\\005\\000\\000\\000\\135\\000\\006\\000\\\n \\135\\000\\157\\000\\135\\000\\135\\000\\135\\000\\000\\000\\000\\000\\000\\000\\\n \\155\\000\\000\\000\\155\\000\\155\\000\\155\\000\\155\\000\\000\\000\\000\\000\\\n \\000\\000\\155\\000\\155\\000\\000\\000\\155\\000\\155\\000\\155\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\000\\000\\000\\006\\000\\\n \\000\\000\\155\\000\\135\\000\\155\\000\\156\\000\\155\\000\\155\\000\\155\\000\\\n \\000\\000\\000\\000\\000\\000\\006\\000\\000\\000\\000\\000\\006\\000\\006\\000\\\n \\006\\000\\000\\000\\000\\000\\000\\000\\006\\000\\006\\000\\000\\000\\006\\000\\\n \\006\\000\\006\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\135\\000\\000\\000\\135\\000\\000\\000\\006\\000\\155\\000\\006\\000\\006\\000\\\n \\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\000\\000\\211\\000\\000\\000\\\n \\006\\000\\212\\000\\000\\000\\006\\000\\006\\000\\006\\000\\000\\000\\255\\255\\\n \\000\\000\\006\\000\\006\\000\\000\\000\\006\\000\\006\\000\\006\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\155\\000\\000\\000\\155\\000\\214\\000\\154\\000\\\n \\006\\000\\006\\000\\237\\000\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\000\\000\\000\\000\\000\\\n \\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\000\\000\\006\\000\\006\\000\\\n \\000\\000\\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\006\\000\\153\\000\\\n \\006\\000\\000\\000\\000\\000\\000\\000\\151\\000\\006\\000\\006\\000\\000\\000\\\n \\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\000\\000\\\n \\006\\000\\000\\000\\000\\000\\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\\n \\213\\000\\006\\000\\006\\000\\000\\000\\142\\000\\006\\000\\006\\000\\000\\000\\\n \\255\\255\\000\\000\\000\\000\\152\\000\\000\\000\\006\\000\\000\\000\\000\\000\\\n \\000\\000\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\\n \\000\\000\\000\\000\\255\\255\\135\\000\\000\\000\\000\\000\\135\\000\\135\\000\\\n \\135\\000\\000\\000\\000\\000\\255\\255\\135\\000\\135\\000\\000\\000\\135\\000\\\n \\136\\000\\135\\000\\000\\000\\255\\255\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\006\\000\\000\\000\\006\\000\\000\\000\\135\\000\\006\\000\\135\\000\\135\\000\\\n \\137\\000\\135\\000\\135\\000\\000\\000\\000\\000\\000\\000\\006\\000\\000\\000\\\n \\000\\000\\006\\000\\006\\000\\134\\000\\000\\000\\000\\000\\255\\255\\006\\000\\\n \\006\\000\\000\\000\\006\\000\\006\\000\\006\\000\\000\\000\\238\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\006\\000\\000\\000\\006\\000\\000\\000\\006\\000\\\n \\135\\000\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\\n \\000\\000\\133\\000\\000\\000\\133\\000\\133\\000\\133\\000\\133\\000\\000\\000\\\n \\000\\000\\000\\000\\133\\000\\133\\000\\000\\000\\133\\000\\133\\000\\133\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\135\\000\\000\\000\\\n \\135\\000\\000\\000\\133\\000\\006\\000\\133\\000\\133\\000\\133\\000\\133\\000\\\n \\133\\000\\159\\000\\000\\000\\000\\000\\003\\000\\000\\000\\000\\000\\003\\000\\\n \\003\\000\\003\\000\\000\\000\\000\\000\\132\\000\\131\\000\\003\\000\\000\\000\\\n \\003\\000\\003\\000\\003\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\159\\000\\006\\000\\000\\000\\006\\000\\000\\000\\003\\000\\133\\000\\003\\000\\\n \\003\\000\\003\\000\\003\\000\\003\\000\\210\\000\\000\\000\\085\\000\\000\\000\\\n \\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\\n \\160\\000\\160\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\133\\000\\084\\000\\133\\000\\000\\000\\\n \\087\\000\\003\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\000\\000\\086\\000\\000\\000\\003\\000\\\n \\087\\000\\003\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\066\\000\\086\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\068\\000\\000\\000\\029\\000\\029\\000\\029\\000\\\n \\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\067\\000\\066\\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 \\000\\000\\000\\000\\000\\000\\000\\000\\029\\000\\000\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\067\\000\\066\\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 \\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\068\\000\\\n \\000\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\\n \\029\\000\\029\\000\\029\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\066\\000\\070\\000\\066\\000\\066\\000\\067\\000\\066\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\071\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\072\\000\\069\\000\\069\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\029\\000\\000\\000\\066\\000\\070\\000\\066\\000\\066\\000\\067\\000\\066\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\071\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\072\\000\\069\\000\\069\\000\\031\\000\\201\\000\\201\\000\\201\\000\\\n \\201\\000\\201\\000\\201\\000\\201\\000\\201\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\031\\000\\000\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\000\\000\\062\\000\\000\\000\\000\\000\\062\\000\\062\\000\\062\\000\\000\\000\\\n \\000\\000\\000\\000\\062\\000\\062\\000\\000\\000\\062\\000\\000\\000\\062\\000\\\n \\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\198\\000\\\n \\198\\000\\198\\000\\062\\000\\000\\000\\000\\000\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\000\\000\\095\\000\\000\\000\\095\\000\\095\\000\\095\\000\\095\\000\\\n \\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\\n \\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\\n \\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\062\\000\\094\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\062\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\032\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\032\\000\\000\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\000\\000\\065\\000\\000\\000\\000\\000\\065\\000\\065\\000\\065\\000\\000\\000\\\n \\000\\000\\000\\000\\065\\000\\065\\000\\000\\000\\065\\000\\000\\000\\065\\000\\\n \\202\\000\\202\\000\\202\\000\\202\\000\\202\\000\\202\\000\\202\\000\\202\\000\\\n \\000\\000\\000\\000\\065\\000\\000\\000\\000\\000\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\000\\000\\102\\000\\000\\000\\102\\000\\102\\000\\102\\000\\102\\000\\\n \\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\\n \\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\\n \\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\065\\000\\101\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\065\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\033\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\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 \\000\\000\\000\\000\\000\\000\\000\\000\\033\\000\\088\\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\\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 \\000\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\000\\000\\000\\000\\000\\000\\000\\000\\089\\000\\\n \\000\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\\n \\226\\000\\226\\000\\226\\000\\000\\000\\000\\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\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\000\\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\\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\\033\\000\\034\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\034\\000\\000\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\000\\000\\000\\000\\000\\000\\000\\000\\096\\000\\000\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\224\\000\\224\\000\\224\\000\\224\\000\\224\\000\\224\\000\\\n \\224\\000\\224\\000\\224\\000\\224\\000\\000\\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\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\000\\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\\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\\033\\000\\034\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\034\\000\\000\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\063\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\000\\000\\000\\000\\000\\000\\000\\000\\093\\000\\000\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\225\\000\\\n \\225\\000\\225\\000\\225\\000\\225\\000\\000\\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\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\000\\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\\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\\033\\000\\034\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\034\\000\\000\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\060\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\000\\000\\000\\000\\000\\000\\000\\000\\100\\000\\000\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\000\\000\\000\\000\\000\\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\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\000\\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\\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\\033\\000\\000\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\048\\000\\162\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\000\\000\\000\\000\\000\\000\\048\\000\\048\\000\\\n \\000\\000\\048\\000\\048\\000\\048\\000\\228\\000\\228\\000\\228\\000\\228\\000\\\n \\228\\000\\228\\000\\228\\000\\228\\000\\000\\000\\162\\000\\048\\000\\161\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\160\\000\\160\\000\\160\\000\\\n \\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\160\\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\\048\\000\\057\\000\\000\\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\\057\\000\\057\\000\\057\\000\\000\\000\\\n \\048\\000\\053\\000\\048\\000\\000\\000\\053\\000\\053\\000\\053\\000\\066\\000\\\n \\000\\000\\000\\000\\053\\000\\053\\000\\000\\000\\053\\000\\054\\000\\053\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\053\\000\\000\\000\\000\\000\\053\\000\\053\\000\\053\\000\\\n \\053\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\053\\000\\066\\000\\\n \\000\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\000\\000\\053\\000\\000\\000\\055\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\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\\056\\000\\056\\000\\000\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\048\\000\\000\\000\\048\\000\\048\\000\\\n \\048\\000\\048\\000\\000\\000\\000\\000\\000\\000\\048\\000\\048\\000\\000\\000\\\n \\048\\000\\048\\000\\048\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\048\\000\\000\\000\\048\\000\\\n \\048\\000\\048\\000\\048\\000\\048\\000\\000\\000\\243\\000\\000\\000\\243\\000\\\n \\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\\n \\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\\n \\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\\n \\243\\000\\048\\000\\050\\000\\242\\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\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\034\\000\\048\\000\\\n \\000\\000\\048\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\000\\000\\000\\000\\000\\000\\000\\000\\034\\000\\000\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\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\\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\\000\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\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\\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\\033\\000\\033\\000\\033\\000\\000\\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\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\000\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\048\\000\\\n \\000\\000\\048\\000\\048\\000\\048\\000\\048\\000\\000\\000\\000\\000\\000\\000\\\n \\048\\000\\048\\000\\000\\000\\048\\000\\048\\000\\048\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\048\\000\\000\\000\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\000\\000\\\n \\000\\000\\090\\000\\000\\000\\049\\000\\090\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\052\\000\\000\\000\\\n \\090\\000\\000\\000\\000\\000\\000\\000\\048\\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\\049\\000\\049\\000\\049\\000\\000\\000\\\n \\000\\000\\179\\000\\048\\000\\049\\000\\048\\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\\049\\000\\049\\000\\049\\000\\095\\000\\\n \\000\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\\n \\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\\n \\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\\n \\095\\000\\095\\000\\095\\000\\178\\000\\094\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\000\\000\\\n \\177\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\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\\000\\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\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\050\\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\\051\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\050\\000\\000\\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\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\050\\000\\123\\000\\\n \\123\\000\\123\\000\\123\\000\\123\\000\\123\\000\\123\\000\\123\\000\\123\\000\\\n \\123\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\123\\000\\123\\000\\123\\000\\123\\000\\123\\000\\123\\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 \\123\\000\\123\\000\\123\\000\\123\\000\\123\\000\\123\\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\\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\\000\\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\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\000\\000\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\053\\000\\000\\000\\000\\000\\053\\000\\\n \\053\\000\\053\\000\\000\\000\\000\\000\\000\\000\\053\\000\\053\\000\\000\\000\\\n \\053\\000\\053\\000\\053\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\053\\000\\000\\000\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\000\\000\\000\\000\\097\\000\\000\\000\\\n \\056\\000\\097\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\059\\000\\000\\000\\097\\000\\000\\000\\000\\000\\\n \\000\\000\\053\\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\\056\\000\\056\\000\\056\\000\\000\\000\\000\\000\\000\\000\\053\\000\\\n \\056\\000\\053\\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\\056\\000\\056\\000\\056\\000\\102\\000\\000\\000\\102\\000\\102\\000\\\n \\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\\n \\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\\n \\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\\n \\178\\000\\101\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\000\\000\\177\\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\\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 \\000\\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\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\057\\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\\058\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\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\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\057\\000\\000\\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\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\057\\000\\057\\000\\057\\000\\124\\000\\124\\000\\124\\000\\124\\000\\\n \\124\\000\\124\\000\\124\\000\\124\\000\\124\\000\\124\\000\\187\\000\\000\\000\\\n \\000\\000\\188\\000\\000\\000\\000\\000\\000\\000\\124\\000\\124\\000\\124\\000\\\n \\124\\000\\124\\000\\124\\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\\189\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\124\\000\\124\\000\\124\\000\\\n \\124\\000\\124\\000\\124\\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\\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 \\185\\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\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\034\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\034\\000\\000\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\061\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\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\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\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\\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\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\000\\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\\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 \\000\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\062\\000\\000\\000\\062\\000\\034\\000\\000\\000\\000\\000\\062\\000\\\n \\062\\000\\000\\000\\062\\000\\000\\000\\062\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\000\\000\\\n \\000\\000\\062\\000\\062\\000\\062\\000\\000\\000\\062\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\000\\000\\000\\000\\000\\000\\062\\000\\034\\000\\000\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\000\\000\\062\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\180\\000\\000\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\000\\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\\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\\033\\000\\034\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\034\\000\\181\\000\\034\\000\\034\\000\\\n \\034\\000\\064\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\000\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\000\\000\\000\\000\\000\\000\\000\\000\\180\\000\\\n \\000\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\000\\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\\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\\033\\000\\000\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\065\\000\\000\\000\\065\\000\\\n \\034\\000\\000\\000\\000\\000\\065\\000\\065\\000\\000\\000\\065\\000\\000\\000\\\n \\065\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\000\\000\\000\\000\\065\\000\\065\\000\\065\\000\\\n \\000\\000\\065\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\000\\000\\000\\000\\000\\000\\065\\000\\\n \\034\\000\\000\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\000\\000\\065\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\184\\000\\000\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\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\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\000\\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\\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 \\000\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\066\\000\\000\\000\\000\\000\\000\\000\\083\\000\\000\\000\\083\\000\\\n \\000\\000\\000\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\\n \\082\\000\\082\\000\\082\\000\\082\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\066\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\067\\000\\066\\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\\000\\000\\000\\000\\000\\000\\000\\000\\068\\000\\000\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\067\\000\\066\\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\\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\066\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\081\\000\\081\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\066\\000\\\n \\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\066\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\066\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\073\\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\\066\\000\\\n \\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\066\\000\\000\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\073\\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\\066\\000\\\n \\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\074\\000\\000\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\073\\000\\073\\000\\073\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\075\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\073\\000\\000\\000\\073\\000\\073\\000\\073\\000\\073\\000\\073\\000\\\n \\073\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\075\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\066\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\000\\000\\000\\000\\000\\000\\000\\000\\074\\000\\000\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\079\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\066\\000\\000\\000\\000\\000\\000\\000\\077\\000\\000\\000\\077\\000\\\n \\000\\000\\000\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\066\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\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\\000\\000\\000\\000\\000\\000\\000\\000\\076\\000\\000\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\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\\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\066\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\000\\000\\000\\000\\\n \\000\\000\\077\\000\\000\\000\\077\\000\\000\\000\\000\\000\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\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\\066\\000\\\n \\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\066\\000\\000\\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\\066\\000\\\n \\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\066\\000\\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\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\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\080\\000\\000\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\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\\066\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\081\\000\\081\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\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 \\069\\000\\000\\000\\000\\000\\000\\000\\000\\000\\081\\000\\000\\000\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\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 \\069\\000\\066\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\\n \\082\\000\\082\\000\\082\\000\\082\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\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\\078\\000\\078\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\082\\000\\000\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\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\\078\\000\\078\\000\\090\\000\\000\\000\\000\\000\\\n \\090\\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\\090\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\089\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\092\\000\\000\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\089\\000\\000\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\090\\000\\\n \\091\\000\\000\\000\\090\\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\\090\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\093\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\092\\000\\000\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\000\\000\\000\\000\\000\\000\\000\\000\\093\\000\\000\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\097\\000\\091\\000\\000\\000\\097\\000\\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 \\097\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\096\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\099\\000\\000\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\000\\000\\000\\000\\000\\000\\000\\000\\096\\000\\\n \\000\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\097\\000\\098\\000\\000\\000\\097\\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\\097\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\100\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\099\\000\\000\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\100\\000\\000\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\114\\000\\098\\000\\114\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\114\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\113\\000\\113\\000\\113\\000\\\n \\113\\000\\113\\000\\113\\000\\113\\000\\113\\000\\113\\000\\113\\000\\131\\000\\\n \\000\\000\\000\\000\\131\\000\\131\\000\\131\\000\\000\\000\\000\\000\\000\\000\\\n \\131\\000\\131\\000\\000\\000\\131\\000\\131\\000\\131\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\131\\000\\000\\000\\131\\000\\131\\000\\131\\000\\131\\000\\131\\000\\000\\000\\\n \\000\\000\\114\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\114\\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\\114\\000\\112\\000\\000\\000\\000\\000\\114\\000\\\n \\000\\000\\114\\000\\000\\000\\000\\000\\131\\000\\111\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\133\\000\\000\\000\\133\\000\\133\\000\\133\\000\\133\\000\\\n \\000\\000\\000\\000\\000\\000\\133\\000\\133\\000\\000\\000\\133\\000\\133\\000\\\n \\133\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\131\\000\\133\\000\\131\\000\\133\\000\\133\\000\\133\\000\\\n \\133\\000\\133\\000\\000\\000\\000\\000\\000\\000\\006\\000\\000\\000\\000\\000\\\n \\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\000\\000\\006\\000\\006\\000\\\n \\000\\000\\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\000\\133\\000\\\n \\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\135\\000\\000\\000\\000\\000\\135\\000\\135\\000\\135\\000\\\n \\000\\000\\000\\000\\000\\000\\135\\000\\135\\000\\000\\000\\135\\000\\135\\000\\\n \\135\\000\\000\\000\\000\\000\\000\\000\\000\\000\\133\\000\\000\\000\\133\\000\\\n \\000\\000\\000\\000\\006\\000\\135\\000\\000\\000\\135\\000\\135\\000\\135\\000\\\n \\135\\000\\135\\000\\000\\000\\000\\000\\000\\000\\135\\000\\000\\000\\000\\000\\\n \\135\\000\\135\\000\\135\\000\\000\\000\\000\\000\\000\\000\\135\\000\\135\\000\\\n \\000\\000\\135\\000\\135\\000\\135\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\006\\000\\000\\000\\006\\000\\000\\000\\000\\000\\255\\255\\135\\000\\135\\000\\\n \\135\\000\\135\\000\\135\\000\\135\\000\\135\\000\\000\\000\\000\\000\\000\\000\\\n \\135\\000\\000\\000\\000\\000\\135\\000\\135\\000\\135\\000\\000\\000\\000\\000\\\n \\000\\000\\135\\000\\135\\000\\000\\000\\135\\000\\135\\000\\135\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\135\\000\\000\\000\\135\\000\\\n \\000\\000\\135\\000\\135\\000\\135\\000\\135\\000\\135\\000\\135\\000\\135\\000\\\n \\000\\000\\000\\000\\000\\000\\006\\000\\000\\000\\000\\000\\006\\000\\006\\000\\\n \\006\\000\\000\\000\\000\\000\\000\\000\\006\\000\\006\\000\\000\\000\\006\\000\\\n \\006\\000\\006\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\135\\000\\000\\000\\135\\000\\000\\000\\006\\000\\135\\000\\006\\000\\006\\000\\\n \\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\000\\000\\006\\000\\000\\000\\\n \\000\\000\\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\000\\000\\006\\000\\\n \\006\\000\\000\\000\\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\135\\000\\000\\000\\135\\000\\000\\000\\006\\000\\\n \\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\006\\000\\000\\000\\000\\000\\\n \\000\\000\\155\\000\\000\\000\\155\\000\\155\\000\\155\\000\\155\\000\\000\\000\\\n \\000\\000\\000\\000\\155\\000\\155\\000\\000\\000\\155\\000\\155\\000\\155\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\000\\000\\000\\\n \\006\\000\\000\\000\\155\\000\\006\\000\\155\\000\\155\\000\\155\\000\\155\\000\\\n \\155\\000\\000\\000\\000\\000\\000\\000\\155\\000\\000\\000\\155\\000\\155\\000\\\n \\155\\000\\155\\000\\000\\000\\000\\000\\000\\000\\155\\000\\155\\000\\000\\000\\\n \\155\\000\\155\\000\\155\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\006\\000\\000\\000\\006\\000\\000\\000\\155\\000\\155\\000\\155\\000\\\n \\155\\000\\155\\000\\155\\000\\155\\000\\000\\000\\000\\000\\000\\000\\135\\000\\\n \\000\\000\\000\\000\\135\\000\\135\\000\\135\\000\\000\\000\\000\\000\\000\\000\\\n \\135\\000\\135\\000\\000\\000\\135\\000\\135\\000\\135\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\155\\000\\000\\000\\155\\000\\000\\000\\\n \\135\\000\\155\\000\\135\\000\\135\\000\\135\\000\\135\\000\\135\\000\\000\\000\\\n \\000\\000\\000\\000\\135\\000\\000\\000\\000\\000\\135\\000\\135\\000\\135\\000\\\n \\000\\000\\000\\000\\000\\000\\135\\000\\135\\000\\000\\000\\135\\000\\135\\000\\\n \\135\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\155\\000\\\n \\000\\000\\155\\000\\000\\000\\135\\000\\135\\000\\135\\000\\135\\000\\135\\000\\\n \\135\\000\\135\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\167\\000\\000\\000\\000\\000\\168\\000\\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\\135\\000\\000\\000\\135\\000\\000\\000\\000\\000\\135\\000\\\n \\000\\000\\172\\000\\000\\000\\000\\000\\000\\000\\000\\000\\170\\000\\174\\000\\\n \\000\\000\\173\\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\\135\\000\\000\\000\\135\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\000\\000\\000\\000\\000\\000\\000\\000\\166\\000\\000\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\171\\000\\166\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\166\\000\\000\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\182\\000\\000\\000\\000\\000\\182\\000\\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 \\182\\000\\000\\000\\000\\000\\000\\000\\000\\000\\182\\000\\000\\000\\180\\000\\\n \\182\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\183\\000\\169\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\000\\000\\000\\000\\182\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\000\\000\\000\\000\\000\\000\\000\\000\\180\\000\\\n \\000\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\178\\000\\177\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\182\\000\\\n \\177\\000\\000\\000\\182\\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\\182\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\184\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\183\\000\\000\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\000\\000\\000\\000\\000\\000\\000\\000\\184\\000\\000\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\195\\000\\177\\000\\195\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\195\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\194\\000\\194\\000\\194\\000\\194\\000\\194\\000\\194\\000\\194\\000\\\n \\194\\000\\194\\000\\194\\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\\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\\n \\205\\000\\205\\000\\205\\000\\205\\000\\205\\000\\195\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\195\\000\\205\\000\\205\\000\\205\\000\\205\\000\\\n \\205\\000\\205\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\195\\000\\\n \\193\\000\\000\\000\\000\\000\\195\\000\\221\\000\\195\\000\\000\\000\\222\\000\\\n \\000\\000\\192\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\205\\000\\205\\000\\205\\000\\205\\000\\\n \\205\\000\\205\\000\\220\\000\\000\\000\\220\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\220\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\219\\000\\219\\000\\219\\000\\219\\000\\219\\000\\219\\000\\\n \\219\\000\\219\\000\\219\\000\\219\\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\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\220\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\220\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\220\\000\\218\\000\\000\\000\\000\\000\\220\\000\\000\\000\\220\\000\\216\\000\\\n \\000\\000\\000\\000\\217\\000\\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\\n \\230\\000\\230\\000\\230\\000\\230\\000\\230\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\000\\000\\230\\000\\230\\000\\230\\000\\230\\000\\\n \\230\\000\\230\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\232\\000\\232\\000\\232\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\000\\000\\000\\000\\000\\000\\230\\000\\230\\000\\230\\000\\230\\000\\\n \\230\\000\\230\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\232\\000\\000\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\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\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\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\\255\\255\\000\\000\\243\\000\\233\\000\\243\\000\\243\\000\\\n \\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\\n \\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\\n \\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\\n \\000\\000\\000\\000\\242\\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\";\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\\043\\000\\000\\000\\000\\000\\043\\000\\044\\000\\\n \\046\\000\\047\\000\\044\\000\\046\\000\\047\\000\\107\\000\\168\\000\\188\\000\\\n \\107\\000\\168\\000\\188\\000\\207\\000\\212\\000\\251\\000\\207\\000\\212\\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\\016\\000\\\n \\013\\000\\017\\000\\025\\000\\041\\000\\017\\000\\017\\000\\041\\000\\077\\000\\\n \\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\077\\000\\\n \\077\\000\\105\\000\\106\\000\\114\\000\\117\\000\\121\\000\\124\\000\\013\\000\\\n \\143\\000\\013\\000\\041\\000\\013\\000\\083\\000\\083\\000\\083\\000\\083\\000\\\n \\083\\000\\083\\000\\083\\000\\083\\000\\083\\000\\083\\000\\112\\000\\112\\000\\\n \\112\\000\\112\\000\\112\\000\\112\\000\\112\\000\\112\\000\\113\\000\\113\\000\\\n \\113\\000\\113\\000\\113\\000\\113\\000\\113\\000\\113\\000\\113\\000\\113\\000\\\n \\119\\000\\119\\000\\119\\000\\119\\000\\119\\000\\119\\000\\119\\000\\119\\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\\013\\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\\144\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\003\\000\\126\\000\\126\\000\\003\\000\\003\\000\\003\\000\\128\\000\\\n \\128\\000\\026\\000\\003\\000\\003\\000\\026\\000\\003\\000\\003\\000\\003\\000\\\n \\116\\000\\116\\000\\116\\000\\116\\000\\116\\000\\116\\000\\116\\000\\116\\000\\\n \\116\\000\\116\\000\\003\\000\\148\\000\\003\\000\\003\\000\\003\\000\\003\\000\\\n \\003\\000\\130\\000\\130\\000\\173\\000\\004\\000\\174\\000\\026\\000\\004\\000\\\n \\004\\000\\004\\000\\186\\000\\187\\000\\195\\000\\004\\000\\004\\000\\162\\000\\\n \\004\\000\\004\\000\\004\\000\\120\\000\\120\\000\\120\\000\\120\\000\\120\\000\\\n \\120\\000\\120\\000\\120\\000\\198\\000\\202\\000\\004\\000\\003\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\205\\000\\216\\000\\162\\000\\005\\000\\\n \\162\\000\\244\\000\\005\\000\\005\\000\\005\\000\\245\\000\\248\\000\\250\\000\\\n \\005\\000\\005\\000\\221\\000\\005\\000\\005\\000\\005\\000\\193\\000\\193\\000\\\n \\193\\000\\193\\000\\161\\000\\026\\000\\003\\000\\161\\000\\003\\000\\255\\255\\\n \\005\\000\\004\\000\\005\\000\\005\\000\\005\\000\\005\\000\\005\\000\\255\\255\\\n \\222\\000\\221\\000\\006\\000\\222\\000\\246\\000\\006\\000\\006\\000\\006\\000\\\n \\255\\255\\255\\255\\161\\000\\006\\000\\006\\000\\247\\000\\006\\000\\006\\000\\\n \\006\\000\\223\\000\\255\\255\\234\\000\\223\\000\\163\\000\\234\\000\\004\\000\\\n \\163\\000\\004\\000\\255\\255\\006\\000\\005\\000\\006\\000\\006\\000\\006\\000\\\n \\006\\000\\006\\000\\255\\255\\240\\000\\241\\000\\007\\000\\240\\000\\241\\000\\\n \\007\\000\\007\\000\\007\\000\\255\\255\\255\\255\\255\\255\\007\\000\\007\\000\\\n \\249\\000\\007\\000\\007\\000\\007\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\235\\000\\255\\255\\005\\000\\235\\000\\005\\000\\255\\255\\007\\000\\006\\000\\\n \\007\\000\\007\\000\\007\\000\\007\\000\\007\\000\\255\\255\\255\\255\\255\\255\\\n \\008\\000\\255\\255\\008\\000\\008\\000\\008\\000\\008\\000\\255\\255\\255\\255\\\n \\255\\255\\008\\000\\008\\000\\255\\255\\008\\000\\008\\000\\008\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\006\\000\\255\\255\\006\\000\\\n \\255\\255\\008\\000\\007\\000\\008\\000\\008\\000\\008\\000\\008\\000\\008\\000\\\n \\255\\255\\255\\255\\255\\255\\010\\000\\255\\255\\255\\255\\010\\000\\010\\000\\\n \\010\\000\\255\\255\\255\\255\\255\\255\\010\\000\\010\\000\\255\\255\\010\\000\\\n \\010\\000\\010\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\007\\000\\255\\255\\007\\000\\255\\255\\010\\000\\008\\000\\010\\000\\010\\000\\\n \\010\\000\\010\\000\\010\\000\\255\\255\\255\\255\\255\\255\\208\\000\\255\\255\\\n \\011\\000\\208\\000\\255\\255\\011\\000\\011\\000\\011\\000\\255\\255\\026\\000\\\n \\255\\255\\011\\000\\011\\000\\255\\255\\011\\000\\011\\000\\011\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\008\\000\\255\\255\\008\\000\\208\\000\\010\\000\\\n \\010\\000\\011\\000\\235\\000\\011\\000\\011\\000\\011\\000\\011\\000\\011\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\014\\000\\255\\255\\255\\255\\\n \\014\\000\\014\\000\\014\\000\\255\\255\\255\\255\\255\\255\\014\\000\\014\\000\\\n \\255\\255\\014\\000\\014\\000\\014\\000\\255\\255\\255\\255\\010\\000\\010\\000\\\n \\010\\000\\255\\255\\255\\255\\255\\255\\011\\000\\011\\000\\014\\000\\255\\255\\\n \\014\\000\\014\\000\\014\\000\\014\\000\\014\\000\\255\\255\\255\\255\\255\\255\\\n \\015\\000\\255\\255\\255\\255\\015\\000\\015\\000\\015\\000\\255\\255\\255\\255\\\n \\208\\000\\015\\000\\015\\000\\255\\255\\015\\000\\015\\000\\015\\000\\255\\255\\\n \\161\\000\\255\\255\\255\\255\\011\\000\\255\\255\\011\\000\\255\\255\\255\\255\\\n \\255\\255\\015\\000\\014\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\255\\255\\255\\255\\246\\000\\018\\000\\255\\255\\255\\255\\018\\000\\018\\000\\\n \\018\\000\\255\\255\\255\\255\\247\\000\\018\\000\\018\\000\\255\\255\\018\\000\\\n \\018\\000\\018\\000\\255\\255\\163\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\014\\000\\255\\255\\014\\000\\255\\255\\018\\000\\015\\000\\018\\000\\018\\000\\\n \\018\\000\\018\\000\\018\\000\\255\\255\\255\\255\\255\\255\\022\\000\\255\\255\\\n \\255\\255\\022\\000\\022\\000\\022\\000\\255\\255\\255\\255\\249\\000\\022\\000\\\n \\022\\000\\255\\255\\022\\000\\022\\000\\022\\000\\255\\255\\235\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\015\\000\\255\\255\\015\\000\\255\\255\\022\\000\\\n \\018\\000\\022\\000\\022\\000\\022\\000\\022\\000\\022\\000\\255\\255\\255\\255\\\n \\255\\255\\023\\000\\255\\255\\023\\000\\023\\000\\023\\000\\023\\000\\255\\255\\\n \\255\\255\\255\\255\\023\\000\\023\\000\\255\\255\\023\\000\\023\\000\\023\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\018\\000\\255\\255\\\n \\018\\000\\255\\255\\023\\000\\022\\000\\023\\000\\023\\000\\023\\000\\023\\000\\\n \\023\\000\\159\\000\\255\\255\\255\\255\\024\\000\\255\\255\\255\\255\\024\\000\\\n \\024\\000\\024\\000\\255\\255\\255\\255\\024\\000\\024\\000\\024\\000\\255\\255\\\n \\024\\000\\024\\000\\024\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\159\\000\\022\\000\\255\\255\\022\\000\\255\\255\\024\\000\\023\\000\\024\\000\\\n \\024\\000\\024\\000\\024\\000\\024\\000\\208\\000\\255\\255\\027\\000\\255\\255\\\n \\159\\000\\159\\000\\159\\000\\159\\000\\159\\000\\159\\000\\159\\000\\159\\000\\\n \\159\\000\\159\\000\\194\\000\\194\\000\\194\\000\\194\\000\\194\\000\\194\\000\\\n \\194\\000\\194\\000\\194\\000\\194\\000\\023\\000\\027\\000\\023\\000\\255\\255\\\n \\087\\000\\024\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\087\\000\\\n \\087\\000\\087\\000\\087\\000\\087\\000\\255\\255\\087\\000\\255\\255\\024\\000\\\n \\027\\000\\024\\000\\027\\000\\027\\000\\027\\000\\027\\000\\027\\000\\027\\000\\\n \\027\\000\\027\\000\\027\\000\\027\\000\\027\\000\\027\\000\\027\\000\\027\\000\\\n \\027\\000\\027\\000\\027\\000\\027\\000\\027\\000\\027\\000\\027\\000\\027\\000\\\n \\027\\000\\027\\000\\027\\000\\027\\000\\029\\000\\027\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\029\\000\\255\\255\\029\\000\\029\\000\\029\\000\\\n \\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\029\\000\\029\\000\\\n \\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\\n \\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\\n \\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\029\\000\\255\\255\\029\\000\\029\\000\\\n \\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\\n \\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\\n \\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\029\\000\\\n \\030\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\030\\000\\\n \\255\\255\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\\n \\030\\000\\030\\000\\030\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\\n \\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\\n \\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\\n \\030\\000\\030\\000\\030\\000\\030\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\030\\000\\255\\255\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\\n \\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\\n \\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\030\\000\\\n \\030\\000\\030\\000\\030\\000\\030\\000\\031\\000\\200\\000\\200\\000\\200\\000\\\n \\200\\000\\200\\000\\200\\000\\200\\000\\200\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\031\\000\\255\\255\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\255\\255\\062\\000\\255\\255\\255\\255\\062\\000\\062\\000\\062\\000\\255\\255\\\n \\255\\255\\255\\255\\062\\000\\062\\000\\255\\255\\062\\000\\255\\255\\062\\000\\\n \\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\197\\000\\\n \\197\\000\\197\\000\\062\\000\\255\\255\\255\\255\\062\\000\\062\\000\\062\\000\\\n \\062\\000\\255\\255\\095\\000\\255\\255\\095\\000\\095\\000\\095\\000\\095\\000\\\n \\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\\n \\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\\n \\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\095\\000\\062\\000\\095\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\062\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\032\\000\\031\\000\\031\\000\\031\\000\\\n \\031\\000\\031\\000\\031\\000\\031\\000\\031\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\032\\000\\255\\255\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\255\\255\\065\\000\\255\\255\\255\\255\\065\\000\\065\\000\\065\\000\\255\\255\\\n \\255\\255\\255\\255\\065\\000\\065\\000\\255\\255\\065\\000\\255\\255\\065\\000\\\n \\201\\000\\201\\000\\201\\000\\201\\000\\201\\000\\201\\000\\201\\000\\201\\000\\\n \\255\\255\\255\\255\\065\\000\\255\\255\\255\\255\\065\\000\\065\\000\\065\\000\\\n \\065\\000\\255\\255\\102\\000\\255\\255\\102\\000\\102\\000\\102\\000\\102\\000\\\n \\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\\n \\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\\n \\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\102\\000\\065\\000\\102\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\065\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\033\\000\\032\\000\\032\\000\\032\\000\\\n \\032\\000\\032\\000\\032\\000\\032\\000\\032\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\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\\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 \\255\\255\\255\\255\\255\\255\\255\\255\\033\\000\\085\\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\\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 \\255\\255\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\255\\255\\255\\255\\255\\255\\255\\255\\085\\000\\\n \\255\\255\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\218\\000\\218\\000\\218\\000\\218\\000\\218\\000\\\n \\218\\000\\218\\000\\218\\000\\255\\255\\255\\255\\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\\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\255\\255\\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\\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\\033\\000\\034\\000\\033\\000\\033\\000\\033\\000\\\n \\033\\000\\033\\000\\033\\000\\033\\000\\033\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\034\\000\\255\\255\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\255\\255\\255\\255\\255\\255\\255\\255\\088\\000\\255\\255\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\219\\000\\219\\000\\219\\000\\219\\000\\219\\000\\219\\000\\\n \\219\\000\\219\\000\\219\\000\\219\\000\\255\\255\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\255\\255\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\035\\000\\034\\000\\034\\000\\034\\000\\\n \\034\\000\\034\\000\\034\\000\\034\\000\\034\\000\\035\\000\\035\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\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\\035\\000\\035\\000\\035\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\035\\000\\255\\255\\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\\035\\000\\035\\000\\035\\000\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\092\\000\\255\\255\\255\\255\\255\\255\\255\\255\\092\\000\\255\\255\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\092\\000\\224\\000\\224\\000\\224\\000\\224\\000\\224\\000\\224\\000\\\n \\224\\000\\224\\000\\224\\000\\224\\000\\255\\255\\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\\255\\255\\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\\035\\000\\035\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\035\\000\\036\\000\\035\\000\\035\\000\\035\\000\\\n \\035\\000\\035\\000\\035\\000\\035\\000\\035\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\036\\000\\255\\255\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\255\\255\\255\\255\\255\\255\\255\\255\\099\\000\\255\\255\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\226\\000\\\n \\226\\000\\226\\000\\255\\255\\255\\255\\255\\255\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\255\\255\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\255\\255\\036\\000\\036\\000\\036\\000\\\n \\036\\000\\036\\000\\036\\000\\036\\000\\036\\000\\037\\000\\160\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\255\\255\\255\\255\\255\\255\\037\\000\\037\\000\\\n \\255\\255\\037\\000\\037\\000\\037\\000\\227\\000\\227\\000\\227\\000\\227\\000\\\n \\227\\000\\227\\000\\227\\000\\227\\000\\255\\255\\160\\000\\037\\000\\160\\000\\\n \\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\160\\000\\160\\000\\160\\000\\\n \\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\160\\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\\037\\000\\037\\000\\255\\255\\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\\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\\255\\255\\\n \\037\\000\\038\\000\\037\\000\\255\\255\\038\\000\\038\\000\\038\\000\\066\\000\\\n \\255\\255\\255\\255\\038\\000\\038\\000\\255\\255\\038\\000\\038\\000\\038\\000\\\n \\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\066\\000\\\n \\066\\000\\066\\000\\038\\000\\255\\255\\255\\255\\038\\000\\038\\000\\038\\000\\\n \\038\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\255\\255\\255\\255\\255\\255\\038\\000\\066\\000\\\n \\255\\255\\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\\066\\000\\\n \\066\\000\\066\\000\\066\\000\\255\\255\\038\\000\\255\\255\\038\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\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\\037\\000\\037\\000\\037\\000\\037\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\255\\255\\037\\000\\037\\000\\037\\000\\037\\000\\\n \\037\\000\\037\\000\\037\\000\\037\\000\\039\\000\\255\\255\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\255\\255\\255\\255\\255\\255\\039\\000\\039\\000\\255\\255\\\n \\039\\000\\039\\000\\039\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\039\\000\\255\\255\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\255\\255\\237\\000\\255\\255\\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\\237\\000\\\n \\237\\000\\039\\000\\039\\000\\237\\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\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\040\\000\\039\\000\\\n \\255\\255\\039\\000\\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\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\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\\040\\000\\255\\255\\255\\255\\255\\255\\255\\255\\040\\000\\255\\255\\\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\\040\\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\\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\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\255\\255\\039\\000\\039\\000\\039\\000\\039\\000\\039\\000\\\n \\039\\000\\039\\000\\039\\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\\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\\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\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\255\\255\\040\\000\\\n \\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\040\\000\\048\\000\\\n \\255\\255\\048\\000\\048\\000\\048\\000\\048\\000\\255\\255\\255\\255\\255\\255\\\n \\048\\000\\048\\000\\255\\255\\048\\000\\048\\000\\048\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\048\\000\\255\\255\\048\\000\\048\\000\\048\\000\\048\\000\\048\\000\\255\\255\\\n \\255\\255\\090\\000\\255\\255\\049\\000\\090\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\049\\000\\255\\255\\\n \\090\\000\\255\\255\\255\\255\\255\\255\\048\\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\\049\\000\\049\\000\\049\\000\\255\\255\\\n \\255\\255\\171\\000\\048\\000\\049\\000\\048\\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\\049\\000\\049\\000\\049\\000\\090\\000\\\n \\255\\255\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\\n \\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\090\\000\\\n \\090\\000\\090\\000\\090\\000\\171\\000\\090\\000\\171\\000\\171\\000\\171\\000\\\n \\171\\000\\171\\000\\171\\000\\171\\000\\171\\000\\171\\000\\171\\000\\171\\000\\\n \\171\\000\\171\\000\\171\\000\\171\\000\\171\\000\\171\\000\\171\\000\\171\\000\\\n \\171\\000\\171\\000\\171\\000\\171\\000\\171\\000\\171\\000\\171\\000\\255\\255\\\n \\171\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\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\\255\\255\\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\\049\\000\\049\\000\\049\\000\\049\\000\\\n \\049\\000\\049\\000\\049\\000\\050\\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\\050\\000\\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\\111\\000\\\n \\111\\000\\111\\000\\111\\000\\111\\000\\111\\000\\111\\000\\111\\000\\111\\000\\\n \\111\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\111\\000\\111\\000\\111\\000\\111\\000\\111\\000\\111\\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 \\111\\000\\111\\000\\111\\000\\111\\000\\111\\000\\111\\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\\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\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\255\\255\\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\\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\\255\\255\\050\\000\\050\\000\\050\\000\\050\\000\\\n \\050\\000\\050\\000\\050\\000\\050\\000\\053\\000\\255\\255\\255\\255\\053\\000\\\n \\053\\000\\053\\000\\255\\255\\255\\255\\255\\255\\053\\000\\053\\000\\255\\255\\\n \\053\\000\\053\\000\\053\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\053\\000\\255\\255\\053\\000\\\n \\053\\000\\053\\000\\053\\000\\053\\000\\255\\255\\255\\255\\097\\000\\255\\255\\\n \\056\\000\\097\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\056\\000\\056\\000\\056\\000\\056\\000\\255\\255\\097\\000\\255\\255\\255\\255\\\n \\255\\255\\053\\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\\056\\000\\056\\000\\056\\000\\255\\255\\255\\255\\255\\255\\053\\000\\\n \\056\\000\\053\\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\\056\\000\\056\\000\\056\\000\\097\\000\\255\\255\\097\\000\\097\\000\\\n \\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\097\\000\\\n \\178\\000\\097\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\178\\000\\\n \\178\\000\\178\\000\\178\\000\\178\\000\\255\\255\\178\\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\\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 \\255\\255\\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\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\056\\000\\\n \\057\\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\\057\\000\\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\\123\\000\\123\\000\\123\\000\\123\\000\\\n \\123\\000\\123\\000\\123\\000\\123\\000\\123\\000\\123\\000\\170\\000\\255\\255\\\n \\255\\255\\170\\000\\255\\255\\255\\255\\255\\255\\123\\000\\123\\000\\123\\000\\\n \\123\\000\\123\\000\\123\\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\\170\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\123\\000\\123\\000\\123\\000\\\n \\123\\000\\123\\000\\123\\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\\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\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\170\\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\\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 \\060\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\057\\000\\\n \\057\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\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\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\060\\000\\255\\255\\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\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\192\\000\\192\\000\\192\\000\\192\\000\\\n \\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\192\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\192\\000\\192\\000\\192\\000\\\n \\192\\000\\192\\000\\192\\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\\170\\000\\192\\000\\192\\000\\192\\000\\\n \\192\\000\\192\\000\\192\\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\\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\\060\\000\\060\\000\\060\\000\\\n \\255\\255\\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\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\255\\255\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\060\\000\\\n \\060\\000\\061\\000\\255\\255\\061\\000\\061\\000\\255\\255\\255\\255\\061\\000\\\n \\061\\000\\255\\255\\061\\000\\255\\255\\061\\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\\061\\000\\061\\000\\061\\000\\255\\255\\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 \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\\n \\255\\255\\255\\255\\255\\255\\061\\000\\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 \\255\\255\\061\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\181\\000\\255\\255\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\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 \\061\\000\\061\\000\\061\\000\\061\\000\\255\\255\\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 \\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\\063\\000\\061\\000\\061\\000\\061\\000\\\n \\061\\000\\061\\000\\061\\000\\061\\000\\061\\000\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\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\\063\\000\\063\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\063\\000\\179\\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\\063\\000\\063\\000\\\n \\255\\255\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\255\\255\\255\\255\\255\\255\\255\\255\\179\\000\\\n \\255\\255\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\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\\255\\255\\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\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\255\\255\\063\\000\\063\\000\\063\\000\\\n \\063\\000\\063\\000\\063\\000\\063\\000\\063\\000\\064\\000\\255\\255\\064\\000\\\n \\064\\000\\255\\255\\255\\255\\064\\000\\064\\000\\255\\255\\064\\000\\255\\255\\\n \\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\064\\000\\064\\000\\255\\255\\255\\255\\064\\000\\064\\000\\064\\000\\\n \\255\\255\\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\\064\\000\\064\\000\\064\\000\\255\\255\\255\\255\\255\\255\\064\\000\\\n \\064\\000\\255\\255\\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\\064\\000\\064\\000\\064\\000\\255\\255\\064\\000\\183\\000\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\183\\000\\255\\255\\183\\000\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\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 \\255\\255\\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\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\255\\255\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\064\\000\\\n \\064\\000\\067\\000\\255\\255\\255\\255\\255\\255\\067\\000\\255\\255\\067\\000\\\n \\255\\255\\255\\255\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\067\\000\\\n \\067\\000\\067\\000\\067\\000\\067\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\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\\067\\000\\067\\000\\067\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\067\\000\\255\\255\\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\\067\\000\\067\\000\\067\\000\\068\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\068\\000\\068\\000\\\n \\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\068\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\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\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\255\\255\\255\\255\\255\\255\\255\\255\\068\\000\\255\\255\\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\\068\\000\\068\\000\\068\\000\\\n \\068\\000\\069\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\\n \\069\\000\\069\\000\\069\\000\\069\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\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 \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\069\\000\\255\\255\\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 \\069\\000\\069\\000\\069\\000\\069\\000\\069\\000\\070\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\070\\000\\070\\000\\\n \\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\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\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\255\\255\\255\\255\\255\\255\\255\\255\\070\\000\\255\\255\\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\\070\\000\\070\\000\\070\\000\\070\\000\\070\\000\\\n \\070\\000\\071\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\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\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\071\\000\\255\\255\\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\\071\\000\\071\\000\\\n \\071\\000\\071\\000\\071\\000\\071\\000\\071\\000\\072\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\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\\255\\255\\255\\255\\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\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\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\\073\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\073\\000\\255\\255\\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\\073\\000\\074\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\074\\000\\074\\000\\\n \\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\074\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\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\\074\\000\\\n \\074\\000\\255\\255\\255\\255\\255\\255\\255\\255\\074\\000\\255\\255\\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\\074\\000\\\n \\074\\000\\075\\000\\255\\255\\255\\255\\255\\255\\075\\000\\255\\255\\075\\000\\\n \\255\\255\\255\\255\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\075\\000\\\n \\075\\000\\075\\000\\075\\000\\075\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\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\\075\\000\\075\\000\\075\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\075\\000\\255\\255\\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\\075\\000\\075\\000\\075\\000\\076\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\076\\000\\076\\000\\\n \\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\076\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\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\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\255\\255\\255\\255\\255\\255\\255\\255\\076\\000\\255\\255\\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\\076\\000\\076\\000\\076\\000\\\n \\076\\000\\078\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\078\\000\\\n \\078\\000\\078\\000\\078\\000\\078\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\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\\078\\000\\078\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\078\\000\\255\\255\\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\\078\\000\\078\\000\\079\\000\\255\\255\\255\\255\\\n \\255\\255\\079\\000\\255\\255\\079\\000\\255\\255\\255\\255\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\255\\255\\255\\255\\255\\255\\255\\255\\079\\000\\255\\255\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\079\\000\\\n \\079\\000\\080\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\080\\000\\255\\255\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\\n \\080\\000\\080\\000\\080\\000\\080\\000\\080\\000\\081\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\255\\255\\255\\255\\255\\255\\255\\255\\081\\000\\255\\255\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\081\\000\\\n \\081\\000\\082\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\\n \\082\\000\\082\\000\\082\\000\\082\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\\n \\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\\n \\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\\n \\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\082\\000\\255\\255\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\\n \\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\\n \\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\\n \\082\\000\\082\\000\\082\\000\\082\\000\\082\\000\\089\\000\\255\\255\\255\\255\\\n \\089\\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\\089\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\089\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\089\\000\\255\\255\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\089\\000\\255\\255\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\093\\000\\\n \\089\\000\\255\\255\\093\\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\\093\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\093\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\093\\000\\255\\255\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\255\\255\\255\\255\\255\\255\\255\\255\\093\\000\\255\\255\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\096\\000\\093\\000\\255\\255\\096\\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 \\096\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\096\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\096\\000\\255\\255\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\255\\255\\255\\255\\255\\255\\255\\255\\096\\000\\\n \\255\\255\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\100\\000\\096\\000\\255\\255\\100\\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\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\100\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\100\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\100\\000\\255\\255\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\100\\000\\255\\255\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\104\\000\\100\\000\\104\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\104\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\104\\000\\104\\000\\104\\000\\\n \\104\\000\\104\\000\\104\\000\\104\\000\\104\\000\\104\\000\\104\\000\\131\\000\\\n \\255\\255\\255\\255\\131\\000\\131\\000\\131\\000\\255\\255\\255\\255\\255\\255\\\n \\131\\000\\131\\000\\255\\255\\131\\000\\131\\000\\131\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\131\\000\\255\\255\\131\\000\\131\\000\\131\\000\\131\\000\\131\\000\\255\\255\\\n \\255\\255\\104\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\104\\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\\104\\000\\104\\000\\255\\255\\255\\255\\104\\000\\\n \\255\\255\\104\\000\\255\\255\\255\\255\\131\\000\\104\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\133\\000\\255\\255\\133\\000\\133\\000\\133\\000\\133\\000\\\n \\255\\255\\255\\255\\255\\255\\133\\000\\133\\000\\255\\255\\133\\000\\133\\000\\\n \\133\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\131\\000\\133\\000\\131\\000\\133\\000\\133\\000\\133\\000\\\n \\133\\000\\133\\000\\255\\255\\255\\255\\255\\255\\134\\000\\255\\255\\255\\255\\\n \\134\\000\\134\\000\\134\\000\\255\\255\\255\\255\\255\\255\\134\\000\\134\\000\\\n \\255\\255\\134\\000\\134\\000\\134\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\134\\000\\133\\000\\\n \\134\\000\\134\\000\\134\\000\\134\\000\\134\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\135\\000\\255\\255\\255\\255\\135\\000\\135\\000\\135\\000\\\n \\255\\255\\255\\255\\255\\255\\135\\000\\135\\000\\255\\255\\135\\000\\135\\000\\\n \\135\\000\\255\\255\\255\\255\\255\\255\\255\\255\\133\\000\\255\\255\\133\\000\\\n \\255\\255\\255\\255\\134\\000\\135\\000\\255\\255\\135\\000\\135\\000\\135\\000\\\n \\135\\000\\135\\000\\255\\255\\255\\255\\255\\255\\136\\000\\255\\255\\255\\255\\\n \\136\\000\\136\\000\\136\\000\\255\\255\\255\\255\\255\\255\\136\\000\\136\\000\\\n \\255\\255\\136\\000\\136\\000\\136\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\134\\000\\255\\255\\134\\000\\255\\255\\255\\255\\104\\000\\136\\000\\135\\000\\\n \\136\\000\\136\\000\\136\\000\\136\\000\\136\\000\\255\\255\\255\\255\\255\\255\\\n \\137\\000\\255\\255\\255\\255\\137\\000\\137\\000\\137\\000\\255\\255\\255\\255\\\n \\255\\255\\137\\000\\137\\000\\255\\255\\137\\000\\137\\000\\137\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\135\\000\\255\\255\\135\\000\\\n \\255\\255\\137\\000\\136\\000\\137\\000\\137\\000\\137\\000\\137\\000\\137\\000\\\n \\255\\255\\255\\255\\255\\255\\142\\000\\255\\255\\255\\255\\142\\000\\142\\000\\\n \\142\\000\\255\\255\\255\\255\\255\\255\\142\\000\\142\\000\\255\\255\\142\\000\\\n \\142\\000\\142\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\136\\000\\255\\255\\136\\000\\255\\255\\142\\000\\137\\000\\142\\000\\142\\000\\\n \\142\\000\\142\\000\\142\\000\\255\\255\\255\\255\\255\\255\\152\\000\\255\\255\\\n \\255\\255\\152\\000\\152\\000\\152\\000\\255\\255\\255\\255\\255\\255\\152\\000\\\n \\152\\000\\255\\255\\152\\000\\152\\000\\152\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\137\\000\\255\\255\\137\\000\\255\\255\\152\\000\\\n \\142\\000\\152\\000\\152\\000\\152\\000\\152\\000\\152\\000\\255\\255\\255\\255\\\n \\255\\255\\155\\000\\255\\255\\155\\000\\155\\000\\155\\000\\155\\000\\255\\255\\\n \\255\\255\\255\\255\\155\\000\\155\\000\\255\\255\\155\\000\\155\\000\\155\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\142\\000\\255\\255\\\n \\142\\000\\255\\255\\155\\000\\152\\000\\155\\000\\155\\000\\155\\000\\155\\000\\\n \\155\\000\\255\\255\\255\\255\\255\\255\\156\\000\\255\\255\\156\\000\\156\\000\\\n \\156\\000\\156\\000\\255\\255\\255\\255\\255\\255\\156\\000\\156\\000\\255\\255\\\n \\156\\000\\156\\000\\156\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\152\\000\\255\\255\\152\\000\\255\\255\\156\\000\\155\\000\\156\\000\\\n \\156\\000\\156\\000\\156\\000\\156\\000\\255\\255\\255\\255\\255\\255\\157\\000\\\n \\255\\255\\255\\255\\157\\000\\157\\000\\157\\000\\255\\255\\255\\255\\255\\255\\\n \\157\\000\\157\\000\\255\\255\\157\\000\\157\\000\\157\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\155\\000\\255\\255\\155\\000\\255\\255\\\n \\157\\000\\156\\000\\157\\000\\157\\000\\157\\000\\157\\000\\157\\000\\255\\255\\\n \\255\\255\\255\\255\\158\\000\\255\\255\\255\\255\\158\\000\\158\\000\\158\\000\\\n \\255\\255\\255\\255\\255\\255\\158\\000\\158\\000\\255\\255\\158\\000\\158\\000\\\n \\158\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\156\\000\\\n \\255\\255\\156\\000\\255\\255\\158\\000\\157\\000\\158\\000\\158\\000\\158\\000\\\n \\158\\000\\158\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\164\\000\\255\\255\\255\\255\\164\\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\\157\\000\\255\\255\\157\\000\\255\\255\\255\\255\\158\\000\\\n \\255\\255\\164\\000\\255\\255\\255\\255\\255\\255\\255\\255\\164\\000\\164\\000\\\n \\255\\255\\164\\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\\158\\000\\255\\255\\158\\000\\\n \\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\\n \\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\\n \\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\\n \\164\\000\\164\\000\\255\\255\\255\\255\\255\\255\\255\\255\\164\\000\\255\\255\\\n \\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\\n \\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\\n \\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\164\\000\\\n \\164\\000\\164\\000\\164\\000\\166\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\166\\000\\255\\255\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\\n \\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\166\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\180\\000\\255\\255\\255\\255\\180\\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 \\180\\000\\255\\255\\255\\255\\255\\255\\255\\255\\182\\000\\255\\255\\180\\000\\\n \\182\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\180\\000\\164\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\255\\255\\255\\255\\182\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\255\\255\\255\\255\\255\\255\\255\\255\\180\\000\\\n \\255\\255\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\182\\000\\180\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\\n \\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\182\\000\\184\\000\\\n \\182\\000\\255\\255\\184\\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\\184\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\184\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\184\\000\\255\\255\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\255\\255\\255\\255\\255\\255\\255\\255\\184\\000\\255\\255\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\185\\000\\184\\000\\185\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\185\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\185\\000\\\n \\185\\000\\185\\000\\185\\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\\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\204\\000\\204\\000\\204\\000\\185\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\185\\000\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\185\\000\\\n \\185\\000\\255\\255\\255\\255\\185\\000\\213\\000\\185\\000\\255\\255\\213\\000\\\n \\255\\255\\185\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\204\\000\\204\\000\\204\\000\\204\\000\\\n \\204\\000\\204\\000\\213\\000\\255\\255\\213\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\213\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\213\\000\\213\\000\\213\\000\\213\\000\\213\\000\\213\\000\\\n \\213\\000\\213\\000\\213\\000\\213\\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\\217\\000\\217\\000\\217\\000\\217\\000\\\n \\217\\000\\217\\000\\217\\000\\217\\000\\217\\000\\217\\000\\213\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\213\\000\\217\\000\\217\\000\\217\\000\\\n \\217\\000\\217\\000\\217\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\213\\000\\213\\000\\255\\255\\255\\255\\213\\000\\255\\255\\213\\000\\213\\000\\\n \\255\\255\\255\\255\\213\\000\\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\229\\000\\229\\000\\229\\000\\217\\000\\217\\000\\217\\000\\\n \\217\\000\\217\\000\\217\\000\\255\\255\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\231\\000\\231\\000\\231\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\255\\255\\255\\255\\255\\255\\229\\000\\229\\000\\229\\000\\229\\000\\\n \\229\\000\\229\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\\n \\232\\000\\232\\000\\255\\255\\231\\000\\231\\000\\231\\000\\231\\000\\231\\000\\\n \\231\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\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\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\232\\000\\232\\000\\232\\000\\232\\000\\232\\000\\232\\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\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\213\\000\\255\\255\\243\\000\\232\\000\\243\\000\\243\\000\\\n \\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\\n \\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\\n \\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\243\\000\\\n \\255\\255\\255\\255\\243\\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\";\n Lexing.lex_base_code =\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 \\058\\000\\172\\000\\000\\000\\000\\000\\230\\000\\088\\001\\010\\000\\000\\000\\\n \\202\\001\\001\\000\\000\\000\\004\\002\\118\\002\\018\\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\\002\\000\\\n \\207\\002\\007\\000\\001\\000\\000\\000\\026\\000\\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\\048\\000\\000\\000\\200\\002\\058\\003\\116\\003\\006\\000\\174\\003\\\n \\032\\004\\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\\004\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\006\\000\\009\\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\";\n Lexing.lex_backtrk_code =\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\036\\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\\048\\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\";\n Lexing.lex_default_code =\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\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\028\\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\";\n Lexing.lex_trans_code =\n \"\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\007\\000\\015\\000\\004\\000\\007\\000\\015\\000\\045\\000\\045\\000\\\n \\045\\000\\000\\000\\045\\000\\045\\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\\015\\000\\004\\000\\031\\000\\000\\000\\000\\000\\045\\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\\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\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\\n \\000\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\045\\000\\000\\000\\000\\000\\\n \\000\\000\\004\\000\\000\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\007\\000\\000\\000\\000\\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 \\000\\000\\000\\000\\000\\000\\000\\000\\007\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\000\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\007\\000\\000\\000\\000\\000\\007\\000\\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 \\007\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\000\\000\\000\\000\\000\\000\\000\\000\\001\\000\\\n \\000\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\001\\000\\\n \\001\\000\\001\\000\\001\\000\\015\\000\\000\\000\\000\\000\\015\\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\\015\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\004\\000\\000\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\015\\000\\\n \\000\\000\\000\\000\\015\\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\\015\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\000\\000\\000\\000\\000\\000\\000\\000\\004\\000\\000\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\004\\000\\\n \\004\\000\\023\\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\\015\\000\\\n \\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\015\\000\\\n \\015\\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 \\045\\000\\045\\000\\045\\000\\000\\000\\000\\000\\000\\000\\000\\000\\045\\000\\\n \\000\\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 \\045\\000\\045\\000\\045\\000\\045\\000\\000\\000\\000\\000\\045\\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\\045\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\045\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\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 \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\000\\045\\000\\000\\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 \\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 \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\000\\000\\\n \\000\\000\\000\\000\\000\\000\\045\\000\\000\\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 \\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 \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\000\\000\\000\\000\\000\\000\\000\\000\\045\\000\\000\\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 \\045\\000\\045\\000\\000\\000\\000\\000\\045\\000\\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 \\045\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\045\\000\\\n \\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\045\\000\\\n \\045\\000\\045\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\000\\\n \\000\\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 \\045\\000\\045\\000\\045\\000\\000\\000\\000\\000\\000\\000\\000\\000\\045\\000\\\n \\000\\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 \\045\\000\\045\\000\\045\\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\";\n Lexing.lex_check_code =\n \"\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\090\\000\\097\\000\\159\\000\\090\\000\\097\\000\\213\\000\\182\\000\\\n \\222\\000\\161\\000\\182\\000\\223\\000\\161\\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 \\090\\000\\097\\000\\159\\000\\162\\000\\255\\255\\255\\255\\182\\000\\255\\255\\\n \\255\\255\\161\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\159\\000\\159\\000\\159\\000\\159\\000\\159\\000\\159\\000\\\n \\159\\000\\159\\000\\159\\000\\159\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\255\\255\\255\\255\\255\\255\\255\\255\\085\\000\\\n \\255\\255\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\085\\000\\\n \\085\\000\\085\\000\\085\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\164\\000\\255\\255\\255\\255\\\n \\255\\255\\088\\000\\255\\255\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\\n \\088\\000\\088\\000\\088\\000\\088\\000\\088\\000\\089\\000\\255\\255\\255\\255\\\n \\089\\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\\089\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\089\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\161\\000\\\n \\255\\255\\255\\255\\255\\255\\089\\000\\255\\255\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\\n \\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\089\\000\\092\\000\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\255\\255\\255\\255\\255\\255\\255\\255\\092\\000\\255\\255\\092\\000\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\092\\000\\\n \\092\\000\\093\\000\\255\\255\\255\\255\\093\\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 \\093\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\093\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\255\\255\\255\\255\\255\\255\\255\\255\\093\\000\\\n \\255\\255\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\093\\000\\\n \\093\\000\\093\\000\\093\\000\\096\\000\\255\\255\\255\\255\\096\\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\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\096\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\096\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\096\\000\\255\\255\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\\n \\096\\000\\096\\000\\096\\000\\096\\000\\096\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\099\\000\\255\\255\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\\n \\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\099\\000\\100\\000\\\n \\255\\255\\255\\255\\100\\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\\100\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\100\\000\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\255\\255\\255\\255\\255\\255\\255\\255\\100\\000\\255\\255\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\100\\000\\\n \\100\\000\\160\\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\\160\\000\\\n \\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\160\\000\\\n \\160\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\255\\255\\255\\255\\255\\255\\255\\255\\179\\000\\\n \\255\\255\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\179\\000\\\n \\179\\000\\179\\000\\179\\000\\180\\000\\255\\255\\255\\255\\180\\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\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\180\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\180\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\180\\000\\255\\255\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\\n \\180\\000\\180\\000\\180\\000\\180\\000\\180\\000\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\255\\255\\\n \\255\\255\\255\\255\\255\\255\\181\\000\\255\\255\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\\n \\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\181\\000\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\183\\000\\255\\255\\255\\255\\255\\255\\255\\255\\183\\000\\255\\255\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\183\\000\\\n \\183\\000\\184\\000\\255\\255\\255\\255\\184\\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 \\184\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\184\\000\\\n \\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\255\\\n \\255\\255\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\255\\255\\255\\255\\255\\255\\255\\255\\184\\000\\\n \\255\\255\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\184\\000\\\n \\184\\000\\184\\000\\184\\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\";\n Lexing.lex_code =\n \"\\255\\002\\255\\255\\004\\255\\255\\003\\255\\255\\000\\002\\001\\003\\255\\005\\\n \\255\\255\\000\\004\\001\\005\\255\\007\\255\\006\\255\\255\\007\\255\\255\\006\\\n \\255\\007\\255\\255\\000\\004\\001\\005\\002\\006\\003\\007\\255\\001\\255\\255\\\n \\000\\001\\255\";\n}\n\nlet rec token lexbuf =\n lexbuf.Lexing.lex_mem <- Array.make 6 (-1); __ocaml_lex_token_rec lexbuf 0\nand __ocaml_lex_token_rec lexbuf __ocaml_lex_state =\n match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n# 379 \"parsing/lexer.mll\"\n bs\n# 2797 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n# 379 \"parsing/lexer.mll\"\n (\n if not !escaped_newlines then error lexbuf (Illegal_character bs);\n update_loc lexbuf None 1 false 0;\n token lexbuf )\n# 2804 \"parsing/lexer.ml\"\n\n | 1 ->\n# 384 \"parsing/lexer.mll\"\n ( update_loc lexbuf None 1 false 0;\n EOL )\n# 2810 \"parsing/lexer.ml\"\n\n | 2 ->\n# 387 \"parsing/lexer.mll\"\n ( token lexbuf )\n# 2815 \"parsing/lexer.ml\"\n\n | 3 ->\n# 389 \"parsing/lexer.mll\"\n ( UNDERSCORE )\n# 2820 \"parsing/lexer.ml\"\n\n | 4 ->\n# 391 \"parsing/lexer.mll\"\n ( TILDE )\n# 2825 \"parsing/lexer.ml\"\n\n | 5 ->\n# 393 \"parsing/lexer.mll\"\n ( error lexbuf\n (Reserved_sequence (\".~\", Some \"is reserved for use in MetaOCaml\")) )\n# 2831 \"parsing/lexer.ml\"\n\n | 6 ->\nlet\n# 395 \"parsing/lexer.mll\"\n name\n# 2837 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) (lexbuf.Lexing.lex_curr_pos + -1) in\n# 396 \"parsing/lexer.mll\"\n ( check_label_name lexbuf name;\n LABEL name )\n# 2842 \"parsing/lexer.ml\"\n\n | 7 ->\nlet\n# 398 \"parsing/lexer.mll\"\n name\n# 2848 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) (lexbuf.Lexing.lex_curr_pos + -1) in\n# 399 \"parsing/lexer.mll\"\n ( warn_latin1 lexbuf;\n LABEL name )\n# 2853 \"parsing/lexer.ml\"\n\n | 8 ->\n# 402 \"parsing/lexer.mll\"\n ( QUESTION )\n# 2858 \"parsing/lexer.ml\"\n\n | 9 ->\nlet\n# 403 \"parsing/lexer.mll\"\n name\n# 2864 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) (lexbuf.Lexing.lex_curr_pos + -1) in\n# 404 \"parsing/lexer.mll\"\n ( check_label_name lexbuf name;\n OPTLABEL name )\n# 2869 \"parsing/lexer.ml\"\n\n | 10 ->\nlet\n# 406 \"parsing/lexer.mll\"\n name\n# 2875 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) (lexbuf.Lexing.lex_curr_pos + -1) in\n# 407 \"parsing/lexer.mll\"\n ( warn_latin1 lexbuf;\n OPTLABEL name )\n# 2880 \"parsing/lexer.ml\"\n\n | 11 ->\nlet\n# 409 \"parsing/lexer.mll\"\n name\n# 2886 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 410 \"parsing/lexer.mll\"\n ( try Hashtbl.find keyword_table name\n with Not_found -> LIDENT name )\n# 2891 \"parsing/lexer.ml\"\n\n | 12 ->\nlet\n# 412 \"parsing/lexer.mll\"\n name\n# 2897 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 413 \"parsing/lexer.mll\"\n ( warn_latin1 lexbuf; LIDENT name )\n# 2901 \"parsing/lexer.ml\"\n\n | 13 ->\nlet\n# 414 \"parsing/lexer.mll\"\n name\n# 2907 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 415 \"parsing/lexer.mll\"\n ( UIDENT name )\n# 2911 \"parsing/lexer.ml\"\n\n | 14 ->\nlet\n# 416 \"parsing/lexer.mll\"\n name\n# 2917 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 417 \"parsing/lexer.mll\"\n ( warn_latin1 lexbuf; UIDENT name )\n# 2921 \"parsing/lexer.ml\"\n\n | 15 ->\nlet\n# 418 \"parsing/lexer.mll\"\n lit\n# 2927 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 418 \"parsing/lexer.mll\"\n ( INT (lit, None) )\n# 2931 \"parsing/lexer.ml\"\n\n | 16 ->\nlet\n# 419 \"parsing/lexer.mll\"\n lit\n# 2937 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos (lexbuf.Lexing.lex_curr_pos + -1)\nand\n# 419 \"parsing/lexer.mll\"\n modif\n# 2942 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_curr_pos + -1) in\n# 420 \"parsing/lexer.mll\"\n ( INT (lit, Some modif) )\n# 2946 \"parsing/lexer.ml\"\n\n | 17 ->\nlet\n# 421 \"parsing/lexer.mll\"\n lit\n# 2952 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 422 \"parsing/lexer.mll\"\n ( FLOAT (lit, None) )\n# 2956 \"parsing/lexer.ml\"\n\n | 18 ->\nlet\n# 423 \"parsing/lexer.mll\"\n lit\n# 2962 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos (lexbuf.Lexing.lex_curr_pos + -1)\nand\n# 423 \"parsing/lexer.mll\"\n modif\n# 2967 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_curr_pos + -1) in\n# 424 \"parsing/lexer.mll\"\n ( FLOAT (lit, Some modif) )\n# 2971 \"parsing/lexer.ml\"\n\n | 19 ->\nlet\n# 425 \"parsing/lexer.mll\"\n invalid\n# 2977 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 426 \"parsing/lexer.mll\"\n ( error lexbuf (Invalid_literal invalid) )\n# 2981 \"parsing/lexer.ml\"\n\n | 20 ->\n# 428 \"parsing/lexer.mll\"\n ( let s, loc = wrap_string_lexer string lexbuf in\n STRING (s, loc, None) )\n# 2987 \"parsing/lexer.ml\"\n\n | 21 ->\nlet\n# 430 \"parsing/lexer.mll\"\n delim\n# 2993 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) (lexbuf.Lexing.lex_curr_pos + -1) in\n# 431 \"parsing/lexer.mll\"\n ( let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in\n STRING (s, loc, Some delim) )\n# 2998 \"parsing/lexer.ml\"\n\n | 22 ->\nlet\n# 433 \"parsing/lexer.mll\"\n id\n# 3004 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 2) (lexbuf.Lexing.lex_curr_pos + -1) in\n# 434 \"parsing/lexer.mll\"\n ( let orig_loc = Location.curr lexbuf in\n let s, loc = wrap_string_lexer (quoted_string \"\") lexbuf in\n let idloc = compute_quoted_string_idloc orig_loc 2 id in\n QUOTED_STRING_EXPR (id, idloc, s, loc, Some \"\") )\n# 3011 \"parsing/lexer.ml\"\n\n | 23 ->\nlet\n# 438 \"parsing/lexer.mll\"\n id\n# 3017 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 2) lexbuf.Lexing.lex_mem.(0)\nand\n# 438 \"parsing/lexer.mll\"\n delim\n# 3022 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(1) (lexbuf.Lexing.lex_curr_pos + -1) in\n# 439 \"parsing/lexer.mll\"\n ( let orig_loc = Location.curr lexbuf in\n let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in\n let idloc = compute_quoted_string_idloc orig_loc 2 id in\n QUOTED_STRING_EXPR (id, idloc, s, loc, Some delim) )\n# 3029 \"parsing/lexer.ml\"\n\n | 24 ->\nlet\n# 443 \"parsing/lexer.mll\"\n id\n# 3035 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 3) (lexbuf.Lexing.lex_curr_pos + -1) in\n# 444 \"parsing/lexer.mll\"\n ( let orig_loc = Location.curr lexbuf in\n let s, loc = wrap_string_lexer (quoted_string \"\") lexbuf in\n let idloc = compute_quoted_string_idloc orig_loc 3 id in\n QUOTED_STRING_ITEM (id, idloc, s, loc, Some \"\") )\n# 3042 \"parsing/lexer.ml\"\n\n | 25 ->\nlet\n# 448 \"parsing/lexer.mll\"\n id\n# 3048 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 3) lexbuf.Lexing.lex_mem.(0)\nand\n# 448 \"parsing/lexer.mll\"\n delim\n# 3053 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(1) (lexbuf.Lexing.lex_curr_pos + -1) in\n# 449 \"parsing/lexer.mll\"\n ( let orig_loc = Location.curr lexbuf in\n let s, loc = wrap_string_lexer (quoted_string delim) lexbuf in\n let idloc = compute_quoted_string_idloc orig_loc 3 id in\n QUOTED_STRING_ITEM (id, idloc, s, loc, Some delim) )\n# 3060 \"parsing/lexer.ml\"\n\n | 26 ->\n# 454 \"parsing/lexer.mll\"\n ( update_loc lexbuf None 1 false 1;\n (* newline is ('\\013'* '\\010') *)\n CHAR '\\n' )\n# 3067 \"parsing/lexer.ml\"\n\n | 27 ->\nlet\n# 457 \"parsing/lexer.mll\"\n c\n# 3073 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1) in\n# 458 \"parsing/lexer.mll\"\n ( CHAR c )\n# 3077 \"parsing/lexer.ml\"\n\n | 28 ->\nlet\n# 459 \"parsing/lexer.mll\"\n c\n# 3083 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 2) in\n# 460 \"parsing/lexer.mll\"\n ( CHAR (char_for_backslash c) )\n# 3087 \"parsing/lexer.ml\"\n\n | 29 ->\n# 462 \"parsing/lexer.mll\"\n ( CHAR(char_for_decimal_code lexbuf 2) )\n# 3092 \"parsing/lexer.ml\"\n\n | 30 ->\n# 464 \"parsing/lexer.mll\"\n ( CHAR(char_for_octal_code lexbuf 3) )\n# 3097 \"parsing/lexer.ml\"\n\n | 31 ->\n# 466 \"parsing/lexer.mll\"\n ( CHAR(char_for_hexadecimal_code lexbuf 3) )\n# 3102 \"parsing/lexer.ml\"\n\n | 32 ->\nlet\n# 467 \"parsing/lexer.mll\"\n esc\n# 3108 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) (lexbuf.Lexing.lex_start_pos + 3) in\n# 468 \"parsing/lexer.mll\"\n ( error lexbuf (Illegal_escape (esc, None)) )\n# 3112 \"parsing/lexer.ml\"\n\n | 33 ->\n# 470 \"parsing/lexer.mll\"\n ( error lexbuf Empty_character_literal )\n# 3117 \"parsing/lexer.ml\"\n\n | 34 ->\n# 472 \"parsing/lexer.mll\"\n ( let s, loc = wrap_comment_lexer comment lexbuf in\n COMMENT (s, loc) )\n# 3123 \"parsing/lexer.ml\"\n\n | 35 ->\n# 475 \"parsing/lexer.mll\"\n ( let s, loc = wrap_comment_lexer comment lexbuf in\n if !handle_docstrings then\n DOCSTRING (Docstrings.docstring s loc)\n else\n COMMENT (\"*\" ^ s, loc)\n )\n# 3133 \"parsing/lexer.ml\"\n\n | 36 ->\nlet\n# 481 \"parsing/lexer.mll\"\n stars\n# 3139 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 3) lexbuf.Lexing.lex_curr_pos in\n# 482 \"parsing/lexer.mll\"\n ( let s, loc =\n wrap_comment_lexer\n (fun lexbuf ->\n store_string (\"*\" ^ stars);\n comment lexbuf)\n lexbuf\n in\n COMMENT (s, loc) )\n# 3150 \"parsing/lexer.ml\"\n\n | 37 ->\n# 491 \"parsing/lexer.mll\"\n ( if !print_warnings then\n Location.prerr_warning (Location.curr lexbuf) Warnings.Comment_start;\n let s, loc = wrap_comment_lexer comment lexbuf in\n COMMENT (s, loc) )\n# 3158 \"parsing/lexer.ml\"\n\n | 38 ->\nlet\n# 495 \"parsing/lexer.mll\"\n stars\n# 3164 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 2) (lexbuf.Lexing.lex_curr_pos + -2) in\n# 496 \"parsing/lexer.mll\"\n ( if !handle_docstrings && stars=\"\" then\n (* (**) is an empty docstring *)\n DOCSTRING(Docstrings.docstring \"\" (Location.curr lexbuf))\n else\n COMMENT (stars, Location.curr lexbuf) )\n# 3172 \"parsing/lexer.ml\"\n\n | 39 ->\n# 502 \"parsing/lexer.mll\"\n ( let loc = Location.curr lexbuf in\n Location.prerr_warning loc Warnings.Comment_not_end;\n lexbuf.Lexing.lex_curr_pos <- lexbuf.Lexing.lex_curr_pos - 1;\n let curpos = lexbuf.lex_curr_p in\n lexbuf.lex_curr_p <- { curpos with pos_cnum = curpos.pos_cnum - 1 };\n STAR\n )\n# 3183 \"parsing/lexer.ml\"\n\n | 40 ->\n# 510 \"parsing/lexer.mll\"\n ( let at_beginning_of_line pos = (pos.pos_cnum = pos.pos_bol) in\n if not (at_beginning_of_line lexbuf.lex_start_p)\n then HASH\n else try directive lexbuf with Failure _ -> HASH\n )\n# 3192 \"parsing/lexer.ml\"\n\n | 41 ->\n# 515 \"parsing/lexer.mll\"\n ( AMPERSAND )\n# 3197 \"parsing/lexer.ml\"\n\n | 42 ->\n# 516 \"parsing/lexer.mll\"\n ( AMPERAMPER )\n# 3202 \"parsing/lexer.ml\"\n\n | 43 ->\n# 517 \"parsing/lexer.mll\"\n ( BACKQUOTE )\n# 3207 \"parsing/lexer.ml\"\n\n | 44 ->\n# 518 \"parsing/lexer.mll\"\n ( QUOTE )\n# 3212 \"parsing/lexer.ml\"\n\n | 45 ->\n# 519 \"parsing/lexer.mll\"\n ( LPAREN )\n# 3217 \"parsing/lexer.ml\"\n\n | 46 ->\n# 520 \"parsing/lexer.mll\"\n ( RPAREN )\n# 3222 \"parsing/lexer.ml\"\n\n | 47 ->\n# 521 \"parsing/lexer.mll\"\n ( STAR )\n# 3227 \"parsing/lexer.ml\"\n\n | 48 ->\n# 522 \"parsing/lexer.mll\"\n ( COMMA )\n# 3232 \"parsing/lexer.ml\"\n\n | 49 ->\n# 523 \"parsing/lexer.mll\"\n ( MINUSGREATER )\n# 3237 \"parsing/lexer.ml\"\n\n | 50 ->\n# 524 \"parsing/lexer.mll\"\n ( DOT )\n# 3242 \"parsing/lexer.ml\"\n\n | 51 ->\n# 525 \"parsing/lexer.mll\"\n ( DOTDOT )\n# 3247 \"parsing/lexer.ml\"\n\n | 52 ->\nlet\n# 526 \"parsing/lexer.mll\"\n op\n# 3253 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) lexbuf.Lexing.lex_curr_pos in\n# 526 \"parsing/lexer.mll\"\n ( DOTOP op )\n# 3257 \"parsing/lexer.ml\"\n\n | 53 ->\n# 527 \"parsing/lexer.mll\"\n ( COLON )\n# 3262 \"parsing/lexer.ml\"\n\n | 54 ->\n# 528 \"parsing/lexer.mll\"\n ( COLONCOLON )\n# 3267 \"parsing/lexer.ml\"\n\n | 55 ->\n# 529 \"parsing/lexer.mll\"\n ( COLONEQUAL )\n# 3272 \"parsing/lexer.ml\"\n\n | 56 ->\n# 530 \"parsing/lexer.mll\"\n ( COLONGREATER )\n# 3277 \"parsing/lexer.ml\"\n\n | 57 ->\n# 531 \"parsing/lexer.mll\"\n ( SEMI )\n# 3282 \"parsing/lexer.ml\"\n\n | 58 ->\n# 532 \"parsing/lexer.mll\"\n ( SEMISEMI )\n# 3287 \"parsing/lexer.ml\"\n\n | 59 ->\n# 533 \"parsing/lexer.mll\"\n ( LESS )\n# 3292 \"parsing/lexer.ml\"\n\n | 60 ->\n# 534 \"parsing/lexer.mll\"\n ( LESSMINUS )\n# 3297 \"parsing/lexer.ml\"\n\n | 61 ->\n# 535 \"parsing/lexer.mll\"\n ( EQUAL )\n# 3302 \"parsing/lexer.ml\"\n\n | 62 ->\n# 536 \"parsing/lexer.mll\"\n ( LBRACKET )\n# 3307 \"parsing/lexer.ml\"\n\n | 63 ->\n# 537 \"parsing/lexer.mll\"\n ( LBRACKETBAR )\n# 3312 \"parsing/lexer.ml\"\n\n | 64 ->\n# 538 \"parsing/lexer.mll\"\n ( LBRACKETLESS )\n# 3317 \"parsing/lexer.ml\"\n\n | 65 ->\n# 539 \"parsing/lexer.mll\"\n ( LBRACKETGREATER )\n# 3322 \"parsing/lexer.ml\"\n\n | 66 ->\n# 540 \"parsing/lexer.mll\"\n ( RBRACKET )\n# 3327 \"parsing/lexer.ml\"\n\n | 67 ->\n# 541 \"parsing/lexer.mll\"\n ( LBRACE )\n# 3332 \"parsing/lexer.ml\"\n\n | 68 ->\n# 542 \"parsing/lexer.mll\"\n ( LBRACELESS )\n# 3337 \"parsing/lexer.ml\"\n\n | 69 ->\n# 543 \"parsing/lexer.mll\"\n ( BAR )\n# 3342 \"parsing/lexer.ml\"\n\n | 70 ->\n# 544 \"parsing/lexer.mll\"\n ( BARBAR )\n# 3347 \"parsing/lexer.ml\"\n\n | 71 ->\n# 545 \"parsing/lexer.mll\"\n ( BARRBRACKET )\n# 3352 \"parsing/lexer.ml\"\n\n | 72 ->\n# 546 \"parsing/lexer.mll\"\n ( GREATER )\n# 3357 \"parsing/lexer.ml\"\n\n | 73 ->\n# 547 \"parsing/lexer.mll\"\n ( GREATERRBRACKET )\n# 3362 \"parsing/lexer.ml\"\n\n | 74 ->\n# 548 \"parsing/lexer.mll\"\n ( RBRACE )\n# 3367 \"parsing/lexer.ml\"\n\n | 75 ->\n# 549 \"parsing/lexer.mll\"\n ( GREATERRBRACE )\n# 3372 \"parsing/lexer.ml\"\n\n | 76 ->\n# 550 \"parsing/lexer.mll\"\n ( LBRACKETAT )\n# 3377 \"parsing/lexer.ml\"\n\n | 77 ->\n# 551 \"parsing/lexer.mll\"\n ( LBRACKETATAT )\n# 3382 \"parsing/lexer.ml\"\n\n | 78 ->\n# 552 \"parsing/lexer.mll\"\n ( LBRACKETATATAT )\n# 3387 \"parsing/lexer.ml\"\n\n | 79 ->\n# 553 \"parsing/lexer.mll\"\n ( LBRACKETPERCENT )\n# 3392 \"parsing/lexer.ml\"\n\n | 80 ->\n# 554 \"parsing/lexer.mll\"\n ( LBRACKETPERCENTPERCENT )\n# 3397 \"parsing/lexer.ml\"\n\n | 81 ->\n# 555 \"parsing/lexer.mll\"\n ( BANG )\n# 3402 \"parsing/lexer.ml\"\n\n | 82 ->\n# 556 \"parsing/lexer.mll\"\n ( INFIXOP0 \"!=\" )\n# 3407 \"parsing/lexer.ml\"\n\n | 83 ->\n# 557 \"parsing/lexer.mll\"\n ( PLUS )\n# 3412 \"parsing/lexer.ml\"\n\n | 84 ->\n# 558 \"parsing/lexer.mll\"\n ( PLUSDOT )\n# 3417 \"parsing/lexer.ml\"\n\n | 85 ->\n# 559 \"parsing/lexer.mll\"\n ( PLUSEQ )\n# 3422 \"parsing/lexer.ml\"\n\n | 86 ->\n# 560 \"parsing/lexer.mll\"\n ( MINUS )\n# 3427 \"parsing/lexer.ml\"\n\n | 87 ->\n# 561 \"parsing/lexer.mll\"\n ( MINUSDOT )\n# 3432 \"parsing/lexer.ml\"\n\n | 88 ->\nlet\n# 563 \"parsing/lexer.mll\"\n op\n# 3438 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 564 \"parsing/lexer.mll\"\n ( PREFIXOP op )\n# 3442 \"parsing/lexer.ml\"\n\n | 89 ->\nlet\n# 565 \"parsing/lexer.mll\"\n op\n# 3448 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 566 \"parsing/lexer.mll\"\n ( PREFIXOP op )\n# 3452 \"parsing/lexer.ml\"\n\n | 90 ->\nlet\n# 567 \"parsing/lexer.mll\"\n op\n# 3458 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 568 \"parsing/lexer.mll\"\n ( INFIXOP0 op )\n# 3462 \"parsing/lexer.ml\"\n\n | 91 ->\nlet\n# 569 \"parsing/lexer.mll\"\n op\n# 3468 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 570 \"parsing/lexer.mll\"\n ( INFIXOP1 op )\n# 3472 \"parsing/lexer.ml\"\n\n | 92 ->\nlet\n# 571 \"parsing/lexer.mll\"\n op\n# 3478 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 572 \"parsing/lexer.mll\"\n ( INFIXOP2 op )\n# 3482 \"parsing/lexer.ml\"\n\n | 93 ->\nlet\n# 573 \"parsing/lexer.mll\"\n op\n# 3488 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 574 \"parsing/lexer.mll\"\n ( INFIXOP4 op )\n# 3492 \"parsing/lexer.ml\"\n\n | 94 ->\n# 575 \"parsing/lexer.mll\"\n ( PERCENT )\n# 3497 \"parsing/lexer.ml\"\n\n | 95 ->\nlet\n# 576 \"parsing/lexer.mll\"\n op\n# 3503 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 577 \"parsing/lexer.mll\"\n ( INFIXOP3 op )\n# 3507 \"parsing/lexer.ml\"\n\n | 96 ->\nlet\n# 578 \"parsing/lexer.mll\"\n op\n# 3513 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 579 \"parsing/lexer.mll\"\n ( HASHOP op )\n# 3517 \"parsing/lexer.ml\"\n\n | 97 ->\nlet\n# 580 \"parsing/lexer.mll\"\n op\n# 3523 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 581 \"parsing/lexer.mll\"\n ( LETOP op )\n# 3527 \"parsing/lexer.ml\"\n\n | 98 ->\nlet\n# 582 \"parsing/lexer.mll\"\n op\n# 3533 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in\n# 583 \"parsing/lexer.mll\"\n ( ANDOP op )\n# 3537 \"parsing/lexer.ml\"\n\n | 99 ->\n# 584 \"parsing/lexer.mll\"\n ( EOF )\n# 3542 \"parsing/lexer.ml\"\n\n | 100 ->\nlet\n# 585 \"parsing/lexer.mll\"\n illegal_char\n# 3548 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n# 586 \"parsing/lexer.mll\"\n ( error lexbuf (Illegal_character illegal_char) )\n# 3552 \"parsing/lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_token_rec lexbuf __ocaml_lex_state\n\nand directive lexbuf =\n lexbuf.Lexing.lex_mem <- Array.make 8 (-1);(* L=1 [4] <- p ; *)\n lexbuf.Lexing.lex_mem.(4) <- lexbuf.Lexing.lex_curr_pos ;\n __ocaml_lex_directive_rec lexbuf 159\nand __ocaml_lex_directive_rec lexbuf __ocaml_lex_state =\n match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\nlet\n# 589 \"parsing/lexer.mll\"\n num\n# 3567 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_mem.(1)\nand\n# 590 \"parsing/lexer.mll\"\n name\n# 3572 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(2) lexbuf.Lexing.lex_mem.(3)\nand\n# 590 \"parsing/lexer.mll\"\n directive\n# 3577 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos (lexbuf.Lexing.lex_mem.(3) + 1) in\n# 592 \"parsing/lexer.mll\"\n (\n match int_of_string num with\n | exception _ ->\n (* PR#7165 *)\n let explanation = \"line number out of range\" in\n error lexbuf (Invalid_directive (\"#\" ^ directive, Some explanation))\n | line_num ->\n (* Documentation says that the line number should be\n positive, but we have never guarded against this and it\n might have useful hackish uses. *)\n update_loc lexbuf (Some name) (line_num - 1) true 0;\n token lexbuf\n )\n# 3593 \"parsing/lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_directive_rec lexbuf __ocaml_lex_state\n\nand comment lexbuf =\n lexbuf.Lexing.lex_mem <- Array.make 2 (-1); __ocaml_lex_comment_rec lexbuf 164\nand __ocaml_lex_comment_rec lexbuf __ocaml_lex_state =\n match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 607 \"parsing/lexer.mll\"\n ( comment_start_loc := (Location.curr lexbuf) :: !comment_start_loc;\n store_lexeme lexbuf;\n comment lexbuf\n )\n# 3608 \"parsing/lexer.ml\"\n\n | 1 ->\n# 612 \"parsing/lexer.mll\"\n ( match !comment_start_loc with\n | [] -> assert false\n | [_] -> comment_start_loc := []; Location.curr lexbuf\n | _ :: l -> comment_start_loc := l;\n store_lexeme lexbuf;\n comment lexbuf\n )\n# 3619 \"parsing/lexer.ml\"\n\n | 2 ->\n# 620 \"parsing/lexer.mll\"\n (\n string_start_loc := Location.curr lexbuf;\n store_string_char '\\\"';\n is_in_string := true;\n let _loc = try string lexbuf\n with Error (Unterminated_string, str_start) ->\n match !comment_start_loc with\n | [] -> assert false\n | loc :: _ ->\n let start = List.hd (List.rev !comment_start_loc) in\n comment_start_loc := [];\n error_loc loc (Unterminated_string_in_comment (start, str_start))\n in\n is_in_string := false;\n store_string_char '\\\"';\n comment lexbuf )\n# 3639 \"parsing/lexer.ml\"\n\n | 3 ->\nlet\n# 636 \"parsing/lexer.mll\"\n delim\n# 3645 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) (lexbuf.Lexing.lex_curr_pos + -1) in\n# 637 \"parsing/lexer.mll\"\n (\n string_start_loc := Location.curr lexbuf;\n store_lexeme lexbuf;\n is_in_string := true;\n let _loc = try quoted_string delim lexbuf\n with Error (Unterminated_string, str_start) ->\n match !comment_start_loc with\n | [] -> assert false\n | loc :: _ ->\n let start = List.hd (List.rev !comment_start_loc) in\n comment_start_loc := [];\n error_loc loc (Unterminated_string_in_comment (start, str_start))\n in\n is_in_string := false;\n store_string_char '|';\n store_string delim;\n store_string_char '}';\n comment lexbuf )\n# 3666 \"parsing/lexer.ml\"\n\n | 4 ->\n# 656 \"parsing/lexer.mll\"\n ( store_lexeme lexbuf; comment lexbuf )\n# 3671 \"parsing/lexer.ml\"\n\n | 5 ->\n# 658 \"parsing/lexer.mll\"\n ( update_loc lexbuf None 1 false 1;\n store_lexeme lexbuf;\n comment lexbuf\n )\n# 3679 \"parsing/lexer.ml\"\n\n | 6 ->\n# 663 \"parsing/lexer.mll\"\n ( store_lexeme lexbuf; comment lexbuf )\n# 3684 \"parsing/lexer.ml\"\n\n | 7 ->\n# 665 \"parsing/lexer.mll\"\n ( store_lexeme lexbuf; comment lexbuf )\n# 3689 \"parsing/lexer.ml\"\n\n | 8 ->\n# 667 \"parsing/lexer.mll\"\n ( store_lexeme lexbuf; comment lexbuf )\n# 3694 \"parsing/lexer.ml\"\n\n | 9 ->\n# 669 \"parsing/lexer.mll\"\n ( store_lexeme lexbuf; comment lexbuf )\n# 3699 \"parsing/lexer.ml\"\n\n | 10 ->\n# 671 \"parsing/lexer.mll\"\n ( store_lexeme lexbuf; comment lexbuf )\n# 3704 \"parsing/lexer.ml\"\n\n | 11 ->\n# 673 \"parsing/lexer.mll\"\n ( match !comment_start_loc with\n | [] -> assert false\n | loc :: _ ->\n let start = List.hd (List.rev !comment_start_loc) in\n comment_start_loc := [];\n error_loc loc (Unterminated_comment start)\n )\n# 3715 \"parsing/lexer.ml\"\n\n | 12 ->\n# 681 \"parsing/lexer.mll\"\n ( update_loc lexbuf None 1 false 0;\n store_lexeme lexbuf;\n comment lexbuf\n )\n# 3723 \"parsing/lexer.ml\"\n\n | 13 ->\n# 686 \"parsing/lexer.mll\"\n ( store_lexeme lexbuf; comment lexbuf )\n# 3728 \"parsing/lexer.ml\"\n\n | 14 ->\n# 688 \"parsing/lexer.mll\"\n ( store_lexeme lexbuf; comment lexbuf )\n# 3733 \"parsing/lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_comment_rec lexbuf __ocaml_lex_state\n\nand string lexbuf =\n lexbuf.Lexing.lex_mem <- Array.make 2 (-1); __ocaml_lex_string_rec lexbuf 208\nand __ocaml_lex_string_rec lexbuf __ocaml_lex_state =\n match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 692 \"parsing/lexer.mll\"\n ( lexbuf.lex_start_p )\n# 3745 \"parsing/lexer.ml\"\n\n | 1 ->\nlet\n# 693 \"parsing/lexer.mll\"\n space\n# 3751 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in\n# 694 \"parsing/lexer.mll\"\n ( update_loc lexbuf None 1 false (String.length space);\n if in_comment () then store_lexeme lexbuf;\n string lexbuf\n )\n# 3758 \"parsing/lexer.ml\"\n\n | 2 ->\nlet\n# 698 \"parsing/lexer.mll\"\n c\n# 3764 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1) in\n# 699 \"parsing/lexer.mll\"\n ( store_escaped_char lexbuf (char_for_backslash c);\n string lexbuf )\n# 3769 \"parsing/lexer.ml\"\n\n | 3 ->\n# 702 \"parsing/lexer.mll\"\n ( store_escaped_char lexbuf (char_for_decimal_code lexbuf 1);\n string lexbuf )\n# 3775 \"parsing/lexer.ml\"\n\n | 4 ->\n# 705 \"parsing/lexer.mll\"\n ( store_escaped_char lexbuf (char_for_octal_code lexbuf 2);\n string lexbuf )\n# 3781 \"parsing/lexer.ml\"\n\n | 5 ->\n# 708 \"parsing/lexer.mll\"\n ( store_escaped_char lexbuf (char_for_hexadecimal_code lexbuf 2);\n string lexbuf )\n# 3787 \"parsing/lexer.ml\"\n\n | 6 ->\n# 711 \"parsing/lexer.mll\"\n ( store_escaped_uchar lexbuf (uchar_for_uchar_escape lexbuf);\n string lexbuf )\n# 3793 \"parsing/lexer.ml\"\n\n | 7 ->\n# 714 \"parsing/lexer.mll\"\n ( if not (in_comment ()) then begin\n(* Should be an error, but we are very lax.\n error lexbuf (Illegal_escape (Lexing.lexeme lexbuf, None))\n*)\n let loc = Location.curr lexbuf in\n Location.prerr_warning loc Warnings.Illegal_backslash;\n end;\n store_lexeme lexbuf;\n string lexbuf\n )\n# 3807 \"parsing/lexer.ml\"\n\n | 8 ->\n# 725 \"parsing/lexer.mll\"\n ( if not (in_comment ()) then\n Location.prerr_warning (Location.curr lexbuf) Warnings.Eol_in_string;\n update_loc lexbuf None 1 false 0;\n store_lexeme lexbuf;\n string lexbuf\n )\n# 3817 \"parsing/lexer.ml\"\n\n | 9 ->\n# 732 \"parsing/lexer.mll\"\n ( is_in_string := false;\n error_loc !string_start_loc Unterminated_string )\n# 3823 \"parsing/lexer.ml\"\n\n | 10 ->\nlet\n# 734 \"parsing/lexer.mll\"\n c\n# 3829 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n# 735 \"parsing/lexer.mll\"\n ( store_string_char c;\n string lexbuf )\n# 3834 \"parsing/lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_string_rec lexbuf __ocaml_lex_state\n\nand quoted_string delim lexbuf =\n __ocaml_lex_quoted_string_rec delim lexbuf 235\nand __ocaml_lex_quoted_string_rec delim lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 740 \"parsing/lexer.mll\"\n ( update_loc lexbuf None 1 false 0;\n store_lexeme lexbuf;\n quoted_string delim lexbuf\n )\n# 3849 \"parsing/lexer.ml\"\n\n | 1 ->\n# 745 \"parsing/lexer.mll\"\n ( is_in_string := false;\n error_loc !string_start_loc Unterminated_string )\n# 3855 \"parsing/lexer.ml\"\n\n | 2 ->\nlet\n# 747 \"parsing/lexer.mll\"\n edelim\n# 3861 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) (lexbuf.Lexing.lex_curr_pos + -1) in\n# 748 \"parsing/lexer.mll\"\n (\n if delim = edelim then lexbuf.lex_start_p\n else (store_lexeme lexbuf; quoted_string delim lexbuf)\n )\n# 3868 \"parsing/lexer.ml\"\n\n | 3 ->\nlet\n# 752 \"parsing/lexer.mll\"\n c\n# 3874 \"parsing/lexer.ml\"\n= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in\n# 753 \"parsing/lexer.mll\"\n ( store_string_char c;\n quoted_string delim lexbuf )\n# 3879 \"parsing/lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_quoted_string_rec delim lexbuf __ocaml_lex_state\n\nand skip_hash_bang lexbuf =\n __ocaml_lex_skip_hash_bang_rec lexbuf 244\nand __ocaml_lex_skip_hash_bang_rec lexbuf __ocaml_lex_state =\n match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with\n | 0 ->\n# 758 \"parsing/lexer.mll\"\n ( update_loc lexbuf None 3 false 0 )\n# 3891 \"parsing/lexer.ml\"\n\n | 1 ->\n# 760 \"parsing/lexer.mll\"\n ( update_loc lexbuf None 1 false 0 )\n# 3896 \"parsing/lexer.ml\"\n\n | 2 ->\n# 761 \"parsing/lexer.mll\"\n ( () )\n# 3901 \"parsing/lexer.ml\"\n\n | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf;\n __ocaml_lex_skip_hash_bang_rec lexbuf __ocaml_lex_state\n\n;;\n\n# 763 \"parsing/lexer.mll\"\n \n\n let token_with_comments lexbuf =\n match !preprocessor with\n | None -> token lexbuf\n | Some (_init, preprocess) -> preprocess token lexbuf\n\n type newline_state =\n | NoLine (* There have been no blank lines yet. *)\n | NewLine\n (* There have been no blank lines, and the previous\n token was a newline. *)\n | BlankLine (* There have been blank lines. *)\n\n type doc_state =\n | Initial (* There have been no docstrings yet *)\n | After of docstring list\n (* There have been docstrings, none of which were\n preceded by a blank line *)\n | Before of docstring list * docstring list * docstring list\n (* There have been docstrings, some of which were\n preceded by a blank line *)\n\n and docstring = Docstrings.docstring\n\n let token lexbuf =\n let post_pos = lexeme_end_p lexbuf in\n let attach lines docs pre_pos =\n let open Docstrings in\n match docs, lines with\n | Initial, _ -> ()\n | After a, (NoLine | NewLine) ->\n set_post_docstrings post_pos (List.rev a);\n set_pre_docstrings pre_pos a;\n | After a, BlankLine ->\n set_post_docstrings post_pos (List.rev a);\n set_pre_extra_docstrings pre_pos (List.rev a)\n | Before(a, f, b), (NoLine | NewLine) ->\n set_post_docstrings post_pos (List.rev a);\n set_post_extra_docstrings post_pos\n (List.rev_append f (List.rev b));\n set_floating_docstrings pre_pos (List.rev f);\n set_pre_extra_docstrings pre_pos (List.rev a);\n set_pre_docstrings pre_pos b\n | Before(a, f, b), BlankLine ->\n set_post_docstrings post_pos (List.rev a);\n set_post_extra_docstrings post_pos\n (List.rev_append f (List.rev b));\n set_floating_docstrings pre_pos\n (List.rev_append f (List.rev b));\n set_pre_extra_docstrings pre_pos (List.rev a)\n in\n let rec loop lines docs lexbuf =\n match token_with_comments lexbuf with\n | COMMENT (s, loc) ->\n add_comment (s, loc);\n let lines' =\n match lines with\n | NoLine -> NoLine\n | NewLine -> NoLine\n | BlankLine -> BlankLine\n in\n loop lines' docs lexbuf\n | EOL ->\n let lines' =\n match lines with\n | NoLine -> NewLine\n | NewLine -> BlankLine\n | BlankLine -> BlankLine\n in\n loop lines' docs lexbuf\n | DOCSTRING doc ->\n Docstrings.register doc;\n add_docstring_comment doc;\n let docs' =\n if Docstrings.docstring_body doc = \"/*\" then\n match docs with\n | Initial -> Before([], [doc], [])\n | After a -> Before (a, [doc], [])\n | Before(a, f, b) -> Before(a, doc :: b @ f, [])\n else\n match docs, lines with\n | Initial, (NoLine | NewLine) -> After [doc]\n | Initial, BlankLine -> Before([], [], [doc])\n | After a, (NoLine | NewLine) -> After (doc :: a)\n | After a, BlankLine -> Before (a, [], [doc])\n | Before(a, f, b), (NoLine | NewLine) -> Before(a, f, doc :: b)\n | Before(a, f, b), BlankLine -> Before(a, b @ f, [doc])\n in\n loop NoLine docs' lexbuf\n | tok ->\n attach lines docs (lexeme_start_p lexbuf);\n tok\n in\n loop NoLine Initial lexbuf\n\n let init () =\n is_in_string := false;\n comment_start_loc := [];\n comment_list := [];\n match !preprocessor with\n | None -> ()\n | Some (init, _preprocess) -> init ()\n\n let set_preprocessor init preprocess =\n escaped_newlines := true;\n preprocessor := Some (init, preprocess)\n\n\n# 4018 \"parsing/lexer.ml\"\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 Local_store\n\nlet lowest_scope = 0\nlet highest_scope = 100000000\n\ntype t =\n | Local of { name: string; stamp: int }\n | Scoped of { name: string; stamp: int; scope: int }\n | Global of string\n | Predef of { name: string; stamp: int }\n (* the stamp is here only for fast comparison, but the name of\n predefined identifiers is always unique. *)\n\n(* A stamp of 0 denotes a persistent identifier *)\n\nlet currentstamp = s_ref 0\nlet predefstamp = s_ref 0\n\nlet create_scoped ~scope s =\n incr currentstamp;\n Scoped { name = s; stamp = !currentstamp; scope }\n\nlet create_local s =\n incr currentstamp;\n Local { name = s; stamp = !currentstamp }\n\nlet create_predef s =\n incr predefstamp;\n Predef { name = s; stamp = !predefstamp }\n\nlet create_persistent s =\n Global s\n\nlet name = function\n | Local { name; _ }\n | Scoped { name; _ }\n | Global name\n | Predef { name; _ } -> name\n\nlet rename = function\n | Local { name; stamp = _ }\n | Scoped { name; stamp = _; scope = _ } ->\n incr currentstamp;\n Local { name; stamp = !currentstamp }\n | id ->\n Misc.fatal_errorf \"Ident.rename %s\" (name id)\n\nlet unique_name = function\n | Local { name; stamp }\n | Scoped { name; stamp } -> name ^ \"_\" ^ Int.to_string stamp\n | Global name ->\n (* we're adding a fake stamp, because someone could have named his unit\n [Foo_123] and since we're using unique_name to produce symbol names,\n we might clash with an ident [Local { \"Foo\"; 123 }]. *)\n name ^ \"_0\"\n | Predef { name; _ } ->\n (* we know that none of the predef names (currently) finishes in\n \"_\", and that their name is unique. *)\n name\n\nlet unique_toplevel_name = function\n | Local { name; stamp }\n | Scoped { name; stamp } -> name ^ \"/\" ^ Int.to_string stamp\n | Global name\n | Predef { name; _ } -> name\n\nlet persistent = function\n | Global _ -> true\n | _ -> false\n\nlet equal i1 i2 =\n match i1, i2 with\n | Local { name = name1; _ }, Local { name = name2; _ }\n | Scoped { name = name1; _ }, Scoped { name = name2; _ }\n | Global name1, Global name2 ->\n name1 = name2\n | Predef { stamp = s1; _ }, Predef { stamp = s2 } ->\n (* if they don't have the same stamp, they don't have the same name *)\n s1 = s2\n | _ ->\n false\n\nlet same i1 i2 =\n match i1, i2 with\n | Local { stamp = s1; _ }, Local { stamp = s2; _ }\n | Scoped { stamp = s1; _ }, Scoped { stamp = s2; _ }\n | Predef { stamp = s1; _ }, Predef { stamp = s2 } ->\n s1 = s2\n | Global name1, Global name2 ->\n name1 = name2\n | _ ->\n false\n\nlet stamp = function\n | Local { stamp; _ }\n | Scoped { stamp; _ } -> stamp\n | _ -> 0\n\nlet scope = function\n | Scoped { scope; _ } -> scope\n | Local _ -> highest_scope\n | Global _ | Predef _ -> lowest_scope\n\nlet reinit_level = ref (-1)\n\nlet reinit () =\n if !reinit_level < 0\n then reinit_level := !currentstamp\n else currentstamp := !reinit_level\n\nlet global = function\n | Local _\n | Scoped _ -> false\n | Global _\n | Predef _ -> true\n\nlet is_predef = function\n | Predef _ -> true\n | _ -> false\n\nlet print ~with_scope ppf =\n let open Format in\n function\n | Global name -> fprintf ppf \"%s!\" name\n | Predef { name; stamp = n } ->\n fprintf ppf \"%s%s!\" name\n (if !Clflags.unique_ids then sprintf \"/%i\" n else \"\")\n | Local { name; stamp = n } ->\n fprintf ppf \"%s%s\" name\n (if !Clflags.unique_ids then sprintf \"/%i\" n else \"\")\n | Scoped { name; stamp = n; scope } ->\n fprintf ppf \"%s%s%s\" name\n (if !Clflags.unique_ids then sprintf \"/%i\" n else \"\")\n (if with_scope then sprintf \"[%i]\" scope else \"\")\n\nlet print_with_scope ppf id = print ~with_scope:true ppf id\n\nlet print ppf id = print ~with_scope:false ppf id\n\ntype 'a tbl =\n Empty\n | Node of 'a tbl * 'a data * 'a tbl * int\n\nand 'a data =\n { ident: t;\n data: 'a;\n previous: 'a data option }\n\nlet empty = Empty\n\n(* Inline expansion of height for better speed\n * let height = function\n * Empty -> 0\n * | Node(_,_,_,h) -> h\n *)\n\nlet mknode l d r =\n let hl = match l with Empty -> 0 | Node(_,_,_,h) -> h\n and hr = match r with Empty -> 0 | Node(_,_,_,h) -> h in\n Node(l, d, r, (if hl >= hr then hl + 1 else hr + 1))\n\nlet balance l d r =\n let hl = match l with Empty -> 0 | Node(_,_,_,h) -> h\n and hr = match r with Empty -> 0 | Node(_,_,_,h) -> h in\n if hl > hr + 1 then\n match l with\n | Node (ll, ld, lr, _)\n when (match ll with Empty -> 0 | Node(_,_,_,h) -> h) >=\n (match lr with Empty -> 0 | Node(_,_,_,h) -> h) ->\n mknode ll ld (mknode lr d r)\n | Node (ll, ld, Node(lrl, lrd, lrr, _), _) ->\n mknode (mknode ll ld lrl) lrd (mknode lrr d r)\n | _ -> assert false\n else if hr > hl + 1 then\n match r with\n | Node (rl, rd, rr, _)\n when (match rr with Empty -> 0 | Node(_,_,_,h) -> h) >=\n (match rl with Empty -> 0 | Node(_,_,_,h) -> h) ->\n mknode (mknode l d rl) rd rr\n | Node (Node (rll, rld, rlr, _), rd, rr, _) ->\n mknode (mknode l d rll) rld (mknode rlr rd rr)\n | _ -> assert false\n else\n mknode l d r\n\nlet rec add id data = function\n Empty ->\n Node(Empty, {ident = id; data = data; previous = None}, Empty, 1)\n | Node(l, k, r, h) ->\n let c = String.compare (name id) (name k.ident) in\n if c = 0 then\n Node(l, {ident = id; data = data; previous = Some k}, r, h)\n else if c < 0 then\n balance (add id data l) k r\n else\n balance l k (add id data r)\n\nlet rec min_binding = function\n Empty -> raise Not_found\n | Node (Empty, d, _, _) -> d\n | Node (l, _, _, _) -> min_binding l\n\nlet rec remove_min_binding = function\n Empty -> invalid_arg \"Map.remove_min_elt\"\n | Node (Empty, _, r, _) -> r\n | Node (l, d, r, _) -> balance (remove_min_binding l) d r\n\nlet merge t1 t2 =\n match (t1, t2) with\n (Empty, t) -> t\n | (t, Empty) -> t\n | (_, _) ->\n let d = min_binding t2 in\n balance t1 d (remove_min_binding t2)\n\nlet rec remove id = function\n Empty ->\n Empty\n | (Node (l, k, r, h) as m) ->\n let c = String.compare (name id) (name k.ident) in\n if c = 0 then\n match k.previous with\n | None -> merge l r\n | Some k -> Node (l, k, r, h)\n else if c < 0 then\n let ll = remove id l in if l == ll then m else balance ll k r\n else\n let rr = remove id r in if r == rr then m else balance l k rr\n\nlet rec find_previous id = function\n None ->\n raise Not_found\n | Some k ->\n if same id k.ident then k.data else find_previous id k.previous\n\nlet rec find_same id = function\n Empty ->\n raise Not_found\n | Node(l, k, r, _) ->\n let c = String.compare (name id) (name k.ident) in\n if c = 0 then\n if same id k.ident\n then k.data\n else find_previous id k.previous\n else\n find_same id (if c < 0 then l else r)\n\nlet rec find_name n = function\n Empty ->\n raise Not_found\n | Node(l, k, r, _) ->\n let c = String.compare n (name k.ident) in\n if c = 0 then\n k.ident, k.data\n else\n find_name n (if c < 0 then l else r)\n\nlet rec get_all = function\n | None -> []\n | Some k -> (k.ident, k.data) :: get_all k.previous\n\nlet rec find_all n = function\n Empty ->\n []\n | Node(l, k, r, _) ->\n let c = String.compare n (name k.ident) in\n if c = 0 then\n (k.ident, k.data) :: get_all k.previous\n else\n find_all n (if c < 0 then l else r)\n\nlet rec fold_aux f stack accu = function\n Empty ->\n begin match stack with\n [] -> accu\n | a :: l -> fold_aux f l accu a\n end\n | Node(l, k, r, _) ->\n fold_aux f (l :: stack) (f k accu) r\n\nlet fold_name f tbl accu = fold_aux (fun k -> f k.ident k.data) [] accu tbl\n\nlet rec fold_data f d accu =\n match d with\n None -> accu\n | Some k -> f k.ident k.data (fold_data f k.previous accu)\n\nlet fold_all f tbl accu =\n fold_aux (fun k -> fold_data f (Some k)) [] accu tbl\n\n(* let keys tbl = fold_name (fun k _ accu -> k::accu) tbl [] *)\n\nlet rec iter f = function\n Empty -> ()\n | Node(l, k, r, _) ->\n iter f l; f k.ident k.data; iter f r\n\n(* Idents for sharing keys *)\n\n(* They should be 'totally fresh' -> neg numbers *)\nlet key_name = \"\"\n\nlet make_key_generator () =\n let c = ref 1 in\n function\n | Local _\n | Scoped _ ->\n let stamp = !c in\n decr c ;\n Local { name = key_name; stamp = stamp }\n | global_id ->\n Misc.fatal_errorf \"Ident.make_key_generator () %s\" (name global_id)\n\nlet compare x y =\n match x, y with\n | Local x, Local y ->\n let c = x.stamp - y.stamp in\n if c <> 0 then c\n else compare x.name y.name\n | Local _, _ -> 1\n | _, Local _ -> (-1)\n | Scoped x, Scoped y ->\n let c = x.stamp - y.stamp in\n if c <> 0 then c\n else compare x.name y.name\n | Scoped _, _ -> 1\n | _, Scoped _ -> (-1)\n | Global x, Global y -> compare x y\n | Global _, _ -> 1\n | _, Global _ -> (-1)\n | Predef { stamp = s1; _ }, Predef { stamp = s2; _ } -> compare s1 s2\n\nlet output oc id = output_string oc (unique_name id)\nlet hash i = (Char.code (name i).[0]) lxor (stamp i)\n\nlet original_equal = equal\ninclude Identifiable.Make (struct\n type nonrec t = t\n let compare = compare\n let output = output\n let print = print\n let hash = hash\n let equal = same\nend)\nlet equal = original_equal\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Jeremie Dimino, Jane Street Europe *)\n(* *)\n(* Copyright 2015 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 Asttypes\nopen Parsetree\n\ntype error =\n | Multiple_attributes of string\n | No_payload_expected of string\n\nexception Error of Location.t * error\n\nlet get_no_payload_attribute alt_names attrs =\n match List.filter (fun a -> List.mem a.attr_name.txt alt_names) attrs with\n | [] -> None\n | [ {attr_name = name; attr_payload = PStr []; attr_loc = _} ] -> Some name\n | [ {attr_name = name; _} ] ->\n raise (Error (name.loc, No_payload_expected name.txt))\n | _ :: {attr_name = name; _} :: _ ->\n raise (Error (name.loc, Multiple_attributes name.txt))\n\nlet has_no_payload_attribute alt_names attrs =\n match get_no_payload_attribute alt_names attrs with\n | None -> false\n | Some _ -> true\n\nopen Format\n\nlet report_error ppf = function\n | Multiple_attributes name ->\n fprintf ppf \"Too many `%s' attributes\" name\n | No_payload_expected name ->\n fprintf ppf \"Attribute `%s' does not accept a payload\" name\n\nlet () =\n Location.register_error_of_exn\n (function\n | Error (loc, err) ->\n Some (Location.error_of_printer ~loc report_error err)\n | _ ->\n None\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(* Description of primitive functions *)\n\nopen Misc\nopen Parsetree\n\ntype boxed_integer = Pnativeint | Pint32 | Pint64\n\ntype native_repr =\n | Same_as_ocaml_repr\n | Unboxed_float\n | Unboxed_integer of boxed_integer\n | Untagged_int\n\ntype description =\n { prim_name: string; (* Name of primitive or C function *)\n prim_arity: int; (* Number of arguments *)\n prim_alloc: bool; (* Does it allocates or raise? *)\n prim_native_name: string; (* Name of C function for the nat. code gen. *)\n prim_native_repr_args: native_repr list;\n prim_native_repr_res: native_repr }\n\ntype error =\n | Old_style_float_with_native_repr_attribute\n | Old_style_noalloc_with_noalloc_attribute\n | No_native_primitive_with_repr_attribute\n\nexception Error of Location.t * error\n\nlet is_ocaml_repr = function\n | Same_as_ocaml_repr -> true\n | Unboxed_float\n | Unboxed_integer _\n | Untagged_int -> false\n\nlet is_unboxed = function\n | Same_as_ocaml_repr\n | Untagged_int -> false\n | Unboxed_float\n | Unboxed_integer _ -> true\n\nlet is_untagged = function\n | Untagged_int -> true\n | Same_as_ocaml_repr\n | Unboxed_float\n | Unboxed_integer _ -> false\n\nlet rec make_native_repr_args arity x =\n if arity = 0 then\n []\n else\n x :: make_native_repr_args (arity - 1) x\n\nlet simple ~name ~arity ~alloc =\n {prim_name = name;\n prim_arity = arity;\n prim_alloc = alloc;\n prim_native_name = \"\";\n prim_native_repr_args = make_native_repr_args arity Same_as_ocaml_repr;\n prim_native_repr_res = Same_as_ocaml_repr}\n\nlet make ~name ~alloc ~native_name ~native_repr_args ~native_repr_res =\n {prim_name = name;\n prim_arity = List.length native_repr_args;\n prim_alloc = alloc;\n prim_native_name = native_name;\n prim_native_repr_args = native_repr_args;\n prim_native_repr_res = native_repr_res}\n\nlet parse_declaration valdecl ~native_repr_args ~native_repr_res =\n let arity = List.length native_repr_args in\n let name, native_name, old_style_noalloc, old_style_float =\n match valdecl.pval_prim with\n | name :: \"noalloc\" :: name2 :: \"float\" :: _ -> (name, name2, true, true)\n | name :: \"noalloc\" :: name2 :: _ -> (name, name2, true, false)\n | name :: name2 :: \"float\" :: _ -> (name, name2, false, true)\n | name :: \"noalloc\" :: _ -> (name, \"\", true, false)\n | name :: name2 :: _ -> (name, name2, false, false)\n | name :: _ -> (name, \"\", false, false)\n | [] ->\n fatal_error \"Primitive.parse_declaration\"\n in\n let noalloc_attribute =\n Attr_helper.has_no_payload_attribute [\"noalloc\"; \"ocaml.noalloc\"]\n valdecl.pval_attributes\n in\n if old_style_float &&\n not (List.for_all is_ocaml_repr native_repr_args &&\n is_ocaml_repr native_repr_res) then\n raise (Error (valdecl.pval_loc,\n Old_style_float_with_native_repr_attribute));\n if old_style_noalloc && noalloc_attribute then\n raise (Error (valdecl.pval_loc,\n Old_style_noalloc_with_noalloc_attribute));\n (* The compiler used to assume \"noalloc\" with \"float\", we just make this\n explicit now (GPR#167): *)\n let old_style_noalloc = old_style_noalloc || old_style_float in\n if old_style_float then\n Location.deprecated valdecl.pval_loc\n \"[@@unboxed] + [@@noalloc] should be used\\n\\\n instead of \\\"float\\\"\"\n else if old_style_noalloc then\n Location.deprecated valdecl.pval_loc\n \"[@@noalloc] should be used instead of \\\"noalloc\\\"\";\n if native_name = \"\" &&\n not (List.for_all is_ocaml_repr native_repr_args &&\n is_ocaml_repr native_repr_res) then\n raise (Error (valdecl.pval_loc,\n No_native_primitive_with_repr_attribute));\n let noalloc = old_style_noalloc || noalloc_attribute in\n let native_repr_args, native_repr_res =\n if old_style_float then\n (make_native_repr_args arity Unboxed_float, Unboxed_float)\n else\n (native_repr_args, native_repr_res)\n in\n {prim_name = name;\n prim_arity = arity;\n prim_alloc = not noalloc;\n prim_native_name = native_name;\n prim_native_repr_args = native_repr_args;\n prim_native_repr_res = native_repr_res}\n\nopen Outcometree\n\nlet rec add_native_repr_attributes ty attrs =\n match ty, attrs with\n | Otyp_arrow (label, a, b), attr_opt :: rest ->\n let b = add_native_repr_attributes b rest in\n let a =\n match attr_opt with\n | None -> a\n | Some attr -> Otyp_attribute (a, attr)\n in\n Otyp_arrow (label, a, b)\n | _, [Some attr] -> Otyp_attribute (ty, attr)\n | _ ->\n assert (List.for_all (fun x -> x = None) attrs);\n ty\n\nlet oattr_unboxed = { oattr_name = \"unboxed\" }\nlet oattr_untagged = { oattr_name = \"untagged\" }\nlet oattr_noalloc = { oattr_name = \"noalloc\" }\n\nlet print p osig_val_decl =\n let prims =\n if p.prim_native_name <> \"\" then\n [p.prim_name; p.prim_native_name]\n else\n [p.prim_name]\n in\n let for_all f =\n List.for_all f p.prim_native_repr_args && f p.prim_native_repr_res\n in\n let all_unboxed = for_all is_unboxed in\n let all_untagged = for_all is_untagged in\n let attrs = if p.prim_alloc then [] else [oattr_noalloc] in\n let attrs =\n if all_unboxed then\n oattr_unboxed :: attrs\n else if all_untagged then\n oattr_untagged :: attrs\n else\n attrs\n in\n let attr_of_native_repr = function\n | Same_as_ocaml_repr -> None\n | Unboxed_float\n | Unboxed_integer _ -> if all_unboxed then None else Some oattr_unboxed\n | Untagged_int -> if all_untagged then None else Some oattr_untagged\n in\n let type_attrs =\n List.map attr_of_native_repr p.prim_native_repr_args @\n [attr_of_native_repr p.prim_native_repr_res]\n in\n { osig_val_decl with\n oval_prims = prims;\n oval_type = add_native_repr_attributes osig_val_decl.oval_type type_attrs;\n oval_attributes = attrs }\n\nlet native_name p =\n if p.prim_native_name <> \"\"\n then p.prim_native_name\n else p.prim_name\n\nlet byte_name p =\n p.prim_name\n\nlet equal_boxed_integer bi1 bi2 =\n match bi1, bi2 with\n | Pnativeint, Pnativeint\n | Pint32, Pint32\n | Pint64, Pint64 ->\n true\n | (Pnativeint | Pint32 | Pint64), _ ->\n false\n\nlet equal_native_repr nr1 nr2 =\n match nr1, nr2 with\n | Same_as_ocaml_repr, Same_as_ocaml_repr -> true\n | Same_as_ocaml_repr,\n (Unboxed_float | Unboxed_integer _ | Untagged_int) -> false\n | Unboxed_float, Unboxed_float -> true\n | Unboxed_float,\n (Same_as_ocaml_repr | Unboxed_integer _ | Untagged_int) -> false\n | Unboxed_integer bi1, Unboxed_integer bi2 -> equal_boxed_integer bi1 bi2\n | Unboxed_integer _,\n (Same_as_ocaml_repr | Unboxed_float | Untagged_int) -> false\n | Untagged_int, Untagged_int -> true\n | Untagged_int,\n (Same_as_ocaml_repr | Unboxed_float | Unboxed_integer _) -> false\n\nlet native_name_is_external p =\n let nat_name = native_name p in\n nat_name <> \"\" && nat_name.[0] <> '%'\n\nlet report_error ppf err =\n match err with\n | Old_style_float_with_native_repr_attribute ->\n Format.fprintf ppf \"Cannot use \\\"float\\\" in conjunction with \\\n [%@unboxed]/[%@untagged].\"\n | Old_style_noalloc_with_noalloc_attribute ->\n Format.fprintf ppf \"Cannot use \\\"noalloc\\\" in conjunction with \\\n [%@%@noalloc].\"\n | No_native_primitive_with_repr_attribute ->\n Format.fprintf ppf\n \"[@The native code version of the primitive is mandatory@ \\\n when attributes [%@untagged] or [%@unboxed] are present.@]\"\n\nlet () =\n Location.register_error_of_exn\n (function\n | Error (loc, err) ->\n Some (Location.error_of_printer ~loc report_error err)\n | _ ->\n None\n )\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Ulysse Gérard, Thomas Refis, Tarides *)\n(* *)\n(* Copyright 2021 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 Uid = struct\n type t =\n | Compilation_unit of string\n | Item of { comp_unit: string; id: int }\n | Internal\n | Predef of string\n\n include Identifiable.Make(struct\n type nonrec t = t\n\n let equal (x : t) y = x = y\n let compare (x : t) y = compare x y\n let hash (x : t) = Hashtbl.hash x\n\n let print fmt = function\n | Internal -> Format.pp_print_string fmt \"\"\n | Predef name -> Format.fprintf fmt \"\" name\n | Compilation_unit s -> Format.pp_print_string fmt s\n | Item { comp_unit; id } -> Format.fprintf fmt \"%s.%d\" comp_unit id\n\n let output oc t =\n let fmt = Format.formatter_of_out_channel oc in\n print fmt t\n end)\n\n let id = ref (-1)\n\n let reinit () = id := (-1)\n\n let mk ~current_unit =\n incr id;\n Item { comp_unit = current_unit; id = !id }\n\n let of_compilation_unit_id id =\n if not (Ident.persistent id) then\n Misc.fatal_errorf \"Types.Uid.of_compilation_unit_id %S\" (Ident.name id);\n Compilation_unit (Ident.name id)\n\n let of_predef_id id =\n if not (Ident.is_predef id) then\n Misc.fatal_errorf \"Types.Uid.of_predef_id %S\" (Ident.name id);\n Predef (Ident.name id)\n\n let internal_not_actually_unique = Internal\n\n let for_actual_declaration = function\n | Item _ -> true\n | _ -> false\nend\n\nmodule Sig_component_kind = struct\n type t =\n | Value\n | Type\n | Module\n | Module_type\n | Extension_constructor\n | Class\n | Class_type\n\n let to_string = function\n | Value -> \"value\"\n | Type -> \"type\"\n | Module -> \"module\"\n | Module_type -> \"module type\"\n | Extension_constructor -> \"extension constructor\"\n | Class -> \"class\"\n | Class_type -> \"class type\"\n\n let can_appear_in_types = function\n | Value\n | Extension_constructor ->\n false\n | Type\n | Module\n | Module_type\n | Class\n | Class_type ->\n true\nend\n\nmodule Item = struct\n module T = struct\n type t = string * Sig_component_kind.t\n let compare = compare\n\n let make str ns = str, ns\n\n let value id = Ident.name id, Sig_component_kind.Value\n let type_ id = Ident.name id, Sig_component_kind.Type\n let module_ id = Ident.name id, Sig_component_kind.Module\n let module_type id = Ident.name id, Sig_component_kind.Module_type\n let extension_constructor id =\n Ident.name id, Sig_component_kind.Extension_constructor\n let class_ id =\n Ident.name id, Sig_component_kind.Class\n let class_type id =\n Ident.name id, Sig_component_kind.Class_type\n\n let print fmt (name, ns) =\n Format.fprintf fmt \"%S[%s]\"\n name\n (Sig_component_kind.to_string ns)\n end\n\n include T\n\n module Map = Map.Make(T)\nend\n\ntype var = Ident.t\ntype t = { uid: Uid.t option; desc: desc }\nand desc =\n | Var of var\n | Abs of var * t\n | App of t * t\n | Struct of t Item.Map.t\n | Leaf\n | Proj of t * Item.t\n | Comp_unit of string\n\nlet print fmt =\n let print_uid_opt =\n Format.pp_print_option (fun fmt -> Format.fprintf fmt \"<%a>\" Uid.print)\n in\n let rec aux fmt { uid; desc } =\n match desc with\n | Var id ->\n Format.fprintf fmt \"%a%a\" Ident.print id print_uid_opt uid\n | Abs (id, t) ->\n Format.fprintf fmt \"Abs@[%a@,(@[%a,@ @[%a@]@])@]\"\n print_uid_opt uid Ident.print id aux t\n | App (t1, t2) ->\n Format.fprintf fmt \"@[%a(@,%a)%a@]\" aux t1 aux t2\n print_uid_opt uid\n | Leaf ->\n Format.fprintf fmt \"<%a>\" (Format.pp_print_option Uid.print) uid\n | Proj (t, item) ->\n begin match uid with\n | None ->\n Format.fprintf fmt \"@[%a@ .@ %a@]\"\n aux t\n Item.print item\n | Some uid ->\n Format.fprintf fmt \"@[(%a@ .@ %a)<%a>@]\"\n aux t\n Item.print item\n Uid.print uid\n end\n | Comp_unit name -> Format.fprintf fmt \"CU %s\" name\n | Struct map ->\n let print_map fmt =\n Item.Map.iter (fun item t ->\n Format.fprintf fmt \"@[%a ->@ %a;@]@,\"\n Item.print item\n aux t\n )\n in\n Format.fprintf fmt \"{@[%a@,%a@]}\" print_uid_opt uid print_map map\n in\n Format.fprintf fmt\"@[%a@]@;\" aux\n\nlet fresh_var ?(name=\"shape-var\") uid =\n let var = Ident.create_local name in\n var, { uid = Some uid; desc = Var var }\n\nlet for_unnamed_functor_param = Ident.create_local \"()\"\n\nlet var uid id =\n { uid = Some uid; desc = Var id }\n\nlet abs ?uid var body =\n { uid; desc = Abs (var, body) }\n\nlet str ?uid map =\n { uid; desc = Struct map }\n\nlet leaf uid =\n { uid = Some uid; desc = Leaf }\n\nlet proj ?uid t item =\n match t.desc with\n | Leaf ->\n (* When stuck projecting in a leaf we propagate the leaf\n as a best effort *)\n t\n | Struct map ->\n begin try Item.Map.find item map\n with Not_found -> t (* ill-typed program *)\n end\n | _ ->\n { uid; desc = Proj (t, item) }\n\nlet app ?uid f ~arg =\n { uid; desc = App (f, arg) }\n\nlet decompose_abs t =\n match t.desc with\n | Abs (x, t) -> Some (x, t)\n | _ -> None\n\nmodule Make_reduce(Params : sig\n type env\n val fuel : int\n val read_unit_shape : unit_name:string -> t option\n val find_shape : env -> Ident.t -> t\nend) = struct\n (* We implement a strong call-by-need reduction, following an\n evaluator from Nathanaelle Courant. *)\n\n type nf = { uid: Uid.t option; desc: nf_desc }\n and nf_desc =\n | NVar of var\n | NApp of nf * nf\n | NAbs of local_env * var * t * delayed_nf\n | NStruct of delayed_nf Item.Map.t\n | NProj of nf * Item.t\n | NLeaf\n | NComp_unit of string\n | NoFuelLeft of desc\n (* A type of normal forms for strong call-by-need evaluation.\n The normal form of an abstraction\n Abs(x, t)\n is a closure\n NAbs(env, x, t, dnf)\n when [env] is the local environment, and [dnf] is a delayed\n normal form of [t].\n\n A \"delayed normal form\" is morally equivalent to (nf Lazy.t), but\n we use a different representation that is compatible with\n memoization (lazy values are not hashable/comparable by default\n comparison functions): we represent a delayed normal form as\n just a not-yet-computed pair [local_env * t] of a term in a\n local environment -- we could also see this as a term under\n an explicit substitution. This delayed thunked is \"forced\"\n by calling the normalization function as usual, but duplicate\n computations are precisely avoided by memoization.\n *)\n and delayed_nf = Thunk of local_env * t\n\n and local_env = delayed_nf option Ident.Map.t\n (* When reducing in the body of an abstraction [Abs(x, body)], we\n bind [x] to [None] in the environment. [Some v] is used for\n actual substitutions, for example in [App(Abs(x, body), t)], when\n [v] is a thunk that will evaluate to the normal form of [t]. *)\n\n let improve_uid uid (nf : nf) =\n match nf.uid with\n | Some _ -> nf\n | None -> { nf with uid }\n\n let in_memo_table memo_table memo_key f arg =\n match Hashtbl.find memo_table memo_key with\n | res -> res\n | exception Not_found ->\n let res = f arg in\n Hashtbl.replace memo_table memo_key res;\n res\n\n type env = {\n fuel: int ref;\n global_env: Params.env;\n local_env: local_env;\n reduce_memo_table: (local_env * t, nf) Hashtbl.t;\n read_back_memo_table: (nf, t) Hashtbl.t;\n }\n\n let bind env var shape =\n { env with local_env = Ident.Map.add var shape env.local_env }\n\n let rec reduce_ env t =\n let memo_key = (env.local_env, t) in\n in_memo_table env.reduce_memo_table memo_key (reduce__ env) t\n (* Memoization is absolutely essential for performance on this\n problem, because the normal forms we build can in some real-world\n cases contain an exponential amount of redundancy. Memoization\n can avoid the repeated evaluation of identical subterms,\n providing a large speedup, but even more importantly it\n implicitly shares the memory of the repeated results, providing\n much smaller normal forms (that blow up again if printed back\n as trees). A functor-heavy file from Irmin has its shape normal\n form decrease from 100Mio to 2.5Mio when memoization is enabled.\n\n Note: the local environment is part of the memoization key, while\n it is defined using a type Ident.Map.t of non-canonical balanced\n trees: two maps could have exactly the same items, but be\n balanced differently and therefore hash differently, reducing\n the effectivenss of memoization.\n This could in theory happen, say, with the two programs\n (fun x -> fun y -> ...)\n and\n (fun y -> fun x -> ...)\n having \"the same\" local environments, with additions done in\n a different order, giving non-structurally-equal trees. Should we\n define our own hash functions to provide robust hashing on\n environments?\n\n We believe that the answer is \"no\": this problem does not occur\n in practice. We can assume that identifiers are unique on valid\n typedtree fragments (identifier \"stamps\" distinguish\n binding positions); in particular the two program fragments above\n in fact bind *distinct* identifiers x (with different stamps) and\n different identifiers y, so the environments are distinct. If two\n environments are structurally the same, they must correspond to\n the evaluation evnrionments of two sub-terms that are under\n exactly the same scope of binders. So the two environments were\n obtained by the same term traversal, adding binders in the same\n order, giving the same balanced trees: the environments have the\n same hash.\n*)\n\n and reduce__ ({fuel; global_env; local_env; _} as env) (t : t) =\n let reduce env t = reduce_ env t in\n let delay_reduce env t = Thunk (env.local_env, t) in\n let force (Thunk (local_env, t)) =\n reduce { env with local_env } t in\n let return desc : nf = { uid = t.uid; desc } in\n if !fuel < 0 then return (NoFuelLeft t.desc)\n else\n match t.desc with\n | Comp_unit unit_name ->\n begin match Params.read_unit_shape ~unit_name with\n | Some t -> reduce env t\n | None -> return (NComp_unit unit_name)\n end\n | App(f, arg) ->\n let f = reduce env f in\n begin match f.desc with\n | NAbs(clos_env, var, body, _body_nf) ->\n let arg = delay_reduce env arg in\n let env = bind { env with local_env = clos_env } var (Some arg) in\n reduce env body\n |> improve_uid t.uid\n | _ ->\n let arg = reduce env arg in\n return (NApp(f, arg))\n end\n | Proj(str, item) ->\n let str = reduce env str in\n let nored () = return (NProj(str, item)) in\n begin match str.desc with\n | NStruct (items) ->\n begin match Item.Map.find item items with\n | exception Not_found -> nored ()\n | nf ->\n force nf\n |> improve_uid t.uid\n end\n | _ ->\n nored ()\n end\n | Abs(var, body) ->\n let body_nf = delay_reduce (bind env var None) body in\n return (NAbs(local_env, var, body, body_nf))\n | Var id ->\n begin match Ident.Map.find id local_env with\n (* Note: instead of binding abstraction-bound variables to\n [None], we could unify it with the [Some v] case by\n binding the bound variable [x] to [NVar x].\n\n One reason to distinguish the situations is that we can\n provide a different [Uid.t] location; for bound\n variables, we use the [Uid.t] of the bound occurrence\n (not the binding site), whereas for bound values we use\n their binding-time [Uid.t]. *)\n | None -> return (NVar id)\n | Some def -> force def\n | exception Not_found ->\n match Params.find_shape global_env id with\n | exception Not_found -> return (NVar id)\n | res when res = t -> return (NVar id)\n | res ->\n decr fuel;\n reduce env res\n end\n | Leaf -> return NLeaf\n | Struct m ->\n let mnf = Item.Map.map (delay_reduce env) m in\n return (NStruct mnf)\n\n let rec read_back env (nf : nf) : t =\n in_memo_table env.read_back_memo_table nf (read_back_ env) nf\n (* The [nf] normal form we receive may contain a lot of internal\n sharing due to the use of memoization in the evaluator. We have\n to memoize here again, otherwise the sharing is lost by mapping\n over the term as a tree. *)\n\n and read_back_ env (nf : nf) : t =\n { uid = nf.uid; desc = read_back_desc env nf.desc }\n\n and read_back_desc env desc =\n let read_back nf = read_back env nf in\n let read_back_force (Thunk (local_env, t)) =\n read_back (reduce_ { env with local_env } t) in\n match desc with\n | NVar v ->\n Var v\n | NApp (nft, nfu) ->\n App(read_back nft, read_back nfu)\n | NAbs (_env, x, _t, nf) ->\n Abs(x, read_back_force nf)\n | NStruct nstr ->\n Struct (Item.Map.map read_back_force nstr)\n | NProj (nf, item) ->\n Proj (read_back nf, item)\n | NLeaf -> Leaf\n | NComp_unit s -> Comp_unit s\n | NoFuelLeft t -> t\n\n let reduce global_env t =\n let fuel = ref Params.fuel in\n let reduce_memo_table = Hashtbl.create 42 in\n let read_back_memo_table = Hashtbl.create 42 in\n let local_env = Ident.Map.empty in\n let env = {\n fuel;\n global_env;\n reduce_memo_table;\n read_back_memo_table;\n local_env;\n } in\n reduce_ env t |> read_back env\nend\n\nmodule Local_reduce =\n (* Note: this definition with [type env = unit] is only suitable for\n reduction of toplevel shapes -- shapes of compilation units,\n where free variables are only Comp_unit names. If we wanted to\n reduce shapes inside module signatures, we would need to take\n a typing environment as parameter. *)\n Make_reduce(struct\n type env = unit\n let fuel = 10\n let read_unit_shape ~unit_name:_ = None\n let find_shape _env _id = raise Not_found\n end)\n\nlet local_reduce shape =\n Local_reduce.reduce () shape\n\nlet dummy_mod = { uid = None; desc = Struct Item.Map.empty }\n\nlet of_path ~find_shape ~namespace =\n let rec aux : Sig_component_kind.t -> Path.t -> t = fun ns -> function\n | Pident id -> find_shape ns id\n | Pdot (path, name) -> proj (aux Module path) (name, ns)\n | Papply (p1, p2) -> app (aux Module p1) ~arg:(aux Module p2)\n in\n aux namespace\n\nlet for_persistent_unit s =\n { uid = Some (Uid.of_compilation_unit_id (Ident.create_persistent s));\n desc = Comp_unit s }\n\nlet leaf_for_unpack = { uid = None; desc = Leaf }\n\nlet set_uid_if_none t uid =\n match t.uid with\n | None -> { t with uid = Some uid }\n | _ -> t\n\nmodule Map = struct\n type shape = t\n type nonrec t = t Item.Map.t\n\n let empty = Item.Map.empty\n\n let add t item shape = Item.Map.add item shape t\n\n let add_value t id uid = Item.Map.add (Item.value id) (leaf uid) t\n let add_value_proj t id shape =\n let item = Item.value id in\n Item.Map.add item (proj shape item) t\n\n let add_type t id uid = Item.Map.add (Item.type_ id) (leaf uid) t\n let add_type_proj t id shape =\n let item = Item.type_ id in\n Item.Map.add item (proj shape item) t\n\n let add_module t id shape = Item.Map.add (Item.module_ id) shape t\n let add_module_proj t id shape =\n let item = Item.module_ id in\n Item.Map.add item (proj shape item) t\n\n let add_module_type t id uid =\n Item.Map.add (Item.module_type id) (leaf uid) t\n let add_module_type_proj t id shape =\n let item = Item.module_type id in\n Item.Map.add item (proj shape item) t\n\n let add_extcons t id uid =\n Item.Map.add (Item.extension_constructor id) (leaf uid) t\n let add_extcons_proj t id shape =\n let item = Item.extension_constructor id in\n Item.Map.add item (proj shape item) t\n\n let add_class t id uid = Item.Map.add (Item.class_ id) (leaf uid) t\n let add_class_proj t id shape =\n let item = Item.class_ id in\n Item.Map.add item (proj shape item) t\n\n let add_class_type t id uid = Item.Map.add (Item.class_type id) (leaf uid) t\n let add_class_type_proj t id shape =\n let item = Item.class_type id in\n Item.Map.add item (proj shape item) t\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy and Jerome Vouillon, 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(* Basic operations on core types *)\n\nopen Asttypes\nopen Types\n\nopen Local_store\n\n(**** Sets, maps and hashtables of types ****)\n\nlet wrap_repr f ty = f (Transient_expr.repr ty)\nlet wrap_type_expr f tty = f (Transient_expr.type_expr tty)\n\nmodule TransientTypeSet = Set.Make(TransientTypeOps)\nmodule TypeSet = struct\n include TransientTypeSet\n let add = wrap_repr add\n let mem = wrap_repr mem\n let singleton = wrap_repr singleton\n let exists p = TransientTypeSet.exists (wrap_type_expr p)\n let elements set =\n List.map Transient_expr.type_expr (TransientTypeSet.elements set)\nend\nmodule TransientTypeMap = Map.Make(TransientTypeOps)\nmodule TypeMap = struct\n include TransientTypeMap\n let add ty = wrap_repr add ty\n let find ty = wrap_repr find ty\n let singleton ty = wrap_repr singleton ty\n let fold f = TransientTypeMap.fold (wrap_type_expr f)\nend\nmodule TransientTypeHash = Hashtbl.Make(TransientTypeOps)\nmodule TypeHash = struct\n include TransientTypeHash\n let add hash = wrap_repr (add hash)\n let find hash = wrap_repr (find hash)\n let iter f = TransientTypeHash.iter (wrap_type_expr f)\nend\nmodule TransientTypePairs =\n Hashtbl.Make (struct\n type t = transient_expr * transient_expr\n let equal (t1, t1') (t2, t2') = (t1 == t2) && (t1' == t2')\n let hash (t, t') = t.id + 93 * t'.id\n end)\nmodule TypePairs = struct\n module H = TransientTypePairs\n open Transient_expr\n\n type t = {\n set : unit H.t;\n mutable elems : (transient_expr * transient_expr) list;\n (* elems preserves the (reversed) insertion order of elements *)\n }\n\n let create n =\n { elems = []; set = H.create n }\n\n let clear t =\n t.elems <- [];\n H.clear t.set\n\n let repr2 (t1, t2) = (repr t1, repr t2)\n\n let add t p =\n let p = repr2 p in\n if H.mem t.set p then () else begin\n H.add t.set p ();\n t.elems <- p :: t.elems\n end\n\n let mem t p = H.mem t.set (repr2 p)\n\n let iter f t =\n (* iterate in insertion order, not Hashtbl.iter order *)\n List.rev t.elems\n |> List.iter (fun (t1,t2) ->\n f (type_expr t1, type_expr t2))\nend\n\n(**** Forward declarations ****)\n\nlet print_raw =\n ref (fun _ -> assert false : Format.formatter -> type_expr -> unit)\n\n(**** Type level management ****)\n\nlet generic_level = Ident.highest_scope\n\n(* Used to mark a type during a traversal. *)\nlet lowest_level = Ident.lowest_scope\nlet pivot_level = 2 * lowest_level - 1\n (* pivot_level - lowest_level < lowest_level *)\n\n(**** Some type creators ****)\n\nlet newgenty desc = newty2 ~level:generic_level desc\nlet newgenvar ?name () = newgenty (Tvar name)\nlet newgenstub ~scope = newty3 ~level:generic_level ~scope (Tvar None)\n\n(*\nlet newmarkedvar level =\n incr new_id; { desc = Tvar; level = pivot_level - level; id = !new_id }\nlet newmarkedgenvar () =\n incr new_id;\n { desc = Tvar; level = pivot_level - generic_level; id = !new_id }\n*)\n\n(**** Check some types ****)\n\nlet is_Tvar ty = match get_desc ty with Tvar _ -> true | _ -> false\nlet is_Tunivar ty = match get_desc ty with Tunivar _ -> true | _ -> false\nlet is_Tconstr ty = match get_desc ty with Tconstr _ -> true | _ -> false\n\nlet dummy_method = \"*dummy method*\"\n\n(**** Representative of a type ****)\n\nlet merge_fixed_explanation fixed1 fixed2 =\n match fixed1, fixed2 with\n | Some Univar _ as x, _ | _, (Some Univar _ as x) -> x\n | Some Fixed_private as x, _ | _, (Some Fixed_private as x) -> x\n | Some Reified _ as x, _ | _, (Some Reified _ as x) -> x\n | Some Rigid as x, _ | _, (Some Rigid as x) -> x\n | None, None -> None\n\n\nlet fixed_explanation row =\n match row_fixed row with\n | Some _ as x -> x\n | None ->\n let ty = row_more row in\n match get_desc ty with\n | Tvar _ | Tnil -> None\n | Tunivar _ -> Some (Univar ty)\n | Tconstr (p,_,_) -> Some (Reified p)\n | _ -> assert false\n\nlet is_fixed row = match row_fixed row with\n | None -> false\n | Some _ -> true\n\nlet has_fixed_explanation row = fixed_explanation row <> None\n\nlet static_row row =\n row_closed row &&\n List.for_all\n (fun (_,f) -> match row_field_repr f with Reither _ -> false | _ -> true)\n (row_fields row)\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\nlet proxy ty =\n match get_desc ty with\n | Tvariant row when not (static_row row) ->\n row_more row\n | Tobject (ty, _) ->\n let rec proxy_obj ty =\n match get_desc ty with\n Tfield (_, _, _, ty) -> proxy_obj ty\n | Tvar _ | Tunivar _ | Tconstr _ -> ty\n | Tnil -> ty\n | _ -> assert false\n in proxy_obj ty\n | _ -> ty\n\n(**** Utilities for fixed row private types ****)\n\nlet row_of_type t =\n match get_desc t with\n Tobject(t,_) ->\n let rec get_row t =\n match get_desc t with\n Tfield(_,_,_,t) -> get_row t\n | _ -> t\n in get_row t\n | Tvariant row ->\n row_more row\n | _ ->\n t\n\nlet has_constr_row t =\n not (is_Tconstr t) && is_Tconstr (row_of_type t)\n\nlet is_row_name s =\n let l = String.length s in\n (* PR#10661: when l=4 and s is \"#row\", this is not a row name\n but the valid #-type name of a class named \"row\". *)\n l > 4 && String.sub s (l-4) 4 = \"#row\"\n\nlet is_constr_row ~allow_ident t =\n match get_desc t with\n Tconstr (Path.Pident id, _, _) when allow_ident ->\n is_row_name (Ident.name id)\n | Tconstr (Path.Pdot (_, s), _, _) -> is_row_name s\n | _ -> false\n\n(* TODO: where should this really be *)\n(* Set row_name in Env, cf. GPR#1204/1329 *)\nlet set_static_row_name decl path =\n match decl.type_manifest with\n None -> ()\n | Some ty ->\n match get_desc ty with\n Tvariant row when static_row row ->\n let row =\n set_row_name row (Some (path, decl.type_params)) in\n set_type_desc ty (Tvariant row)\n | _ -> ()\n\n\n (**********************************)\n (* Utilities for type traversal *)\n (**********************************)\n\nlet fold_row f init row =\n let result =\n List.fold_left\n (fun init (_, fi) ->\n match row_field_repr fi with\n | Rpresent(Some ty) -> f init ty\n | Reither(_, tl, _) -> List.fold_left f init tl\n | _ -> init)\n init\n (row_fields row)\n in\n match get_desc (row_more row) with\n | Tvar _ | Tunivar _ | Tsubst _ | Tconstr _ | Tnil ->\n begin match\n Option.map (fun (_,l) -> List.fold_left f result l) (row_name row)\n with\n | None -> result\n | Some result -> result\n end\n | _ -> assert false\n\nlet iter_row f row =\n fold_row (fun () v -> f v) () row\n\nlet fold_type_expr f init ty =\n match get_desc ty with\n Tvar _ -> init\n | Tarrow (_, ty1, ty2, _) ->\n let result = f init ty1 in\n f result ty2\n | Ttuple l -> List.fold_left f init l\n | Tconstr (_, l, _) -> List.fold_left f init l\n | Tobject(ty, {contents = Some (_, p)}) ->\n let result = f init ty in\n List.fold_left f result p\n | Tobject (ty, _) -> f init ty\n | Tvariant row ->\n let result = fold_row f init row in\n f result (row_more row)\n | Tfield (_, _, ty1, ty2) ->\n let result = f init ty1 in\n f result ty2\n | Tnil -> init\n | Tlink _\n | Tsubst _ -> assert false\n | Tunivar _ -> init\n | Tpoly (ty, tyl) ->\n let result = f init ty in\n List.fold_left f result tyl\n | Tpackage (_, fl) ->\n List.fold_left (fun result (_n, ty) -> f result ty) init fl\n\nlet iter_type_expr f ty =\n fold_type_expr (fun () v -> f v) () ty\n\nlet rec iter_abbrev f = function\n Mnil -> ()\n | Mcons(_, _, ty, ty', rem) -> f ty; f ty'; iter_abbrev f rem\n | Mlink rem -> iter_abbrev f !rem\n\ntype type_iterators =\n { it_signature: type_iterators -> signature -> unit;\n it_signature_item: type_iterators -> signature_item -> unit;\n it_value_description: type_iterators -> value_description -> unit;\n it_type_declaration: type_iterators -> type_declaration -> unit;\n it_extension_constructor: type_iterators -> extension_constructor -> unit;\n it_module_declaration: type_iterators -> module_declaration -> unit;\n it_modtype_declaration: type_iterators -> modtype_declaration -> unit;\n it_class_declaration: type_iterators -> class_declaration -> unit;\n it_class_type_declaration: type_iterators -> class_type_declaration -> unit;\n it_functor_param: type_iterators -> functor_parameter -> unit;\n it_module_type: type_iterators -> module_type -> unit;\n it_class_type: type_iterators -> class_type -> unit;\n it_type_kind: type_iterators -> type_decl_kind -> unit;\n it_do_type_expr: type_iterators -> type_expr -> unit;\n it_type_expr: type_iterators -> type_expr -> unit;\n it_path: Path.t -> unit; }\n\nlet iter_type_expr_cstr_args f = function\n | Cstr_tuple tl -> List.iter f tl\n | Cstr_record lbls -> List.iter (fun d -> f d.ld_type) lbls\n\nlet map_type_expr_cstr_args f = function\n | Cstr_tuple tl -> Cstr_tuple (List.map f tl)\n | Cstr_record lbls ->\n Cstr_record (List.map (fun d -> {d with ld_type=f d.ld_type}) lbls)\n\nlet iter_type_expr_kind f = function\n | Type_abstract -> ()\n | Type_variant (cstrs, _) ->\n List.iter\n (fun cd ->\n iter_type_expr_cstr_args f cd.cd_args;\n Option.iter f cd.cd_res\n )\n cstrs\n | Type_record(lbls, _) ->\n List.iter (fun d -> f d.ld_type) lbls\n | Type_open ->\n ()\n\n\nlet type_iterators =\n let it_signature it =\n List.iter (it.it_signature_item it)\n and it_signature_item it = function\n Sig_value (_, vd, _) -> it.it_value_description it vd\n | Sig_type (_, td, _, _) -> it.it_type_declaration it td\n | Sig_typext (_, td, _, _) -> it.it_extension_constructor it td\n | Sig_module (_, _, md, _, _) -> it.it_module_declaration it md\n | Sig_modtype (_, mtd, _) -> it.it_modtype_declaration it mtd\n | Sig_class (_, cd, _, _) -> it.it_class_declaration it cd\n | Sig_class_type (_, ctd, _, _) -> it.it_class_type_declaration it ctd\n and it_value_description it vd =\n it.it_type_expr it vd.val_type\n and it_type_declaration it td =\n List.iter (it.it_type_expr it) td.type_params;\n Option.iter (it.it_type_expr it) td.type_manifest;\n it.it_type_kind it td.type_kind\n and it_extension_constructor it td =\n it.it_path td.ext_type_path;\n List.iter (it.it_type_expr it) td.ext_type_params;\n iter_type_expr_cstr_args (it.it_type_expr it) td.ext_args;\n Option.iter (it.it_type_expr it) td.ext_ret_type\n and it_module_declaration it md =\n it.it_module_type it md.md_type\n and it_modtype_declaration it mtd =\n Option.iter (it.it_module_type it) mtd.mtd_type\n and it_class_declaration it cd =\n List.iter (it.it_type_expr it) cd.cty_params;\n it.it_class_type it cd.cty_type;\n Option.iter (it.it_type_expr it) cd.cty_new;\n it.it_path cd.cty_path\n and it_class_type_declaration it ctd =\n List.iter (it.it_type_expr it) ctd.clty_params;\n it.it_class_type it ctd.clty_type;\n it.it_path ctd.clty_path\n and it_functor_param it = function\n | Unit -> ()\n | Named (_, mt) -> it.it_module_type it mt\n and it_module_type it = function\n Mty_ident p\n | Mty_alias p -> it.it_path p\n | Mty_signature sg -> it.it_signature it sg\n | Mty_functor (p, mt) ->\n it.it_functor_param it p;\n it.it_module_type it mt\n and it_class_type it = function\n Cty_constr (p, tyl, cty) ->\n it.it_path p;\n List.iter (it.it_type_expr it) tyl;\n it.it_class_type it cty\n | Cty_signature cs ->\n it.it_type_expr it cs.csig_self;\n it.it_type_expr it cs.csig_self_row;\n Vars.iter (fun _ (_,_,ty) -> it.it_type_expr it ty) cs.csig_vars;\n Meths.iter (fun _ (_,_,ty) -> it.it_type_expr it ty) cs.csig_meths\n | Cty_arrow (_, ty, cty) ->\n it.it_type_expr it ty;\n it.it_class_type it cty\n and it_type_kind it kind =\n iter_type_expr_kind (it.it_type_expr it) kind\n and it_do_type_expr it ty =\n iter_type_expr (it.it_type_expr it) ty;\n match get_desc ty with\n Tconstr (p, _, _)\n | Tobject (_, {contents=Some (p, _)})\n | Tpackage (p, _) ->\n it.it_path p\n | Tvariant row ->\n Option.iter (fun (p,_) -> it.it_path p) (row_name row)\n | _ -> ()\n and it_path _p = ()\n in\n { it_path; it_type_expr = it_do_type_expr; it_do_type_expr;\n it_type_kind; it_class_type; it_functor_param; it_module_type;\n it_signature; it_class_type_declaration; it_class_declaration;\n it_modtype_declaration; it_module_declaration; it_extension_constructor;\n it_type_declaration; it_value_description; it_signature_item; }\n\nlet copy_row f fixed row keep more =\n let Row {fields = orig_fields; fixed = orig_fixed; closed; name = orig_name} =\n row_repr row in\n let fields = List.map\n (fun (l, fi) -> l,\n match row_field_repr fi with\n | Rpresent oty -> rf_present (Option.map f oty)\n | Reither(c, tl, m) ->\n let use_ext_of = if keep then Some fi else None in\n let m = if is_fixed row then fixed else m in\n let tl = List.map f tl in\n rf_either tl ?use_ext_of ~no_arg:c ~matched:m\n | Rabsent -> rf_absent)\n orig_fields in\n let name =\n match orig_name with\n | None -> None\n | Some (path, tl) -> Some (path, List.map f tl) in\n let fixed = if fixed then orig_fixed else None in\n create_row ~fields ~more ~fixed ~closed ~name\n\nlet copy_commu c = if is_commu_ok c then commu_ok else commu_var ()\n\nlet rec copy_type_desc ?(keep_names=false) f = function\n Tvar _ as ty -> if keep_names then ty else Tvar None\n | Tarrow (p, ty1, ty2, c)-> Tarrow (p, f ty1, f ty2, copy_commu c)\n | Ttuple l -> Ttuple (List.map f l)\n | Tconstr (p, l, _) -> Tconstr (p, List.map f l, ref Mnil)\n | Tobject(ty, {contents = Some (p, tl)})\n -> Tobject (f ty, ref (Some(p, List.map f tl)))\n | Tobject (ty, _) -> Tobject (f ty, ref None)\n | Tvariant _ -> assert false (* too ambiguous *)\n | Tfield (p, k, ty1, ty2) ->\n Tfield (p, field_kind_internal_repr k, f ty1, f ty2)\n (* the kind is kept shared, with indirections removed for performance *)\n | Tnil -> Tnil\n | Tlink ty -> copy_type_desc f (get_desc ty)\n | Tsubst _ -> assert false\n | Tunivar _ as ty -> ty (* always keep the name *)\n | Tpoly (ty, tyl) ->\n let tyl = List.map f tyl in\n Tpoly (f ty, tyl)\n | Tpackage (p, fl) -> Tpackage (p, List.map (fun (n, ty) -> (n, f ty)) fl)\n\n(* Utilities for copying *)\n\nmodule For_copy : sig\n type copy_scope\n\n val redirect_desc: copy_scope -> type_expr -> type_desc -> unit\n\n val with_scope: (copy_scope -> 'a) -> 'a\nend = struct\n type copy_scope = {\n mutable saved_desc : (transient_expr * type_desc) list;\n (* Save association of generic nodes with their description. *)\n }\n\n let redirect_desc copy_scope ty desc =\n let ty = Transient_expr.repr ty in\n copy_scope.saved_desc <- (ty, ty.desc) :: copy_scope.saved_desc;\n Transient_expr.set_desc ty desc\n\n (* Restore type descriptions. *)\n let cleanup { saved_desc; _ } =\n List.iter (fun (ty, desc) -> Transient_expr.set_desc ty desc) saved_desc\n\n let with_scope f =\n let scope = { saved_desc = [] } in\n let res = f scope in\n cleanup scope;\n res\nend\n\n (*******************************************)\n (* Memorization of abbreviation expansion *)\n (*******************************************)\n\n(* Search whether the expansion has been memorized. *)\n\nlet lte_public p1 p2 = (* Private <= Public *)\n match p1, p2 with\n | Private, _ | _, Public -> true\n | Public, Private -> false\n\nlet rec find_expans priv p1 = function\n Mnil -> None\n | Mcons (priv', p2, _ty0, ty, _)\n when lte_public priv priv' && Path.same p1 p2 -> Some ty\n | Mcons (_, _, _, _, rem) -> find_expans priv p1 rem\n | Mlink {contents = rem} -> find_expans priv p1 rem\n\n(* debug: check for cycles in abbreviation. only works with -principal\nlet rec check_expans visited ty =\n let ty = repr ty in\n assert (not (List.memq ty visited));\n match ty.desc with\n Tconstr (path, args, abbrev) ->\n begin match find_expans path !abbrev with\n Some ty' -> check_expans (ty :: visited) ty'\n | None -> ()\n end\n | _ -> ()\n*)\n\nlet memo = s_ref []\n (* Contains the list of saved abbreviation expansions. *)\n\nlet cleanup_abbrev () =\n (* Remove all memorized abbreviation expansions. *)\n List.iter (fun abbr -> abbr := Mnil) !memo;\n memo := []\n\nlet memorize_abbrev mem priv path v v' =\n (* Memorize the expansion of an abbreviation. *)\n mem := Mcons (priv, path, v, v', !mem);\n (* check_expans [] v; *)\n memo := mem :: !memo\n\nlet rec forget_abbrev_rec mem path =\n match mem with\n Mnil ->\n mem\n | Mcons (_, path', _, _, rem) when Path.same path path' ->\n rem\n | Mcons (priv, path', v, v', rem) ->\n Mcons (priv, path', v, v', forget_abbrev_rec rem path)\n | Mlink mem' ->\n mem' := forget_abbrev_rec !mem' path;\n raise Exit\n\nlet forget_abbrev mem path =\n try mem := forget_abbrev_rec !mem path with Exit -> ()\n\n(* debug: check for invalid abbreviations\nlet rec check_abbrev_rec = function\n Mnil -> true\n | Mcons (_, ty1, ty2, rem) ->\n repr ty1 != repr ty2\n | Mlink mem' ->\n check_abbrev_rec !mem'\n\nlet check_memorized_abbrevs () =\n List.for_all (fun mem -> check_abbrev_rec !mem) !memo\n*)\n\n(* Re-export backtrack *)\n\nlet snapshot = snapshot\nlet backtrack = backtrack ~cleanup_abbrev\n\n (**********************************)\n (* Utilities for labels *)\n (**********************************)\n\nlet is_optional = function Optional _ -> true | _ -> false\n\nlet label_name = function\n Nolabel -> \"\"\n | Labelled s\n | Optional s -> s\n\nlet prefixed_label_name = function\n Nolabel -> \"\"\n | Labelled s -> \"~\" ^ s\n | Optional s -> \"?\" ^ s\n\nlet rec extract_label_aux hd l = function\n | [] -> None\n | (l',t as p) :: ls ->\n if label_name l' = l then\n Some (l', t, hd <> [], List.rev_append hd ls)\n else\n extract_label_aux (p::hd) l ls\n\nlet extract_label l ls = extract_label_aux [] l ls\n\n (*******************************)\n (* Operations on class types *)\n (*******************************)\n\nlet rec signature_of_class_type =\n function\n Cty_constr (_, _, cty) -> signature_of_class_type cty\n | Cty_signature sign -> sign\n | Cty_arrow (_, _, cty) -> signature_of_class_type cty\n\nlet rec class_body cty =\n match cty with\n Cty_constr _ ->\n cty (* Only class bodies can be abbreviated *)\n | Cty_signature _ ->\n cty\n | Cty_arrow (_, _, cty) ->\n class_body cty\n\n(* Fully expand the head of a class type *)\nlet rec scrape_class_type =\n function\n Cty_constr (_, _, cty) -> scrape_class_type cty\n | cty -> cty\n\nlet rec class_type_arity =\n function\n Cty_constr (_, _, cty) -> class_type_arity cty\n | Cty_signature _ -> 0\n | Cty_arrow (_, _, cty) -> 1 + class_type_arity cty\n\nlet rec abbreviate_class_type path params cty =\n match cty with\n Cty_constr (_, _, _) | Cty_signature _ ->\n Cty_constr (path, params, cty)\n | Cty_arrow (l, ty, cty) ->\n Cty_arrow (l, ty, abbreviate_class_type path params cty)\n\nlet self_type cty =\n (signature_of_class_type cty).csig_self\n\nlet self_type_row cty =\n (signature_of_class_type cty).csig_self_row\n\n(* Return the methods of a class signature *)\nlet methods sign =\n Meths.fold\n (fun name _ l -> name :: l)\n sign.csig_meths []\n\n(* Return the virtual methods of a class signature *)\nlet virtual_methods sign =\n Meths.fold\n (fun name (_priv, vr, _ty) l ->\n match vr with\n | Virtual -> name :: l\n | Concrete -> l)\n sign.csig_meths []\n\n(* Return the concrete methods of a class signature *)\nlet concrete_methods sign =\n Meths.fold\n (fun name (_priv, vr, _ty) s ->\n match vr with\n | Virtual -> s\n | Concrete -> MethSet.add name s)\n sign.csig_meths MethSet.empty\n\n(* Return the public methods of a class signature *)\nlet public_methods sign =\n Meths.fold\n (fun name (priv, _vr, _ty) l ->\n match priv with\n | Mprivate _ -> l\n | Mpublic -> name :: l)\n sign.csig_meths []\n\n(* Return the instance variables of a class signature *)\nlet instance_vars sign =\n Vars.fold\n (fun name _ l -> name :: l)\n sign.csig_vars []\n\n(* Return the virtual instance variables of a class signature *)\nlet virtual_instance_vars sign =\n Vars.fold\n (fun name (_mut, vr, _ty) l ->\n match vr with\n | Virtual -> name :: l\n | Concrete -> l)\n sign.csig_vars []\n\n(* Return the concrete instance variables of a class signature *)\nlet concrete_instance_vars sign =\n Vars.fold\n (fun name (_mut, vr, _ty) s ->\n match vr with\n | Virtual -> s\n | Concrete -> VarSet.add name s)\n sign.csig_vars VarSet.empty\n\nlet method_type label sign =\n match Meths.find label sign.csig_meths with\n | (_, _, ty) -> ty\n | exception Not_found -> assert false\n\nlet instance_variable_type label sign =\n match Vars.find label sign.csig_vars with\n | (_, _, ty) -> ty\n | exception Not_found -> assert false\n\n (**********************************)\n (* Utilities for level-marking *)\n (**********************************)\n\nlet not_marked_node ty = get_level ty >= lowest_level\n (* type nodes with negative levels are \"marked\" *)\n\nlet flip_mark_node ty =\n let ty = Transient_expr.repr ty in\n Transient_expr.set_level ty (pivot_level - ty.level)\nlet logged_mark_node ty =\n set_level ty (pivot_level - get_level ty)\n\nlet try_mark_node ty = not_marked_node ty && (flip_mark_node ty; true)\nlet try_logged_mark_node ty = not_marked_node ty && (logged_mark_node ty; true)\n\nlet rec mark_type ty =\n if not_marked_node ty then begin\n flip_mark_node ty;\n iter_type_expr mark_type ty\n end\n\nlet mark_type_params ty =\n iter_type_expr mark_type ty\n\nlet type_iterators =\n let it_type_expr it ty =\n if try_mark_node ty then it.it_do_type_expr it ty\n in\n {type_iterators with it_type_expr}\n\n\n(* Remove marks from a type. *)\nlet rec unmark_type ty =\n if get_level ty < lowest_level then begin\n (* flip back the marked level *)\n flip_mark_node ty;\n iter_type_expr unmark_type ty\n end\n\nlet unmark_iterators =\n let it_type_expr _it ty = unmark_type ty in\n {type_iterators with it_type_expr}\n\nlet unmark_type_decl decl =\n unmark_iterators.it_type_declaration unmark_iterators decl\n\nlet unmark_extension_constructor ext =\n List.iter unmark_type ext.ext_type_params;\n iter_type_expr_cstr_args unmark_type ext.ext_args;\n Option.iter unmark_type ext.ext_ret_type\n\nlet unmark_class_signature sign =\n unmark_type sign.csig_self;\n unmark_type sign.csig_self_row;\n Vars.iter (fun _l (_m, _v, t) -> unmark_type t) sign.csig_vars;\n Meths.iter (fun _l (_m, _v, t) -> unmark_type t) sign.csig_meths\n\nlet unmark_class_type cty =\n unmark_iterators.it_class_type unmark_iterators cty\n\n(**** Type information getter ****)\n\nlet cstr_type_path cstr =\n match get_desc cstr.cstr_res with\n | Tconstr (p, _, _) -> p\n | _ -> assert false\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(* Substitutions *)\n\nopen Misc\nopen Path\nopen Types\nopen Btype\n\nopen Local_store\n\ntype type_replacement =\n | Path of Path.t\n | Type_function of { params : type_expr list; body : type_expr }\n\ntype t =\n { types: type_replacement Path.Map.t;\n modules: Path.t Path.Map.t;\n modtypes: module_type Path.Map.t;\n for_saving: bool;\n loc: Location.t option;\n }\n\nlet identity =\n { types = Path.Map.empty;\n modules = Path.Map.empty;\n modtypes = Path.Map.empty;\n for_saving = false;\n loc = None;\n }\n\nlet add_type_path id p s = { s with types = Path.Map.add id (Path p) s.types }\nlet add_type id p s = add_type_path (Pident id) p s\n\nlet add_type_function id ~params ~body s =\n { s with types = Path.Map.add id (Type_function { params; body }) s.types }\n\nlet add_module_path id p s = { s with modules = Path.Map.add id p s.modules }\nlet add_module id p s = add_module_path (Pident id) p s\n\nlet add_modtype_path p ty s = { s with modtypes = Path.Map.add p ty s.modtypes }\nlet add_modtype id ty s = add_modtype_path (Pident id) ty s\n\nlet for_saving s = { s with for_saving = true }\n\nlet change_locs s loc = { s with loc = Some loc }\n\nlet loc s x =\n match s.loc with\n | Some l -> l\n | None ->\n if s.for_saving && not !Clflags.keep_locs then Location.none else x\n\nlet remove_loc =\n let open Ast_mapper in\n {default_mapper with location = (fun _this _loc -> Location.none)}\n\nlet is_not_doc = function\n | {Parsetree.attr_name = {Location.txt = \"ocaml.doc\"}; _} -> false\n | {Parsetree.attr_name = {Location.txt = \"ocaml.text\"}; _} -> false\n | {Parsetree.attr_name = {Location.txt = \"doc\"}; _} -> false\n | {Parsetree.attr_name = {Location.txt = \"text\"}; _} -> false\n | _ -> true\n\nlet attrs s x =\n let x =\n if s.for_saving && not !Clflags.keep_docs then\n List.filter is_not_doc x\n else x\n in\n if s.for_saving && not !Clflags.keep_locs\n then remove_loc.Ast_mapper.attributes remove_loc x\n else x\n\nlet rec module_path s path =\n try Path.Map.find path s.modules\n with Not_found ->\n match path with\n | Pident _ -> path\n | Pdot(p, n) ->\n Pdot(module_path s p, n)\n | Papply(p1, p2) ->\n Papply(module_path s p1, module_path s p2)\n\nlet modtype_path s path =\n match Path.Map.find path s.modtypes with\n | Mty_ident p -> p\n | Mty_alias _ | Mty_signature _ | Mty_functor _ ->\n fatal_error \"Subst.modtype_path\"\n | exception Not_found ->\n match path with\n | Pdot(p, n) ->\n Pdot(module_path s p, n)\n | Papply _ ->\n fatal_error \"Subst.modtype_path\"\n | Pident _ -> path\n\nlet type_path s path =\n match Path.Map.find path s.types with\n | Path p -> p\n | Type_function _ -> assert false\n | exception Not_found ->\n match path with\n | Pident _ -> path\n | Pdot(p, n) ->\n Pdot(module_path s p, n)\n | Papply _ ->\n fatal_error \"Subst.type_path\"\n\nlet type_path s p =\n match Path.constructor_typath p with\n | Regular p -> type_path s p\n | Cstr (ty_path, cstr) -> Pdot(type_path s ty_path, cstr)\n | LocalExt _ -> type_path s p\n | Ext (p, cstr) -> Pdot(module_path s p, cstr)\n\nlet to_subst_by_type_function s p =\n match Path.Map.find p s.types with\n | Path _ -> false\n | Type_function _ -> true\n | exception Not_found -> false\n\n(* Special type ids for saved signatures *)\n\nlet new_id = s_ref (-1)\nlet reset_for_saving () = new_id := -1\n\nlet newpersty desc =\n decr new_id;\n create_expr\n desc ~level:generic_level ~scope:Btype.lowest_level ~id:!new_id\n\n(* ensure that all occurrences of 'Tvar None' are physically shared *)\nlet tvar_none = Tvar None\nlet tunivar_none = Tunivar None\nlet norm = function\n | Tvar None -> tvar_none\n | Tunivar None -> tunivar_none\n | d -> d\n\nlet ctype_apply_env_empty = ref (fun _ -> assert false)\n\n(* Similar to [Ctype.nondep_type_rec]. *)\nlet rec typexp copy_scope s ty =\n let desc = get_desc ty in\n match desc with\n Tvar _ | Tunivar _ ->\n if s.for_saving || get_id ty < 0 then\n let ty' =\n if s.for_saving then newpersty (norm desc)\n else newty2 ~level:(get_level ty) desc\n in\n For_copy.redirect_desc copy_scope ty (Tsubst (ty', None));\n ty'\n else ty\n | Tsubst (ty, _) ->\n ty\n | Tfield (m, k, _t1, _t2) when not s.for_saving && m = dummy_method\n && field_kind_repr k <> Fabsent && get_level ty < generic_level ->\n (* do not copy the type of self when it is not generalized *)\n ty\n(* cannot do it, since it would omit substitution\n | Tvariant row when not (static_row row) ->\n ty\n*)\n | _ ->\n let tm = row_of_type ty in\n let has_fixed_row =\n not (is_Tconstr ty) && is_constr_row ~allow_ident:false tm in\n (* Make a stub *)\n let ty' =\n if s.for_saving then newpersty (Tvar None)\n else newgenstub ~scope:(get_scope ty)\n in\n For_copy.redirect_desc copy_scope ty (Tsubst (ty', None));\n let desc =\n if has_fixed_row then\n match get_desc tm with (* PR#7348 *)\n Tconstr (Pdot(m,i), tl, _abbrev) ->\n let i' = String.sub i 0 (String.length i - 4) in\n Tconstr(type_path s (Pdot(m,i')), tl, ref Mnil)\n | _ -> assert false\n else match desc with\n | Tconstr (p, args, _abbrev) ->\n let args = List.map (typexp copy_scope s) args in\n begin match Path.Map.find p s.types with\n | exception Not_found -> Tconstr(type_path s p, args, ref Mnil)\n | Path _ -> Tconstr(type_path s p, args, ref Mnil)\n | Type_function { params; body } ->\n Tlink (!ctype_apply_env_empty params body args)\n end\n | Tpackage(p, fl) ->\n Tpackage(modtype_path s p,\n List.map (fun (n, ty) -> (n, typexp copy_scope s ty)) fl)\n | Tobject (t1, name) ->\n let t1' = typexp copy_scope s t1 in\n let name' =\n match !name with\n | None -> None\n | Some (p, tl) ->\n if to_subst_by_type_function s p\n then None\n else Some (type_path s p, List.map (typexp copy_scope s) tl)\n in\n Tobject (t1', ref name')\n | Tvariant row ->\n let more = row_more row in\n let mored = get_desc more in\n (* We must substitute in a subtle way *)\n (* Tsubst takes a tuple containing the row var and the variant *)\n begin match mored with\n Tsubst (_, Some ty2) ->\n (* This variant type has been already copied *)\n (* Change the stub to avoid Tlink in the new type *)\n For_copy.redirect_desc copy_scope ty (Tsubst (ty2, None));\n Tlink ty2\n | _ ->\n let dup =\n s.for_saving || get_level more = generic_level ||\n static_row row || is_Tconstr more in\n (* Various cases for the row variable *)\n let more' =\n match mored with\n Tsubst (ty, None) -> ty\n | Tconstr _ | Tnil -> typexp copy_scope s more\n | Tunivar _ | Tvar _ ->\n if s.for_saving then newpersty (norm mored)\n else if dup && is_Tvar more then newgenty mored\n else more\n | _ -> assert false\n in\n (* Register new type first for recursion *)\n For_copy.redirect_desc copy_scope more\n (Tsubst (more', Some ty'));\n (* TODO: check if more' can be eliminated *)\n (* Return a new copy *)\n let row =\n copy_row (typexp copy_scope s) true row (not dup) more' in\n match row_name row with\n | Some (p, tl) ->\n let name =\n if to_subst_by_type_function s p then None\n else Some (type_path s p, tl)\n in\n Tvariant (set_row_name row name)\n | None ->\n Tvariant row\n end\n | Tfield(_label, kind, _t1, t2) when field_kind_repr kind = Fabsent ->\n Tlink (typexp copy_scope s t2)\n | _ -> copy_type_desc (typexp copy_scope s) desc\n in\n Transient_expr.set_stub_desc ty' desc;\n ty'\n\n(*\n Always make a copy of the type. If this is not done, type levels\n might not be correct.\n*)\nlet type_expr s ty =\n For_copy.with_scope (fun copy_scope -> typexp copy_scope s ty)\n\nlet label_declaration copy_scope s l =\n {\n ld_id = l.ld_id;\n ld_mutable = l.ld_mutable;\n ld_type = typexp copy_scope s l.ld_type;\n ld_loc = loc s l.ld_loc;\n ld_attributes = attrs s l.ld_attributes;\n ld_uid = l.ld_uid;\n }\n\nlet constructor_arguments copy_scope s = function\n | Cstr_tuple l ->\n Cstr_tuple (List.map (typexp copy_scope s) l)\n | Cstr_record l ->\n Cstr_record (List.map (label_declaration copy_scope s) l)\n\nlet constructor_declaration copy_scope s c =\n {\n cd_id = c.cd_id;\n cd_args = constructor_arguments copy_scope s c.cd_args;\n cd_res = Option.map (typexp copy_scope s) c.cd_res;\n cd_loc = loc s c.cd_loc;\n cd_attributes = attrs s c.cd_attributes;\n cd_uid = c.cd_uid;\n }\n\nlet type_declaration' copy_scope s decl =\n { type_params = List.map (typexp copy_scope s) decl.type_params;\n type_arity = decl.type_arity;\n type_kind =\n begin match decl.type_kind with\n Type_abstract -> Type_abstract\n | Type_variant (cstrs, rep) ->\n Type_variant (List.map (constructor_declaration copy_scope s) cstrs,\n rep)\n | Type_record(lbls, rep) ->\n Type_record (List.map (label_declaration copy_scope s) lbls, rep)\n | Type_open -> Type_open\n end;\n type_manifest =\n begin\n match decl.type_manifest with\n None -> None\n | Some ty -> Some(typexp copy_scope s ty)\n end;\n type_private = decl.type_private;\n type_variance = decl.type_variance;\n type_separability = decl.type_separability;\n type_is_newtype = false;\n type_expansion_scope = Btype.lowest_level;\n type_loc = loc s decl.type_loc;\n type_attributes = attrs s decl.type_attributes;\n type_immediate = decl.type_immediate;\n type_unboxed_default = decl.type_unboxed_default;\n type_uid = decl.type_uid;\n }\n\nlet type_declaration s decl =\n For_copy.with_scope (fun copy_scope -> type_declaration' copy_scope s decl)\n\nlet class_signature copy_scope s sign =\n { csig_self = typexp copy_scope s sign.csig_self;\n csig_self_row = typexp copy_scope s sign.csig_self_row;\n csig_vars =\n Vars.map\n (function (m, v, t) -> (m, v, typexp copy_scope s t))\n sign.csig_vars;\n csig_meths =\n Meths.map\n (function (p, v, t) -> (p, v, typexp copy_scope s t))\n sign.csig_meths;\n }\n\nlet rec class_type copy_scope s = function\n | Cty_constr (p, tyl, cty) ->\n let p' = type_path s p in\n let tyl' = List.map (typexp copy_scope s) tyl in\n let cty' = class_type copy_scope s cty in\n Cty_constr (p', tyl', cty')\n | Cty_signature sign ->\n Cty_signature (class_signature copy_scope s sign)\n | Cty_arrow (l, ty, cty) ->\n Cty_arrow (l, typexp copy_scope s ty, class_type copy_scope s cty)\n\nlet class_declaration' copy_scope s decl =\n { cty_params = List.map (typexp copy_scope s) decl.cty_params;\n cty_variance = decl.cty_variance;\n cty_type = class_type copy_scope s decl.cty_type;\n cty_path = type_path s decl.cty_path;\n cty_new =\n begin match decl.cty_new with\n | None -> None\n | Some ty -> Some (typexp copy_scope s ty)\n end;\n cty_loc = loc s decl.cty_loc;\n cty_attributes = attrs s decl.cty_attributes;\n cty_uid = decl.cty_uid;\n }\n\nlet class_declaration s decl =\n For_copy.with_scope (fun copy_scope -> class_declaration' copy_scope s decl)\n\nlet cltype_declaration' copy_scope s decl =\n { clty_params = List.map (typexp copy_scope s) decl.clty_params;\n clty_variance = decl.clty_variance;\n clty_type = class_type copy_scope s decl.clty_type;\n clty_path = type_path s decl.clty_path;\n clty_loc = loc s decl.clty_loc;\n clty_attributes = attrs s decl.clty_attributes;\n clty_uid = decl.clty_uid;\n }\n\nlet cltype_declaration s decl =\n For_copy.with_scope (fun copy_scope -> cltype_declaration' copy_scope s decl)\n\nlet class_type s cty =\n For_copy.with_scope (fun copy_scope -> class_type copy_scope s cty)\n\nlet value_description' copy_scope s descr =\n { val_type = typexp copy_scope s descr.val_type;\n val_kind = descr.val_kind;\n val_loc = loc s descr.val_loc;\n val_attributes = attrs s descr.val_attributes;\n val_uid = descr.val_uid;\n }\n\nlet value_description s descr =\n For_copy.with_scope (fun copy_scope -> value_description' copy_scope s descr)\n\nlet extension_constructor' copy_scope s ext =\n { ext_type_path = type_path s ext.ext_type_path;\n ext_type_params = List.map (typexp copy_scope s) ext.ext_type_params;\n ext_args = constructor_arguments copy_scope s ext.ext_args;\n ext_ret_type = Option.map (typexp copy_scope s) ext.ext_ret_type;\n ext_private = ext.ext_private;\n ext_attributes = attrs s ext.ext_attributes;\n ext_loc = if s.for_saving then Location.none else ext.ext_loc;\n ext_uid = ext.ext_uid;\n }\n\nlet extension_constructor s ext =\n For_copy.with_scope\n (fun copy_scope -> extension_constructor' copy_scope s ext)\n\n\n(* For every binding k |-> d of m1, add k |-> f d to m2\n and return resulting merged map. *)\n\nlet merge_path_maps f m1 m2 =\n Path.Map.fold (fun k d accu -> Path.Map.add k (f d) accu) m1 m2\n\nlet keep_latest_loc l1 l2 =\n match l2 with\n | None -> l1\n | Some _ -> l2\n\nlet type_replacement s = function\n | Path p -> Path (type_path s p)\n | Type_function { params; body } ->\n For_copy.with_scope (fun copy_scope ->\n let params = List.map (typexp copy_scope s) params in\n let body = typexp copy_scope s body in\n Type_function { params; body })\n\ntype scoping =\n | Keep\n | Make_local\n | Rescope of int\n\nmodule Lazy_types = struct\n\n type module_decl =\n {\n mdl_type: modtype;\n mdl_attributes: Parsetree.attributes;\n mdl_loc: Location.t;\n mdl_uid: Uid.t;\n }\n\n and modtype =\n | MtyL_ident of Path.t\n | MtyL_signature of signature\n | MtyL_functor of functor_parameter * modtype\n | MtyL_alias of Path.t\n\n and modtype_declaration =\n {\n mtdl_type: modtype option;\n mtdl_attributes: Parsetree.attributes;\n mtdl_loc: Location.t;\n mtdl_uid: Uid.t;\n }\n\n and signature' =\n | S_eager of Types.signature\n | S_lazy of signature_item list\n\n and signature =\n (scoping * t * signature', signature') Lazy_backtrack.t\n\n and signature_item =\n SigL_value of Ident.t * value_description * visibility\n | SigL_type of Ident.t * type_declaration * rec_status * visibility\n | SigL_typext of Ident.t * extension_constructor * ext_status * visibility\n | SigL_module of\n Ident.t * module_presence * module_decl * rec_status * visibility\n | SigL_modtype of Ident.t * modtype_declaration * visibility\n | SigL_class of Ident.t * class_declaration * rec_status * visibility\n | SigL_class_type of Ident.t * class_type_declaration *\n rec_status * visibility\n\n and functor_parameter =\n | Unit\n | Named of Ident.t option * modtype\n\nend\nopen Lazy_types\n\nlet rename_bound_idents scoping s sg =\n let rename =\n let open Ident in\n match scoping with\n | Keep -> (fun id -> create_scoped ~scope:(scope id) (name id))\n | Make_local -> Ident.rename\n | Rescope scope -> (fun id -> create_scoped ~scope (name id))\n in\n let rec rename_bound_idents s sg = function\n | [] -> sg, s\n | SigL_type(id, td, rs, vis) :: rest ->\n let id' = rename id in\n rename_bound_idents\n (add_type id (Pident id') s)\n (SigL_type(id', td, rs, vis) :: sg)\n rest\n | SigL_module(id, pres, md, rs, vis) :: rest ->\n let id' = rename id in\n rename_bound_idents\n (add_module id (Pident id') s)\n (SigL_module (id', pres, md, rs, vis) :: sg)\n rest\n | SigL_modtype(id, mtd, vis) :: rest ->\n let id' = rename id in\n rename_bound_idents\n (add_modtype id (Mty_ident(Pident id')) s)\n (SigL_modtype(id', mtd, vis) :: sg)\n rest\n | SigL_class(id, cd, rs, vis) :: rest ->\n (* cheat and pretend they are types cf. PR#6650 *)\n let id' = rename id in\n rename_bound_idents\n (add_type id (Pident id') s)\n (SigL_class(id', cd, rs, vis) :: sg)\n rest\n | SigL_class_type(id, ctd, rs, vis) :: rest ->\n (* cheat and pretend they are types cf. PR#6650 *)\n let id' = rename id in\n rename_bound_idents\n (add_type id (Pident id') s)\n (SigL_class_type(id', ctd, rs, vis) :: sg)\n rest\n | SigL_value(id, vd, vis) :: rest ->\n (* scope doesn't matter for value identifiers. *)\n let id' = Ident.rename id in\n rename_bound_idents s (SigL_value(id', vd, vis) :: sg) rest\n | SigL_typext(id, ec, es, vis) :: rest ->\n let id' = rename id in\n rename_bound_idents s (SigL_typext(id',ec,es,vis) :: sg) rest\n in\n rename_bound_idents s [] sg\n\nlet rec lazy_module_decl md =\n { mdl_type = lazy_modtype md.md_type;\n mdl_attributes = md.md_attributes;\n mdl_loc = md.md_loc;\n mdl_uid = md.md_uid }\n\nand subst_lazy_module_decl scoping s md =\n let mdl_type = subst_lazy_modtype scoping s md.mdl_type in\n { mdl_type;\n mdl_attributes = attrs s md.mdl_attributes;\n mdl_loc = loc s md.mdl_loc;\n mdl_uid = md.mdl_uid }\n\nand force_module_decl md =\n let md_type = force_modtype md.mdl_type in\n { md_type;\n md_attributes = md.mdl_attributes;\n md_loc = md.mdl_loc;\n md_uid = md.mdl_uid }\n\nand lazy_modtype = function\n | Mty_ident p -> MtyL_ident p\n | Mty_signature sg ->\n MtyL_signature (Lazy_backtrack.create_forced (S_eager sg))\n | Mty_functor (Unit, mty) -> MtyL_functor (Unit, lazy_modtype mty)\n | Mty_functor (Named (id, arg), res) ->\n MtyL_functor (Named (id, lazy_modtype arg), lazy_modtype res)\n | Mty_alias p -> MtyL_alias p\n\nand subst_lazy_modtype scoping s = function\n | MtyL_ident p ->\n begin match Path.Map.find p s.modtypes with\n | mty -> lazy_modtype mty\n | exception Not_found ->\n begin match p with\n | Pident _ -> MtyL_ident p\n | Pdot(p, n) ->\n MtyL_ident(Pdot(module_path s p, n))\n | Papply _ ->\n fatal_error \"Subst.modtype\"\n end\n end\n | MtyL_signature sg ->\n MtyL_signature(subst_lazy_signature scoping s sg)\n | MtyL_functor(Unit, res) ->\n MtyL_functor(Unit, subst_lazy_modtype scoping s res)\n | MtyL_functor(Named (None, arg), res) ->\n MtyL_functor(Named (None, (subst_lazy_modtype scoping s) arg),\n subst_lazy_modtype scoping s res)\n | MtyL_functor(Named (Some id, arg), res) ->\n let id' = Ident.rename id in\n MtyL_functor(Named (Some id', (subst_lazy_modtype scoping s) arg),\n subst_lazy_modtype scoping (add_module id (Pident id') s) res)\n | MtyL_alias p ->\n MtyL_alias (module_path s p)\n\nand force_modtype = function\n | MtyL_ident p -> Mty_ident p\n | MtyL_signature sg -> Mty_signature (force_signature sg)\n | MtyL_functor (param, res) ->\n let param : Types.functor_parameter =\n match param with\n | Unit -> Unit\n | Named (id, mty) -> Named (id, force_modtype mty) in\n Mty_functor (param, force_modtype res)\n | MtyL_alias p -> Mty_alias p\n\nand lazy_modtype_decl mtd =\n let mtdl_type = Option.map lazy_modtype mtd.mtd_type in\n { mtdl_type;\n mtdl_attributes = mtd.mtd_attributes;\n mtdl_loc = mtd.mtd_loc;\n mtdl_uid = mtd.mtd_uid }\n\nand subst_lazy_modtype_decl scoping s mtd =\n { mtdl_type = Option.map (subst_lazy_modtype scoping s) mtd.mtdl_type;\n mtdl_attributes = attrs s mtd.mtdl_attributes;\n mtdl_loc = loc s mtd.mtdl_loc;\n mtdl_uid = mtd.mtdl_uid }\n\nand force_modtype_decl mtd =\n let mtd_type = Option.map force_modtype mtd.mtdl_type in\n { mtd_type;\n mtd_attributes = mtd.mtdl_attributes;\n mtd_loc = mtd.mtdl_loc;\n mtd_uid = mtd.mtdl_uid }\n\nand subst_lazy_signature scoping s sg =\n match Lazy_backtrack.get_contents sg with\n | Left (scoping', s', sg) ->\n let scoping =\n match scoping', scoping with\n | sc, Keep -> sc\n | _, (Make_local|Rescope _) -> scoping\n in\n let s = compose s' s in\n Lazy_backtrack.create (scoping, s, sg)\n | Right sg ->\n Lazy_backtrack.create (scoping, s, sg)\n\nand force_signature sg =\n List.map force_signature_item (force_signature_once sg)\n\nand force_signature_once sg =\n lazy_signature' (Lazy_backtrack.force force_signature_once' sg)\n\nand lazy_signature' = function\n | S_lazy sg -> sg\n | S_eager sg -> List.map lazy_signature_item sg\n\nand force_signature_once' (scoping, s, sg) =\n let sg = lazy_signature' sg in\n (* Components of signature may be mutually recursive (e.g. type declarations\n or class and type declarations), so first build global renaming\n substitution... *)\n let (sg', s') = rename_bound_idents scoping s sg in\n (* ... then apply it to each signature component in turn *)\n For_copy.with_scope (fun copy_scope ->\n S_lazy (List.rev_map (subst_lazy_signature_item' copy_scope scoping s') sg')\n )\n\nand lazy_signature_item = function\n | Sig_value(id, d, vis) ->\n SigL_value(id, d, vis)\n | Sig_type(id, d, rs, vis) ->\n SigL_type(id, d, rs, vis)\n | Sig_typext(id, ext, es, vis) ->\n SigL_typext(id, ext, es, vis)\n | Sig_module(id, res, d, rs, vis) ->\n SigL_module(id, res, lazy_module_decl d, rs, vis)\n | Sig_modtype(id, d, vis) ->\n SigL_modtype(id, lazy_modtype_decl d, vis)\n | Sig_class(id, d, rs, vis) ->\n SigL_class(id, d, rs, vis)\n | Sig_class_type(id, d, rs, vis) ->\n SigL_class_type(id, d, rs, vis)\n\nand subst_lazy_signature_item' copy_scope scoping s comp =\n match comp with\n SigL_value(id, d, vis) ->\n SigL_value(id, value_description' copy_scope s d, vis)\n | SigL_type(id, d, rs, vis) ->\n SigL_type(id, type_declaration' copy_scope s d, rs, vis)\n | SigL_typext(id, ext, es, vis) ->\n SigL_typext(id, extension_constructor' copy_scope s ext, es, vis)\n | SigL_module(id, pres, d, rs, vis) ->\n SigL_module(id, pres, subst_lazy_module_decl scoping s d, rs, vis)\n | SigL_modtype(id, d, vis) ->\n SigL_modtype(id, subst_lazy_modtype_decl scoping s d, vis)\n | SigL_class(id, d, rs, vis) ->\n SigL_class(id, class_declaration' copy_scope s d, rs, vis)\n | SigL_class_type(id, d, rs, vis) ->\n SigL_class_type(id, cltype_declaration' copy_scope s d, rs, vis)\n\nand force_signature_item = function\n | SigL_value(id, vd, vis) -> Sig_value(id, vd, vis)\n | SigL_type(id, d, rs, vis) -> Sig_type(id, d, rs, vis)\n | SigL_typext(id, ext, es, vis) -> Sig_typext(id, ext, es, vis)\n | SigL_module(id, pres, d, rs, vis) ->\n Sig_module(id, pres, force_module_decl d, rs, vis)\n | SigL_modtype(id, d, vis) ->\n Sig_modtype (id, force_modtype_decl d, vis)\n | SigL_class(id, d, rs, vis) -> Sig_class(id, d, rs, vis)\n | SigL_class_type(id, d, rs, vis) -> Sig_class_type(id, d, rs, vis)\n\nand modtype scoping s t =\n t |> lazy_modtype |> subst_lazy_modtype scoping s |> force_modtype\n\n(* Composition of substitutions:\n apply (compose s1 s2) x = apply s2 (apply s1 x) *)\n\nand compose s1 s2 =\n if s1 == identity then s2 else\n if s2 == identity then s1 else\n { types = merge_path_maps (type_replacement s2) s1.types s2.types;\n modules = merge_path_maps (module_path s2) s1.modules s2.modules;\n modtypes = merge_path_maps (modtype Keep s2) s1.modtypes s2.modtypes;\n for_saving = s1.for_saving || s2.for_saving;\n loc = keep_latest_loc s1.loc s2.loc;\n }\n\n\nlet subst_lazy_signature_item scoping s comp =\n For_copy.with_scope\n (fun copy_scope -> subst_lazy_signature_item' copy_scope scoping s comp)\n\nmodule Lazy = struct\n include Lazy_types\n\n let of_module_decl = lazy_module_decl\n let of_modtype = lazy_modtype\n let of_modtype_decl = lazy_modtype_decl\n let of_signature sg = Lazy_backtrack.create_forced (S_eager sg)\n let of_signature_items sg = Lazy_backtrack.create_forced (S_lazy sg)\n let of_signature_item = lazy_signature_item\n\n let module_decl = subst_lazy_module_decl\n let modtype = subst_lazy_modtype\n let modtype_decl = subst_lazy_modtype_decl\n let signature = subst_lazy_signature\n let signature_item = subst_lazy_signature_item\n\n let force_module_decl = force_module_decl\n let force_modtype = force_modtype\n let force_modtype_decl = force_modtype_decl\n let force_signature = force_signature\n let force_signature_once = force_signature_once\n let force_signature_item = force_signature_item\nend\n\nlet signature sc s sg =\n Lazy.(sg |> of_signature |> signature sc s |> force_signature)\n\nlet signature_item sc s comp =\n Lazy.(comp|> of_signature_item |> signature_item sc s |> force_signature_item)\n\nlet modtype_declaration sc s decl =\n Lazy.(decl |> of_modtype_decl |> modtype_decl sc s |> force_modtype_decl)\n\nlet module_declaration scoping s decl =\n Lazy.(decl |> of_module_decl |> module_decl scoping s |> force_module_decl)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy and Jerome Vouillon, 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 core types *)\n\nopen Misc\nopen Asttypes\nopen Types\nopen Btype\nopen Errortrace\n\nopen Local_store\n\n(*\n Type manipulation after type inference\n ======================================\n If one wants to manipulate a type after type inference (for\n instance, during code generation or in the debugger), one must\n first make sure that the type levels are correct, using the\n function [correct_levels]. Then, this type can be correctly\n manipulated by [apply], [expand_head] and [moregeneral].\n*)\n\n(*\n General notes\n =============\n - As much sharing as possible should be kept : it makes types\n smaller and better abbreviated.\n When necessary, some sharing can be lost. Types will still be\n printed correctly (+++ TO DO...), and abbreviations defined by a\n class do not depend on sharing thanks to constrained\n abbreviations. (Of course, even if some sharing is lost, typing\n will still be correct.)\n - All nodes of a type have a level : that way, one knows whether a\n node need to be duplicated or not when instantiating a type.\n - Levels of a type are decreasing (generic level being considered\n as greatest).\n - The level of a type constructor is superior to the binding\n time of its path.\n - Recursive types without limitation should be handled (even if\n there is still an occur check). This avoid treating specially the\n case for objects, for instance. Furthermore, the occur check\n policy can then be easily changed.\n*)\n\n(**** Errors ****)\n\n(* There are two classes of errortrace-related exceptions: *traces* and\n *errors*. The former, whose names end with [_trace], contain\n [Errortrace.trace]s, representing traces that are currently being built; they\n are local to this file. All the internal functions that implement\n unification, type equality, and moregen raise trace exceptions. Once we are\n done, in the top level functions such as [unify], [equal], and [moregen], we\n catch the trace exceptions and transform them into the analogous error\n exception. This indicates that we are done building the trace, and expect\n the error to flow out of unification, type equality, or moregen into\n surrounding code (with some few exceptions when these top-level functions are\n used as building blocks elsewhere.) Only the error exceptions are exposed in\n [ctype.mli]; the trace exceptions are an implementation detail. Any trace\n exception that escapes from a function in this file is a bug. *)\n\nexception Unify_trace of unification trace\nexception Equality_trace of comparison trace\nexception Moregen_trace of comparison trace\n\nexception Unify of unification_error\nexception Equality of equality_error\nexception Moregen of moregen_error\nexception Subtype of Subtype.error\n\nexception Escape of type_expr escape\n\n(* For local use: throw the appropriate exception. Can be passed into local\n functions as a parameter *)\ntype _ trace_exn =\n| Unify : unification trace_exn\n| Moregen : comparison trace_exn\n| Equality : comparison trace_exn\n\nlet raise_trace_for\n (type variant)\n (tr_exn : variant trace_exn)\n (tr : variant trace) : 'a =\n match tr_exn with\n | Unify -> raise (Unify_trace tr)\n | Equality -> raise (Equality_trace tr)\n | Moregen -> raise (Moregen_trace tr)\n\n(* Uses of this function are a bit suspicious, as we usually want to maintain\n trace information; sometimes it makes sense, however, since we're maintaining\n the trace at an outer exception handler. *)\nlet raise_unexplained_for tr_exn =\n raise_trace_for tr_exn []\n\nlet raise_for tr_exn e =\n raise_trace_for tr_exn [e]\n\n(* Thrown from [moregen_kind] *)\nexception Public_method_to_private_method\n\nlet escape kind = {kind; context = None}\nlet escape_exn kind = Escape (escape kind)\nlet scope_escape_exn ty = escape_exn (Equation ty)\nlet raise_escape_exn kind = raise (escape_exn kind)\nlet raise_scope_escape_exn ty = raise (scope_escape_exn ty)\n\nexception Tags of label * label\n\nlet () =\n Location.register_error_of_exn\n (function\n | Tags (l, l') ->\n Some\n Location.\n (errorf ~loc:(in_file !input_name)\n \"In this program,@ variant constructors@ `%s and `%s@ \\\n have the same hash value.@ Change one of them.\" l l'\n )\n | _ -> None\n )\n\nexception Cannot_expand\n\nexception Cannot_apply\n\nexception Cannot_subst\n\nexception Cannot_unify_universal_variables\n\nexception Matches_failure of Env.t * unification_error\n\nexception Incompatible\n\n(**** Type level management ****)\n\nlet current_level = s_ref 0\nlet nongen_level = s_ref 0\nlet global_level = s_ref 1\nlet saved_level = s_ref []\n\ntype levels =\n { current_level: int; nongen_level: int; global_level: int;\n saved_level: (int * int) list; }\nlet save_levels () =\n { current_level = !current_level;\n nongen_level = !nongen_level;\n global_level = !global_level;\n saved_level = !saved_level }\nlet set_levels l =\n current_level := l.current_level;\n nongen_level := l.nongen_level;\n global_level := l.global_level;\n saved_level := l.saved_level\n\nlet get_current_level () = !current_level\nlet init_def level = current_level := level; nongen_level := level\nlet begin_def () =\n saved_level := (!current_level, !nongen_level) :: !saved_level;\n incr current_level; nongen_level := !current_level\nlet begin_class_def () =\n saved_level := (!current_level, !nongen_level) :: !saved_level;\n incr current_level\nlet raise_nongen_level () =\n saved_level := (!current_level, !nongen_level) :: !saved_level;\n nongen_level := !current_level\nlet end_def () =\n let (cl, nl) = List.hd !saved_level in\n saved_level := List.tl !saved_level;\n current_level := cl; nongen_level := nl\nlet create_scope () =\n init_def (!current_level + 1);\n !current_level\n\nlet reset_global_level () =\n global_level := !current_level + 1\nlet increase_global_level () =\n let gl = !global_level in\n global_level := !current_level;\n gl\nlet restore_global_level gl =\n global_level := gl\n\n(**** Whether a path points to an object type (with hidden row variable) ****)\nlet is_object_type path =\n let name =\n match path with Path.Pident id -> Ident.name id\n | Path.Pdot(_, s) -> s\n | Path.Papply _ -> assert false\n in name.[0] = '#'\n\n(**** Control tracing of GADT instances *)\n\nlet trace_gadt_instances = ref false\nlet check_trace_gadt_instances env =\n not !trace_gadt_instances && Env.has_local_constraints env &&\n (trace_gadt_instances := true; cleanup_abbrev (); true)\n\nlet reset_trace_gadt_instances b =\n if b then trace_gadt_instances := false\n\nlet wrap_trace_gadt_instances env f x =\n let b = check_trace_gadt_instances env in\n let y = f x in\n reset_trace_gadt_instances b;\n y\n\n(**** Abbreviations without parameters ****)\n(* Shall reset after generalizing *)\n\nlet simple_abbrevs = ref Mnil\n\nlet proper_abbrevs path tl abbrev =\n if tl <> [] || !trace_gadt_instances || !Clflags.principal ||\n is_object_type path\n then abbrev\n else simple_abbrevs\n\n(**** Some type creators ****)\n\n(* Re-export generic type creators *)\n\nlet newty desc = newty2 ~level:!current_level desc\nlet new_scoped_ty scope desc = newty3 ~level:!current_level ~scope desc\n\nlet newvar ?name () = newty2 ~level:!current_level (Tvar name)\nlet newvar2 ?name level = newty2 ~level:level (Tvar name)\nlet new_global_var ?name () = newty2 ~level:!global_level (Tvar name)\nlet newstub ~scope = newty3 ~level:!current_level ~scope (Tvar None)\n\nlet newobj fields = newty (Tobject (fields, ref None))\n\nlet newconstr path tyl = newty (Tconstr (path, tyl, ref Mnil))\n\nlet none = newty (Ttuple []) (* Clearly ill-formed type *)\n\n(**** unification mode ****)\n\ntype unification_mode =\n | Expression (* unification in expression *)\n | Pattern (* unification in pattern which may add local constraints *)\n\ntype equations_generation =\n | Forbidden\n | Allowed of { equated_types : TypePairs.t }\n\nlet umode = ref Expression\nlet equations_generation = ref Forbidden\nlet assume_injective = ref false\nlet allow_recursive_equation = ref false\n\nlet can_generate_equations () =\n match !equations_generation with\n | Forbidden -> false\n | _ -> true\n\nlet set_mode_pattern ~generate ~injective ~allow_recursive f =\n Misc.protect_refs\n [ Misc.R (umode, Pattern);\n Misc.R (equations_generation, generate);\n Misc.R (assume_injective, injective);\n Misc.R (allow_recursive_equation, allow_recursive);\n ] f\n\n(*** Checks for type definitions ***)\n\nlet in_current_module = function\n | Path.Pident _ -> true\n | Path.Pdot _ | Path.Papply _ -> false\n\nlet in_pervasives p =\n in_current_module p &&\n try ignore (Env.find_type p Env.initial_safe_string); true\n with Not_found -> false\n\nlet is_datatype decl=\n match decl.type_kind with\n Type_record _ | Type_variant _ | Type_open -> true\n | Type_abstract -> false\n\n\n (**********************************************)\n (* Miscellaneous operations on object types *)\n (**********************************************)\n\n(* Note:\n We need to maintain some invariants:\n * cty_self must be a Tobject\n * ...\n*)\n\n(**** Object field manipulation. ****)\n\nlet object_fields ty =\n match get_desc ty with\n Tobject (fields, _) -> fields\n | _ -> assert false\n\nlet flatten_fields ty =\n let rec flatten l ty =\n match get_desc ty with\n Tfield(s, k, ty1, ty2) ->\n flatten ((s, k, ty1)::l) ty2\n | _ ->\n (l, ty)\n in\n let (l, r) = flatten [] ty in\n (List.sort (fun (n, _, _) (n', _, _) -> compare n n') l, r)\n\nlet build_fields level =\n List.fold_right\n (fun (s, k, ty1) ty2 -> newty2 ~level (Tfield(s, k, ty1, ty2)))\n\nlet associate_fields fields1 fields2 =\n let rec associate p s s' =\n function\n (l, []) ->\n (List.rev p, (List.rev s) @ l, List.rev s')\n | ([], l') ->\n (List.rev p, List.rev s, (List.rev s') @ l')\n | ((n, k, t)::r, (n', k', t')::r') when n = n' ->\n associate ((n, k, t, k', t')::p) s s' (r, r')\n | ((n, k, t)::r, ((n', _k', _t')::_ as l')) when n < n' ->\n associate p ((n, k, t)::s) s' (r, l')\n | (((_n, _k, _t)::_ as l), (n', k', t')::r') (* when n > n' *) ->\n associate p s ((n', k', t')::s') (l, r')\n in\n associate [] [] [] (fields1, fields2)\n\n(**** Check whether an object is open ****)\n\n(* +++ The abbreviation should eventually be expanded *)\nlet rec object_row ty =\n match get_desc ty with\n Tobject (t, _) -> object_row t\n | Tfield(_, _, _, t) -> object_row t\n | _ -> ty\n\nlet opened_object ty =\n match get_desc (object_row ty) with\n | Tvar _ | Tunivar _ | Tconstr _ -> true\n | _ -> false\n\nlet concrete_object ty =\n match get_desc (object_row ty) with\n | Tvar _ -> false\n | _ -> true\n\n(**** Row variable of an object type ****)\n\nlet rec fields_row_variable ty =\n match get_desc ty with\n | Tfield (_, _, _, ty) -> fields_row_variable ty\n | Tvar _ -> ty\n | _ -> assert false\n\n(**** Object name manipulation ****)\n(* +++ Bientot obsolete *)\n\nlet set_object_name id params ty =\n match get_desc ty with\n | Tobject (fi, nm) ->\n let rv = fields_row_variable fi in\n set_name nm (Some (Path.Pident id, rv::params))\n | Tconstr (_, _, _) -> ()\n | _ -> fatal_error \"Ctype.set_object_name\"\n\nlet remove_object_name ty =\n match get_desc ty with\n Tobject (_, nm) -> set_name nm None\n | Tconstr (_, _, _) -> ()\n | _ -> fatal_error \"Ctype.remove_object_name\"\n\n (*******************************************)\n (* Miscellaneous operations on row types *)\n (*******************************************)\n\nlet sort_row_fields = List.sort (fun (p,_) (q,_) -> compare p q)\n\nlet rec merge_rf r1 r2 pairs fi1 fi2 =\n match fi1, fi2 with\n (l1,f1 as p1)::fi1', (l2,f2 as p2)::fi2' ->\n if l1 = l2 then merge_rf r1 r2 ((l1,f1,f2)::pairs) fi1' fi2' else\n if l1 < l2 then merge_rf (p1::r1) r2 pairs fi1' fi2 else\n merge_rf r1 (p2::r2) pairs fi1 fi2'\n | [], _ -> (List.rev r1, List.rev_append r2 fi2, pairs)\n | _, [] -> (List.rev_append r1 fi1, List.rev r2, pairs)\n\nlet merge_row_fields fi1 fi2 =\n match fi1, fi2 with\n [], _ | _, [] -> (fi1, fi2, [])\n | [p1], _ when not (List.mem_assoc (fst p1) fi2) -> (fi1, fi2, [])\n | _, [p2] when not (List.mem_assoc (fst p2) fi1) -> (fi1, fi2, [])\n | _ -> merge_rf [] [] [] (sort_row_fields fi1) (sort_row_fields fi2)\n\nlet rec filter_row_fields erase = function\n [] -> []\n | (_l,f as p)::fi ->\n let fi = filter_row_fields erase fi in\n match row_field_repr f with\n Rabsent -> fi\n | Reither(_,_,false) when erase ->\n link_row_field_ext ~inside:f rf_absent; fi\n | _ -> p :: fi\n\n (**************************************)\n (* Check genericity of type schemes *)\n (**************************************)\n\n\nexception Non_closed of type_expr * bool\n\nlet free_variables = ref []\nlet really_closed = ref None\n\n(* [free_vars_rec] collects the variables of the input type\n expression into the [free_variables] reference. It is used for\n several different things in the type-checker, with the following\n bells and whistles:\n - If [really_closed] is Some typing environment, types in the environment\n are expanded to check whether the apparently-free variable would vanish\n during expansion.\n - We collect both type variables and row variables, paired with a boolean\n that is [true] if we have a row variable.\n - We do not count \"virtual\" free variables -- free variables stored in\n the abbreviation of an object type that has been expanded (we store\n the abbreviations for use when displaying the type).\n\n The functions [free_vars] and [free_variables] below receive\n a typing environment as an optional [?env] parameter and\n set [really_closed] accordingly.\n [free_vars] returns a [(variable * bool) list], while\n [free_variables] drops the type/row information\n and only returns a [variable list].\n *)\nlet rec free_vars_rec real ty =\n if try_mark_node ty then\n match get_desc ty, !really_closed with\n Tvar _, _ ->\n free_variables := (ty, real) :: !free_variables\n | Tconstr (path, tl, _), Some env ->\n begin try\n let (_, body, _) = Env.find_type_expansion path env in\n if get_level body <> generic_level then\n free_variables := (ty, real) :: !free_variables\n with Not_found -> ()\n end;\n List.iter (free_vars_rec true) tl\n(* Do not count \"virtual\" free variables\n | Tobject(ty, {contents = Some (_, p)}) ->\n free_vars_rec false ty; List.iter (free_vars_rec true) p\n*)\n | Tobject (ty, _), _ ->\n free_vars_rec false ty\n | Tfield (_, _, ty1, ty2), _ ->\n free_vars_rec true ty1; free_vars_rec false ty2\n | Tvariant row, _ ->\n iter_row (free_vars_rec true) row;\n if not (static_row row) then free_vars_rec false (row_more row)\n | _ ->\n iter_type_expr (free_vars_rec true) ty\n\nlet free_vars ?env ty =\n free_variables := [];\n really_closed := env;\n free_vars_rec true ty;\n let res = !free_variables in\n free_variables := [];\n really_closed := None;\n res\n\nlet free_variables ?env ty =\n let tl = List.map fst (free_vars ?env ty) in\n unmark_type ty;\n tl\n\nlet closed_type ty =\n match free_vars ty with\n [] -> ()\n | (v, real) :: _ -> raise (Non_closed (v, real))\n\nlet closed_parameterized_type params ty =\n List.iter mark_type params;\n let ok =\n try closed_type ty; true with Non_closed _ -> false in\n List.iter unmark_type params;\n unmark_type ty;\n ok\n\nlet closed_type_decl decl =\n try\n List.iter mark_type decl.type_params;\n begin match decl.type_kind with\n Type_abstract ->\n ()\n | Type_variant (v, _rep) ->\n List.iter\n (fun {cd_args; cd_res; _} ->\n match cd_res with\n | Some _ -> ()\n | None ->\n match cd_args with\n | Cstr_tuple l -> List.iter closed_type l\n | Cstr_record l -> List.iter (fun l -> closed_type l.ld_type) l\n )\n v\n | Type_record(r, _rep) ->\n List.iter (fun l -> closed_type l.ld_type) r\n | Type_open -> ()\n end;\n begin match decl.type_manifest with\n None -> ()\n | Some ty -> closed_type ty\n end;\n unmark_type_decl decl;\n None\n with Non_closed (ty, _) ->\n unmark_type_decl decl;\n Some ty\n\nlet closed_extension_constructor ext =\n try\n List.iter mark_type ext.ext_type_params;\n begin match ext.ext_ret_type with\n | Some _ -> ()\n | None -> iter_type_expr_cstr_args closed_type ext.ext_args\n end;\n unmark_extension_constructor ext;\n None\n with Non_closed (ty, _) ->\n unmark_extension_constructor ext;\n Some ty\n\nexception CCFailure of (type_expr * bool * string * type_expr)\n\nlet closed_class params sign =\n List.iter mark_type params;\n ignore (try_mark_node sign.csig_self_row);\n try\n Meths.iter\n (fun lab (priv, _, ty) ->\n if priv = Mpublic then begin\n try closed_type ty with Non_closed (ty0, real) ->\n raise (CCFailure (ty0, real, lab, ty))\n end)\n sign.csig_meths;\n List.iter unmark_type params;\n unmark_class_signature sign;\n None\n with CCFailure reason ->\n List.iter unmark_type params;\n unmark_class_signature sign;\n Some reason\n\n\n (**********************)\n (* Type duplication *)\n (**********************)\n\n\n(* Duplicate a type, preserving only type variables *)\nlet duplicate_type ty =\n Subst.type_expr Subst.identity ty\n\n(* Same, for class types *)\nlet duplicate_class_type ty =\n Subst.class_type Subst.identity ty\n\n\n (*****************************)\n (* Type level manipulation *)\n (*****************************)\n\n(*\n It would be a bit more efficient to remove abbreviation expansions\n rather than generalizing them: these expansions will usually not be\n used anymore. However, this is not possible in the general case, as\n [expand_abbrev] (via [subst]) requires these expansions to be\n preserved. Does it worth duplicating this code ?\n*)\nlet rec generalize ty =\n let level = get_level ty in\n if (level > !current_level) && (level <> generic_level) then begin\n set_level ty generic_level;\n (* recur into abbrev for the speed *)\n begin match get_desc ty with\n Tconstr (_, _, abbrev) ->\n iter_abbrev generalize !abbrev\n | _ -> ()\n end;\n iter_type_expr generalize ty\n end\n\nlet generalize ty =\n simple_abbrevs := Mnil;\n generalize ty\n\n(* Generalize the structure and lower the variables *)\n\nlet rec generalize_structure ty =\n let level = get_level ty in\n if level <> generic_level then begin\n if is_Tvar ty && level > !current_level then\n set_level ty !current_level\n else if\n level > !current_level &&\n match get_desc ty with\n Tconstr (p, _, abbrev) ->\n not (is_object_type p) && (abbrev := Mnil; true)\n | _ -> true\n then begin\n set_level ty generic_level;\n iter_type_expr generalize_structure ty\n end\n end\n\nlet generalize_structure ty =\n simple_abbrevs := Mnil;\n generalize_structure ty\n\n(* Generalize the spine of a function, if the level >= !current_level *)\n\nlet rec generalize_spine ty =\n let level = get_level ty in\n if level < !current_level || level = generic_level then () else\n match get_desc ty with\n Tarrow (_, ty1, ty2, _) ->\n set_level ty generic_level;\n generalize_spine ty1;\n generalize_spine ty2;\n | Tpoly (ty', _) ->\n set_level ty generic_level;\n generalize_spine ty'\n | Ttuple tyl ->\n set_level ty generic_level;\n List.iter generalize_spine tyl\n | Tpackage (_, fl) ->\n set_level ty generic_level;\n List.iter (fun (_n, ty) -> generalize_spine ty) fl\n | Tconstr (p, tyl, memo) when not (is_object_type p) ->\n set_level ty generic_level;\n memo := Mnil;\n List.iter generalize_spine tyl\n | _ -> ()\n\nlet forward_try_expand_safe = (* Forward declaration *)\n ref (fun _env _ty -> assert false)\n\n(*\n Lower the levels of a type (assume [level] is not\n [generic_level]).\n*)\n\nlet rec normalize_package_path env p =\n let t =\n try (Env.find_modtype p env).mtd_type\n with Not_found -> None\n in\n match t with\n | Some (Mty_ident p) -> normalize_package_path env p\n | Some (Mty_signature _ | Mty_functor _ | Mty_alias _) | None ->\n match p with\n Path.Pdot (p1, s) ->\n (* For module aliases *)\n let p1' = Env.normalize_module_path None env p1 in\n if Path.same p1 p1' then p else\n normalize_package_path env (Path.Pdot (p1', s))\n | _ -> p\n\nlet rec check_scope_escape env level ty =\n let orig_level = get_level ty in\n if try_logged_mark_node ty then begin\n if level < get_scope ty then\n raise_scope_escape_exn ty;\n begin match get_desc ty with\n | Tconstr (p, _, _) when level < Path.scope p ->\n begin match !forward_try_expand_safe env ty with\n | ty' ->\n check_scope_escape env level ty'\n | exception Cannot_expand ->\n raise_escape_exn (Constructor p)\n end\n | Tpackage (p, fl) when level < Path.scope p ->\n let p' = normalize_package_path env p in\n if Path.same p p' then raise_escape_exn (Module_type p);\n check_scope_escape env level\n (newty2 ~level:orig_level (Tpackage (p', fl)))\n | _ ->\n iter_type_expr (check_scope_escape env level) ty\n end;\n end\n\nlet check_scope_escape env level ty =\n let snap = snapshot () in\n try check_scope_escape env level ty; backtrack snap\n with Escape e ->\n backtrack snap;\n raise (Escape { e with context = Some ty })\n\nlet rec update_scope scope ty =\n if get_scope ty < scope then begin\n if get_level ty < scope then raise_scope_escape_exn ty;\n set_scope ty scope;\n (* Only recurse in principal mode as this is not necessary for soundness *)\n if !Clflags.principal then iter_type_expr (update_scope scope) ty\n end\n\nlet update_scope_for tr_exn scope ty =\n try\n update_scope scope ty\n with Escape e -> raise_for tr_exn (Escape e)\n\n(* Note: the level of a type constructor must be greater than its binding\n time. That way, a type constructor cannot escape the scope of its\n definition, as would be the case in\n let x = ref []\n module M = struct type t let _ = (x : t list ref) end\n (without this constraint, the type system would actually be unsound.)\n*)\n\nlet rec update_level env level expand ty =\n if get_level ty > level then begin\n if level < get_scope ty then raise_scope_escape_exn ty;\n match get_desc ty with\n Tconstr(p, _tl, _abbrev) when level < Path.scope p ->\n (* Try first to replace an abbreviation by its expansion. *)\n begin try\n let ty' = !forward_try_expand_safe env ty in\n link_type ty ty';\n update_level env level expand ty'\n with Cannot_expand ->\n raise_escape_exn (Constructor p)\n end\n | Tconstr(p, (_ :: _ as tl), _) ->\n let variance =\n try (Env.find_type p env).type_variance\n with Not_found -> List.map (fun _ -> Variance.unknown) tl in\n let needs_expand =\n expand ||\n List.exists2\n (fun var ty -> var = Variance.null && get_level ty > level)\n variance tl\n in\n begin try\n if not needs_expand then raise Cannot_expand;\n let ty' = !forward_try_expand_safe env ty in\n link_type ty ty';\n update_level env level expand ty'\n with Cannot_expand ->\n set_level ty level;\n iter_type_expr (update_level env level expand) ty\n end\n | Tpackage (p, fl) when level < Path.scope p ->\n let p' = normalize_package_path env p in\n if Path.same p p' then raise_escape_exn (Module_type p);\n set_type_desc ty (Tpackage (p', fl));\n update_level env level expand ty\n | Tobject (_, ({contents=Some(p, _tl)} as nm))\n when level < Path.scope p ->\n set_name nm None;\n update_level env level expand ty\n | Tvariant row ->\n begin match row_name row with\n | Some (p, _tl) when level < Path.scope p ->\n set_type_desc ty (Tvariant (set_row_name row None))\n | _ -> ()\n end;\n set_level ty level;\n iter_type_expr (update_level env level expand) ty\n | Tfield(lab, _, ty1, _)\n when lab = dummy_method && level < get_scope ty1 ->\n raise_escape_exn Self\n | _ ->\n set_level ty level;\n (* XXX what about abbreviations in Tconstr ? *)\n iter_type_expr (update_level env level expand) ty\n end\n\n(* First try without expanding, then expand everything,\n to avoid combinatorial blow-up *)\nlet update_level env level ty =\n if get_level ty > level then begin\n let snap = snapshot () in\n try\n update_level env level false ty\n with Escape _ ->\n backtrack snap;\n update_level env level true ty\n end\n\nlet update_level_for tr_exn env level ty =\n try\n update_level env level ty\n with Escape e -> raise_for tr_exn (Escape e)\n\n(* Lower level of type variables inside contravariant branches *)\n\nlet rec lower_contravariant env var_level visited contra ty =\n let must_visit =\n get_level ty > var_level &&\n match Hashtbl.find visited (get_id ty) with\n | done_contra -> contra && not done_contra\n | exception Not_found -> true\n in\n if must_visit then begin\n Hashtbl.add visited (get_id ty) contra;\n let lower_rec = lower_contravariant env var_level visited in\n match get_desc ty with\n Tvar _ -> if contra then set_level ty var_level\n | Tconstr (_, [], _) -> ()\n | Tconstr (path, tyl, _abbrev) ->\n let variance, maybe_expand =\n try\n let typ = Env.find_type path env in\n typ.type_variance,\n typ.type_kind = Type_abstract\n with Not_found ->\n (* See testsuite/tests/typing-missing-cmi-2 for an example *)\n List.map (fun _ -> Variance.unknown) tyl,\n false\n in\n if List.for_all ((=) Variance.null) variance then () else\n let not_expanded () =\n List.iter2\n (fun v t ->\n if v = Variance.null then () else\n if Variance.(mem May_weak v)\n then lower_rec true t\n else lower_rec contra t)\n variance tyl in\n if maybe_expand then (* we expand cautiously to avoid missing cmis *)\n match !forward_try_expand_safe env ty with\n | ty -> lower_rec contra ty\n | exception Cannot_expand -> not_expanded ()\n else not_expanded ()\n | Tpackage (_, fl) ->\n List.iter (fun (_n, ty) -> lower_rec true ty) fl\n | Tarrow (_, t1, t2, _) ->\n lower_rec true t1;\n lower_rec contra t2\n | _ ->\n iter_type_expr (lower_rec contra) ty\n end\n\nlet lower_variables_only env level ty =\n simple_abbrevs := Mnil;\n lower_contravariant env level (Hashtbl.create 7) true ty\n\nlet lower_contravariant env ty =\n simple_abbrevs := Mnil;\n lower_contravariant env !nongen_level (Hashtbl.create 7) false ty\n\nlet rec generalize_class_type' gen =\n function\n Cty_constr (_, params, cty) ->\n List.iter gen params;\n generalize_class_type' gen cty\n | Cty_signature csig ->\n gen csig.csig_self;\n gen csig.csig_self_row;\n Vars.iter (fun _ (_, _, ty) -> gen ty) csig.csig_vars;\n Meths.iter (fun _ (_, _, ty) -> gen ty) csig.csig_meths\n | Cty_arrow (_, ty, cty) ->\n gen ty;\n generalize_class_type' gen cty\n\nlet generalize_class_type cty =\n generalize_class_type' generalize cty\n\nlet generalize_class_type_structure cty =\n generalize_class_type' generalize_structure cty\n\n(* Correct the levels of type [ty]. *)\nlet correct_levels ty =\n duplicate_type ty\n\n(* Only generalize the type ty0 in ty *)\nlet limited_generalize ty0 ty =\n let graph = Hashtbl.create 17 in\n let idx = ref lowest_level in\n let roots = ref [] in\n\n let rec inverse pty ty =\n let level = get_level ty in\n if (level > !current_level) || (level = generic_level) then begin\n decr idx;\n Hashtbl.add graph !idx (ty, ref pty);\n if (level = generic_level) || eq_type ty ty0 then\n roots := ty :: !roots;\n set_level ty !idx;\n iter_type_expr (inverse [ty]) ty\n end else if level < lowest_level then begin\n let (_, parents) = Hashtbl.find graph level in\n parents := pty @ !parents\n end\n\n and generalize_parents ty =\n let idx = get_level ty in\n if idx <> generic_level then begin\n set_level ty generic_level;\n List.iter generalize_parents !(snd (Hashtbl.find graph idx));\n (* Special case for rows: must generalize the row variable *)\n match get_desc ty with\n Tvariant row ->\n let more = row_more row in\n let lv = get_level more in\n if (lv < lowest_level || lv > !current_level)\n && lv <> generic_level then set_level more generic_level\n | _ -> ()\n end\n in\n\n inverse [] ty;\n if get_level ty0 < lowest_level then\n iter_type_expr (inverse []) ty0;\n List.iter generalize_parents !roots;\n Hashtbl.iter\n (fun _ (ty, _) ->\n if get_level ty <> generic_level then set_level ty !current_level)\n graph\n\nlet limited_generalize_class_type rv cty =\n generalize_class_type' (limited_generalize rv) cty\n\n(* Compute statically the free univars of all nodes in a type *)\n(* This avoids doing it repeatedly during instantiation *)\n\ntype inv_type_expr =\n { inv_type : type_expr;\n mutable inv_parents : inv_type_expr list }\n\nlet rec inv_type hash pty ty =\n try\n let inv = TypeHash.find hash ty in\n inv.inv_parents <- pty @ inv.inv_parents\n with Not_found ->\n let inv = { inv_type = ty; inv_parents = pty } in\n TypeHash.add hash ty inv;\n iter_type_expr (inv_type hash [inv]) ty\n\nlet compute_univars ty =\n let inverted = TypeHash.create 17 in\n inv_type inverted [] ty;\n let node_univars = TypeHash.create 17 in\n let rec add_univar univ inv =\n match get_desc inv.inv_type with\n Tpoly (_ty, tl) when List.memq (get_id univ) (List.map get_id tl) -> ()\n | _ ->\n try\n let univs = TypeHash.find node_univars inv.inv_type in\n if not (TypeSet.mem univ !univs) then begin\n univs := TypeSet.add univ !univs;\n List.iter (add_univar univ) inv.inv_parents\n end\n with Not_found ->\n TypeHash.add node_univars inv.inv_type (ref(TypeSet.singleton univ));\n List.iter (add_univar univ) inv.inv_parents\n in\n TypeHash.iter (fun ty inv -> if is_Tunivar ty then add_univar ty inv)\n inverted;\n fun ty ->\n try !(TypeHash.find node_univars ty) with Not_found -> TypeSet.empty\n\n\nlet fully_generic ty =\n let rec aux ty =\n if not_marked_node ty then\n if get_level ty = generic_level then\n (flip_mark_node ty; iter_type_expr aux ty)\n else raise Exit\n in\n let res = try aux ty; true with Exit -> false in\n unmark_type ty;\n res\n\n\n (*******************)\n (* Instantiation *)\n (*******************)\n\n\nlet rec find_repr p1 =\n function\n Mnil ->\n None\n | Mcons (Public, p2, ty, _, _) when Path.same p1 p2 ->\n Some ty\n | Mcons (_, _, _, _, rem) ->\n find_repr p1 rem\n | Mlink {contents = rem} ->\n find_repr p1 rem\n\n(*\n Generic nodes are duplicated, while non-generic nodes are left\n as-is.\n During instantiation, the description of a generic node is first\n replaced by a link to a stub ([Tsubst (newvar ())]). Once the\n copy is made, it replaces the stub.\n After instantiation, the description of generic node, which was\n stored by [save_desc], must be put back, using [cleanup_types].\n*)\n\nlet abbreviations = ref (ref Mnil)\n (* Abbreviation memorized. *)\n\n(* partial: we may not wish to copy the non generic types\n before we call type_pat *)\nlet rec copy ?partial ?keep_names scope ty =\n let copy = copy ?partial ?keep_names scope in\n match get_desc ty with\n Tsubst (ty, _) -> ty\n | desc ->\n let level = get_level ty in\n if level <> generic_level && partial = None then ty else\n (* We only forget types that are non generic and do not contain\n free univars *)\n let forget =\n if level = generic_level then generic_level else\n match partial with\n None -> assert false\n | Some (free_univars, keep) ->\n if TypeSet.is_empty (free_univars ty) then\n if keep then level else !current_level\n else generic_level\n in\n if forget <> generic_level then newty2 ~level:forget (Tvar None) else\n let t = newstub ~scope:(get_scope ty) in\n For_copy.redirect_desc scope ty (Tsubst (t, None));\n let desc' =\n match desc with\n | Tconstr (p, tl, _) ->\n let abbrevs = proper_abbrevs p tl !abbreviations in\n begin match find_repr p !abbrevs with\n Some ty when not (eq_type ty t) ->\n Tlink ty\n | _ ->\n (*\n One must allocate a new reference, so that abbrevia-\n tions belonging to different branches of a type are\n independent.\n Moreover, a reference containing a [Mcons] must be\n shared, so that the memorized expansion of an abbrevi-\n ation can be released by changing the content of just\n one reference.\n *)\n Tconstr (p, List.map copy tl,\n ref (match !(!abbreviations) with\n Mcons _ -> Mlink !abbreviations\n | abbrev -> abbrev))\n end\n | Tvariant row ->\n let more = row_more row in\n let mored = get_desc more in\n (* We must substitute in a subtle way *)\n (* Tsubst takes a tuple containing the row var and the variant *)\n begin match mored with\n Tsubst (_, Some ty2) ->\n (* This variant type has been already copied *)\n (* Change the stub to avoid Tlink in the new type *)\n For_copy.redirect_desc scope ty (Tsubst (ty2, None));\n Tlink ty2\n | _ ->\n (* If the row variable is not generic, we must keep it *)\n let keep = get_level more <> generic_level && partial = None in\n let more' =\n match mored with\n Tsubst (ty, None) -> ty\n (* TODO: is this case possible?\n possibly an interaction with (copy more) below? *)\n | Tconstr _ | Tnil ->\n copy more\n | Tvar _ | Tunivar _ ->\n if keep then more else newty mored\n | _ -> assert false\n in\n let row =\n match get_desc more' with (* PR#6163 *)\n Tconstr (x,_,_) when not (is_fixed row) ->\n let Row {fields; more; closed; name} = row_repr row in\n create_row ~fields ~more ~closed ~name\n ~fixed:(Some (Reified x))\n | _ -> row\n in\n (* Open row if partial for pattern and contains Reither *)\n let more', row =\n match partial with\n Some (free_univars, false) ->\n let more' =\n if not (eq_type more more') then\n more' (* we've already made a copy *)\n else\n newvar ()\n in\n let not_reither (_, f) =\n match row_field_repr f with\n Reither _ -> false\n | _ -> true\n in\n let fields = row_fields row in\n if row_closed row && not (is_fixed row)\n && TypeSet.is_empty (free_univars ty)\n && not (List.for_all not_reither fields) then\n (more',\n create_row ~fields:(List.filter not_reither fields)\n ~more:more' ~closed:false ~fixed:None ~name:None)\n else (more', row)\n | _ -> (more', row)\n in\n (* Register new type first for recursion *)\n For_copy.redirect_desc scope more\n (Tsubst(more', Some t));\n (* Return a new copy *)\n Tvariant (copy_row copy true row keep more')\n end\n | Tobject (ty1, _) when partial <> None ->\n Tobject (copy ty1, ref None)\n | _ -> copy_type_desc ?keep_names copy desc\n in\n Transient_expr.set_stub_desc t desc';\n t\n\n(**** Variants of instantiations ****)\n\nlet instance ?partial sch =\n let partial =\n match partial with\n None -> None\n | Some keep -> Some (compute_univars sch, keep)\n in\n For_copy.with_scope (fun scope -> copy ?partial scope sch)\n\nlet generic_instance sch =\n let old = !current_level in\n current_level := generic_level;\n let ty = instance sch in\n current_level := old;\n ty\n\nlet instance_list schl =\n For_copy.with_scope (fun scope -> List.map (fun t -> copy scope t) schl)\n\nlet reified_var_counter = ref Vars.empty\nlet reset_reified_var_counter () =\n reified_var_counter := Vars.empty\n\n(* names given to new type constructors.\n Used for existential types and\n local constraints *)\nlet get_new_abstract_name s =\n let index =\n try Vars.find s !reified_var_counter + 1\n with Not_found -> 0 in\n reified_var_counter := Vars.add s index !reified_var_counter;\n if index = 0 && s <> \"\" && s.[String.length s - 1] <> '$' then s else\n Printf.sprintf \"%s%d\" s index\n\nlet new_local_type ?(loc = Location.none) ?manifest_and_scope () =\n let manifest, expansion_scope =\n match manifest_and_scope with\n None -> None, Btype.lowest_level\n | Some (ty, scope) -> Some ty, scope\n in\n {\n type_params = [];\n type_arity = 0;\n type_kind = Type_abstract;\n type_private = Public;\n type_manifest = manifest;\n type_variance = [];\n type_separability = [];\n type_is_newtype = true;\n type_expansion_scope = expansion_scope;\n type_loc = loc;\n type_attributes = [];\n type_immediate = Unknown;\n type_unboxed_default = false;\n type_uid = Uid.mk ~current_unit:(Env.get_unit_name ());\n }\n\nlet existential_name cstr ty =\n match get_desc ty with\n | Tvar (Some name) -> \"$\" ^ cstr.cstr_name ^ \"_'\" ^ name\n | _ -> \"$\" ^ cstr.cstr_name\n\nlet instance_constructor ?in_pattern cstr =\n For_copy.with_scope (fun scope ->\n begin match in_pattern with\n | None -> ()\n | Some (env, fresh_constr_scope) ->\n let process existential =\n let decl = new_local_type () in\n let name = existential_name cstr existential in\n let (id, new_env) =\n Env.enter_type (get_new_abstract_name name) decl !env\n ~scope:fresh_constr_scope in\n env := new_env;\n let to_unify = newty (Tconstr (Path.Pident id,[],ref Mnil)) in\n let tv = copy scope existential in\n assert (is_Tvar tv);\n link_type tv to_unify\n in\n List.iter process cstr.cstr_existentials\n end;\n let ty_res = copy scope cstr.cstr_res in\n let ty_args = List.map (copy scope) cstr.cstr_args in\n let ty_ex = List.map (copy scope) cstr.cstr_existentials in\n (ty_args, ty_res, ty_ex)\n )\n\nlet instance_parameterized_type ?keep_names sch_args sch =\n For_copy.with_scope (fun scope ->\n let ty_args = List.map (fun t -> copy ?keep_names scope t) sch_args in\n let ty = copy scope sch in\n (ty_args, ty)\n )\n\nlet instance_parameterized_type_2 sch_args sch_lst sch =\n For_copy.with_scope (fun scope ->\n let ty_args = List.map (copy scope) sch_args in\n let ty_lst = List.map (copy scope) sch_lst in\n let ty = copy scope sch in\n (ty_args, ty_lst, ty)\n )\n\nlet map_kind f = function\n | Type_abstract -> Type_abstract\n | Type_open -> Type_open\n | Type_variant (cl, rep) ->\n Type_variant (\n List.map\n (fun c ->\n {c with\n cd_args = map_type_expr_cstr_args f c.cd_args;\n cd_res = Option.map f c.cd_res\n })\n cl, rep)\n | Type_record (fl, rr) ->\n Type_record (\n List.map\n (fun l ->\n {l with ld_type = f l.ld_type}\n ) fl, rr)\n\n\nlet instance_declaration decl =\n For_copy.with_scope (fun scope ->\n {decl with type_params = List.map (copy scope) decl.type_params;\n type_manifest = Option.map (copy scope) decl.type_manifest;\n type_kind = map_kind (copy scope) decl.type_kind;\n }\n )\n\nlet generic_instance_declaration decl =\n let old = !current_level in\n current_level := generic_level;\n let decl = instance_declaration decl in\n current_level := old;\n decl\n\nlet instance_class params cty =\n let rec copy_class_type scope = function\n | Cty_constr (path, tyl, cty) ->\n let tyl' = List.map (copy scope) tyl in\n let cty' = copy_class_type scope cty in\n Cty_constr (path, tyl', cty')\n | Cty_signature sign ->\n Cty_signature\n {csig_self = copy scope sign.csig_self;\n csig_self_row = copy scope sign.csig_self_row;\n csig_vars =\n Vars.map\n (function (m, v, ty) -> (m, v, copy scope ty))\n sign.csig_vars;\n csig_meths =\n Meths.map\n (function (p, v, ty) -> (p, v, copy scope ty))\n sign.csig_meths}\n | Cty_arrow (l, ty, cty) ->\n Cty_arrow (l, copy scope ty, copy_class_type scope cty)\n in\n For_copy.with_scope (fun scope ->\n let params' = List.map (copy scope) params in\n let cty' = copy_class_type scope cty in\n (params', cty')\n )\n\n(**** Instantiation for types with free universal variables ****)\n\nlet rec diff_list l1 l2 =\n if l1 == l2 then [] else\n match l1 with [] -> invalid_arg \"Ctype.diff_list\"\n | a :: l1 -> a :: diff_list l1 l2\n\nlet conflicts free bound =\n let bound = List.map get_id bound in\n TypeSet.exists (fun t -> List.memq (get_id t) bound) free\n\nlet delayed_copy = ref []\n (* copying to do later *)\n\n(* Copy without sharing until there are no free univars left *)\n(* all free univars must be included in [visited] *)\nlet rec copy_sep ~cleanup_scope ~fixed ~free ~bound ~may_share\n (visited : (int * (type_expr * type_expr list)) list) (ty : type_expr) =\n let univars = free ty in\n if is_Tvar ty || may_share && TypeSet.is_empty univars then\n if get_level ty <> generic_level then ty else\n let t = newstub ~scope:(get_scope ty) in\n delayed_copy :=\n lazy (Transient_expr.set_stub_desc t (Tlink (copy cleanup_scope ty)))\n :: !delayed_copy;\n t\n else try\n let t, bound_t = List.assq (get_id ty) visited in\n let dl = if is_Tunivar ty then [] else diff_list bound bound_t in\n if dl <> [] && conflicts univars dl then raise Not_found;\n t\n with Not_found -> begin\n let t = newstub ~scope:(get_scope ty) in\n let desc = get_desc ty in\n let visited =\n match desc with\n Tarrow _ | Ttuple _ | Tvariant _ | Tconstr _ | Tobject _ | Tpackage _ ->\n (get_id ty, (t, bound)) :: visited\n | Tvar _ | Tfield _ | Tnil | Tpoly _ | Tunivar _ ->\n visited\n | Tlink _ | Tsubst _ ->\n assert false\n in\n let copy_rec = copy_sep ~cleanup_scope ~fixed ~free ~bound visited in\n let desc' =\n match desc with\n | Tvariant row ->\n let more = row_more row in\n (* We shall really check the level on the row variable *)\n let keep = is_Tvar more && get_level more <> generic_level in\n let more' = copy_rec ~may_share:false more in\n let fixed' = fixed && (is_Tvar more || is_Tunivar more) in\n let row =\n copy_row (copy_rec ~may_share:true) fixed' row keep more' in\n Tvariant row\n | Tpoly (t1, tl) ->\n let tl' = List.map (fun t -> newty (get_desc t)) tl in\n let bound = tl @ bound in\n let visited =\n List.map2 (fun ty t -> get_id ty, (t, bound)) tl tl' @ visited in\n let body =\n copy_sep ~cleanup_scope ~fixed ~free ~bound ~may_share:true\n visited t1 in\n Tpoly (body, tl')\n | Tfield (p, k, ty1, ty2) ->\n (* the kind is kept shared, see Btype.copy_type_desc *)\n Tfield (p, field_kind_internal_repr k, copy_rec ~may_share:true ty1,\n copy_rec ~may_share:false ty2)\n | _ -> copy_type_desc (copy_rec ~may_share:true) desc\n in\n Transient_expr.set_stub_desc t desc';\n t\n end\n\nlet instance_poly' cleanup_scope ~keep_names fixed univars sch =\n (* In order to compute univars below, [sch] should not contain [Tsubst] *)\n let copy_var ty =\n match get_desc ty with\n Tunivar name -> if keep_names then newty (Tvar name) else newvar ()\n | _ -> assert false\n in\n let vars = List.map copy_var univars in\n let pairs = List.map2 (fun u v -> get_id u, (v, [])) univars vars in\n delayed_copy := [];\n let ty =\n copy_sep ~cleanup_scope ~fixed ~free:(compute_univars sch) ~bound:[]\n ~may_share:true pairs sch in\n List.iter Lazy.force !delayed_copy;\n delayed_copy := [];\n vars, ty\n\nlet instance_poly ?(keep_names=false) fixed univars sch =\n For_copy.with_scope (fun cleanup_scope ->\n instance_poly' cleanup_scope ~keep_names fixed univars sch\n )\n\nlet instance_label fixed lbl =\n For_copy.with_scope (fun scope ->\n let vars, ty_arg =\n match get_desc lbl.lbl_arg with\n Tpoly (ty, tl) ->\n instance_poly' scope ~keep_names:false fixed tl ty\n | _ ->\n [], copy scope lbl.lbl_arg\n in\n (* call [copy] after [instance_poly] to avoid introducing [Tsubst] *)\n let ty_res = copy scope lbl.lbl_res in\n (vars, ty_arg, ty_res)\n )\n\n(**** Instantiation with parameter substitution ****)\n\n(* NB: since this is [unify_var], it raises [Unify], not [Unify_trace] *)\nlet unify_var' = (* Forward declaration *)\n ref (fun _env _ty1 _ty2 -> assert false)\n\nlet subst env level priv abbrev oty params args body =\n if List.length params <> List.length args then raise Cannot_subst;\n let old_level = !current_level in\n current_level := level;\n let body0 = newvar () in (* Stub *)\n let undo_abbrev =\n match oty with\n | None -> fun () -> () (* No abbreviation added *)\n | Some ty ->\n match get_desc ty with\n Tconstr (path, tl, _) ->\n let abbrev = proper_abbrevs path tl abbrev in\n memorize_abbrev abbrev priv path ty body0;\n fun () -> forget_abbrev abbrev path\n | _ -> assert false\n in\n abbreviations := abbrev;\n let (params', body') = instance_parameterized_type params body in\n abbreviations := ref Mnil;\n try\n !unify_var' env body0 body';\n List.iter2 (!unify_var' env) params' args;\n current_level := old_level;\n body'\n with Unify _ ->\n current_level := old_level;\n undo_abbrev ();\n raise Cannot_subst\n\n(*\n Only the shape of the type matters, not whether it is generic or\n not. [generic_level] might be somewhat slower, but it ensures\n invariants on types are enforced (decreasing levels), and we don't\n care about efficiency here.\n*)\nlet apply env params body args =\n try\n subst env generic_level Public (ref Mnil) None params args body\n with\n Cannot_subst -> raise Cannot_apply\n\nlet () = Subst.ctype_apply_env_empty := apply Env.empty\n\n (****************************)\n (* Abbreviation expansion *)\n (****************************)\n\n(*\n If the environment has changed, memorized expansions might not\n be correct anymore, and so we flush the cache. This is safe but\n quite pessimistic: it would be enough to flush the cache when a\n type or module definition is overridden in the environment.\n*)\nlet previous_env = ref Env.empty\n(*let string_of_kind = function Public -> \"public\" | Private -> \"private\"*)\nlet check_abbrev_env env =\n if env != !previous_env then begin\n (* prerr_endline \"cleanup expansion cache\"; *)\n cleanup_abbrev ();\n previous_env := env\n end\n\n\n(* Expand an abbreviation. The expansion is memorized. *)\n(*\n Assume the level is greater than the path binding time of the\n expanded abbreviation.\n*)\n(*\n An abbreviation expansion will fail in either of these cases:\n 1. The type constructor does not correspond to a manifest type.\n 2. The type constructor is defined in an external file, and this\n file is not in the path (missing -I options).\n 3. The type constructor is not in the \"local\" environment. This can\n happens when a non-generic type variable has been instantiated\n afterwards to the not yet defined type constructor. (Actually,\n this cannot happen at the moment due to the strong constraints\n between type levels and constructor binding time.)\n 4. The expansion requires the expansion of another abbreviation,\n and this other expansion fails.\n*)\nlet expand_abbrev_gen kind find_type_expansion env ty =\n check_abbrev_env env;\n match get_desc ty with\n Tconstr (path, args, abbrev) ->\n let level = get_level ty in\n let scope = get_scope ty in\n let lookup_abbrev = proper_abbrevs path args abbrev in\n begin match find_expans kind path !lookup_abbrev with\n Some ty' ->\n (* prerr_endline\n (\"found a \"^string_of_kind kind^\" expansion for \"^Path.name path);*)\n if level <> generic_level then\n begin try\n update_level env level ty'\n with Escape _ ->\n (* XXX This should not happen.\n However, levels are not correctly restored after a\n typing error *)\n ()\n end;\n begin try\n update_scope scope ty';\n with Escape _ ->\n (* XXX This should not happen.\n However, levels are not correctly restored after a\n typing error *)\n ()\n end;\n ty'\n | None ->\n match find_type_expansion path env with\n | exception Not_found ->\n (* another way to expand is to normalize the path itself *)\n let path' = Env.normalize_type_path None env path in\n if Path.same path path' then raise Cannot_expand\n else newty2 ~level (Tconstr (path', args, abbrev))\n | (params, body, lv) ->\n (* prerr_endline\n (\"add a \"^string_of_kind kind^\" expansion for \"^Path.name path);*)\n let ty' =\n try\n subst env level kind abbrev (Some ty) params args body\n with Cannot_subst -> raise_escape_exn Constraint\n in\n (* For gadts, remember type as non exportable *)\n (* The ambiguous level registered for ty' should be the highest *)\n (* if !trace_gadt_instances then begin *)\n let scope = Int.max lv (get_scope ty) in\n update_scope scope ty;\n update_scope scope ty';\n ty'\n end\n | _ ->\n assert false\n\n(* Expand respecting privacy *)\nlet expand_abbrev env ty =\n expand_abbrev_gen Public Env.find_type_expansion env ty\n\n(* Expand once the head of a type *)\nlet expand_head_once env ty =\n try\n expand_abbrev env ty\n with Cannot_expand | Escape _ -> assert false\n\n(* Check whether a type can be expanded *)\nlet safe_abbrev env ty =\n let snap = Btype.snapshot () in\n try ignore (expand_abbrev env ty); true with\n Cannot_expand ->\n Btype.backtrack snap;\n false\n | Escape _ ->\n Btype.backtrack snap;\n cleanup_abbrev ();\n false\n\n(* Expand the head of a type once.\n Raise Cannot_expand if the type cannot be expanded.\n May raise Escape, if a recursion was hidden in the type. *)\nlet try_expand_once env ty =\n match get_desc ty with\n Tconstr _ -> expand_abbrev env ty\n | _ -> raise Cannot_expand\n\n(* This one only raises Cannot_expand *)\nlet try_expand_safe env ty =\n let snap = Btype.snapshot () in\n try try_expand_once env ty\n with Escape _ ->\n Btype.backtrack snap; cleanup_abbrev (); raise Cannot_expand\n\n(* Fully expand the head of a type. *)\nlet rec try_expand_head\n (try_once : Env.t -> type_expr -> type_expr) env ty =\n let ty' = try_once env ty in\n try try_expand_head try_once env ty'\n with Cannot_expand -> ty'\n\n(* Unsafe full expansion, may raise [Unify [Escape _]]. *)\nlet expand_head_unif env ty =\n try\n try_expand_head try_expand_once env ty\n with\n | Cannot_expand -> ty\n | Escape e -> raise_for Unify (Escape e)\n\n(* Safe version of expand_head, never fails *)\nlet expand_head env ty =\n try try_expand_head try_expand_safe env ty\n with Cannot_expand -> ty\n\nlet _ = forward_try_expand_safe := try_expand_safe\n\n\n(* Expand until we find a non-abstract type declaration,\n use try_expand_safe to avoid raising \"Unify _\" when\n called on recursive types\n *)\n\ntype typedecl_extraction_result =\n | Typedecl of Path.t * Path.t * type_declaration\n | Has_no_typedecl\n | May_have_typedecl\n\nlet rec extract_concrete_typedecl env ty =\n match get_desc ty with\n Tconstr (p, _, _) ->\n begin match Env.find_type p env with\n | exception Not_found -> May_have_typedecl\n | decl ->\n if decl.type_kind <> Type_abstract then Typedecl(p, p, decl)\n else begin\n match try_expand_safe env ty with\n | exception Cannot_expand -> May_have_typedecl\n | ty ->\n match extract_concrete_typedecl env ty with\n | Typedecl(_, p', decl) -> Typedecl(p, p', decl)\n | Has_no_typedecl -> Has_no_typedecl\n | May_have_typedecl -> May_have_typedecl\n end\n end\n | Tpoly(ty, _) -> extract_concrete_typedecl env ty\n | Tarrow _ | Ttuple _ | Tobject _ | Tfield _ | Tnil\n | Tvariant _ | Tpackage _ -> Has_no_typedecl\n | Tvar _ | Tunivar _ -> May_have_typedecl\n | Tlink _ | Tsubst _ -> assert false\n\n(* Implementing function [expand_head_opt], the compiler's own version of\n [expand_head] used for type-based optimisations.\n [expand_head_opt] uses [Env.find_type_expansion_opt] to access the\n manifest type information of private abstract data types which is\n normally hidden to the type-checker out of the implementation module of\n the private abbreviation. *)\n\nlet expand_abbrev_opt env ty =\n expand_abbrev_gen Private Env.find_type_expansion_opt env ty\n\nlet safe_abbrev_opt env ty =\n let snap = Btype.snapshot () in\n try ignore (expand_abbrev_opt env ty); true\n with Cannot_expand | Escape _ ->\n Btype.backtrack snap;\n false\n\nlet try_expand_once_opt env ty =\n match get_desc ty with\n Tconstr _ -> expand_abbrev_opt env ty\n | _ -> raise Cannot_expand\n\nlet try_expand_safe_opt env ty =\n let snap = Btype.snapshot () in\n try try_expand_once_opt env ty\n with Escape _ ->\n Btype.backtrack snap; raise Cannot_expand\n\nlet expand_head_opt env ty =\n try try_expand_head try_expand_safe_opt env ty with Cannot_expand -> ty\n\n(* Recursively expand the head of a type.\n Also expand #-types.\n\n Error printing relies on [full_expand] returning exactly its input (i.e., a\n physically equal type) when nothing changes. *)\nlet full_expand ~may_forget_scope env ty =\n let ty =\n if may_forget_scope then\n try expand_head_unif env ty with Unify_trace _ ->\n (* #10277: forget scopes when printing trace *)\n begin_def ();\n init_def (get_level ty);\n let ty =\n (* The same as [expand_head], except in the failing case we return the\n *original* type, not [correct_levels ty].*)\n try try_expand_head try_expand_safe env (correct_levels ty) with\n | Cannot_expand -> ty\n in\n end_def ();\n ty\n else expand_head env ty\n in\n match get_desc ty with\n Tobject (fi, {contents = Some (_, v::_)}) when is_Tvar v ->\n newty2 ~level:(get_level ty) (Tobject (fi, ref None))\n | _ ->\n ty\n\n(*\n Check whether the abbreviation expands to a well-defined type.\n During the typing of a class, abbreviations for correspondings\n types expand to non-generic types.\n*)\nlet generic_abbrev env path =\n try\n let (_, body, _) = Env.find_type_expansion path env in\n get_level body = generic_level\n with\n Not_found ->\n false\n\nlet generic_private_abbrev env path =\n try\n match Env.find_type path env with\n {type_kind = Type_abstract;\n type_private = Private;\n type_manifest = Some body} ->\n get_level body = generic_level\n | _ -> false\n with Not_found -> false\n\nlet is_contractive env p =\n try\n let decl = Env.find_type p env in\n in_pervasives p && decl.type_manifest = None || is_datatype decl\n with Not_found -> false\n\n\n (*****************)\n (* Occur check *)\n (*****************)\n\n\nexception Occur\n\nlet rec occur_rec env allow_recursive visited ty0 ty =\n if eq_type ty ty0 then raise Occur;\n match get_desc ty with\n Tconstr(p, _tl, _abbrev) ->\n if allow_recursive && is_contractive env p then () else\n begin try\n if TypeSet.mem ty visited then raise Occur;\n let visited = TypeSet.add ty visited in\n iter_type_expr (occur_rec env allow_recursive visited ty0) ty\n with Occur -> try\n let ty' = try_expand_head try_expand_once env ty in\n (* This call used to be inlined, but there seems no reason for it.\n Message was referring to change in rev. 1.58 of the CVS repo. *)\n occur_rec env allow_recursive visited ty0 ty'\n with Cannot_expand ->\n raise Occur\n end\n | Tobject _ | Tvariant _ ->\n ()\n | _ ->\n if allow_recursive || TypeSet.mem ty visited then () else begin\n let visited = TypeSet.add ty visited in\n iter_type_expr (occur_rec env allow_recursive visited ty0) ty\n end\n\nlet type_changed = ref false (* trace possible changes to the studied type *)\n\nlet merge r b = if b then r := true\n\nlet occur env ty0 ty =\n let allow_recursive =\n !Clflags.recursive_types || !umode = Pattern && !allow_recursive_equation in\n let old = !type_changed in\n try\n while\n type_changed := false;\n if not (eq_type ty0 ty) then\n occur_rec env allow_recursive TypeSet.empty ty0 ty;\n !type_changed\n do () (* prerr_endline \"changed\" *) done;\n merge type_changed old\n with exn ->\n merge type_changed old;\n raise exn\n\nlet occur_for tr_exn env t1 t2 =\n try\n occur env t1 t2\n with Occur -> raise_for tr_exn (Rec_occur(t1, t2))\n\nlet occur_in env ty0 t =\n try occur env ty0 t; false with Occur -> true\n\n(* Check that a local constraint is well-founded *)\n(* PR#6405: not needed since we allow recursion and work on normalized types *)\n(* PR#6992: we actually need it for contractiveness *)\n(* This is a simplified version of occur, only for the rectypes case *)\n\nlet rec local_non_recursive_abbrev ~allow_rec strict visited env p ty =\n (*Format.eprintf \"@[Check %s =@ %a@]@.\" (Path.name p) !Btype.print_raw ty;*)\n if not (List.memq (get_id ty) visited) then begin\n match get_desc ty with\n Tconstr(p', args, _abbrev) ->\n if Path.same p p' then raise Occur;\n if allow_rec && not strict && is_contractive env p' then () else\n let visited = get_id ty :: visited in\n begin try\n (* try expanding, since [p] could be hidden *)\n local_non_recursive_abbrev ~allow_rec strict visited env p\n (try_expand_head try_expand_safe_opt env ty)\n with Cannot_expand ->\n let params =\n try (Env.find_type p' env).type_params\n with Not_found -> args\n in\n List.iter2\n (fun tv ty ->\n let strict = strict || not (is_Tvar tv) in\n local_non_recursive_abbrev ~allow_rec strict visited env p ty)\n params args\n end\n | Tobject _ | Tvariant _ when not strict ->\n ()\n | _ ->\n if strict || not allow_rec then (* PR#7374 *)\n let visited = get_id ty :: visited in\n iter_type_expr\n (local_non_recursive_abbrev ~allow_rec true visited env p) ty\n end\n\nlet local_non_recursive_abbrev env p ty =\n let allow_rec =\n !Clflags.recursive_types || !umode = Pattern && !allow_recursive_equation in\n try (* PR#7397: need to check trace_gadt_instances *)\n wrap_trace_gadt_instances env\n (local_non_recursive_abbrev ~allow_rec false [] env p) ty;\n true\n with Occur -> false\n\n\n (*****************************)\n (* Polymorphic Unification *)\n (*****************************)\n\n(* Since we cannot duplicate universal variables, unification must\n be done at meta-level, using bindings in univar_pairs *)\n(* TODO: use find_opt *)\nlet rec unify_univar t1 t2 = function\n (cl1, cl2) :: rem ->\n let find_univ t cl =\n try\n let (_, r) = List.find (fun (t',_) -> eq_type t t') cl in\n Some r\n with Not_found -> None\n in\n begin match find_univ t1 cl1, find_univ t2 cl2 with\n Some {contents=Some t'2}, Some _ when eq_type t2 t'2 ->\n ()\n | Some({contents=None} as r1), Some({contents=None} as r2) ->\n set_univar r1 t2; set_univar r2 t1\n | None, None ->\n unify_univar t1 t2 rem\n | _ ->\n raise Cannot_unify_universal_variables\n end\n | [] -> raise Cannot_unify_universal_variables\n\n(* The same as [unify_univar], but raises the appropriate exception instead of\n [Cannot_unify_universal_variables] *)\nlet unify_univar_for tr_exn t1 t2 univar_pairs =\n try unify_univar t1 t2 univar_pairs\n with Cannot_unify_universal_variables -> raise_unexplained_for tr_exn\n\n(* Test the occurrence of free univars in a type *)\n(* That's way too expensive. Must do some kind of caching *)\n(* If [inj_only=true], only check injective positions *)\nlet occur_univar ?(inj_only=false) env ty =\n let visited = ref TypeMap.empty in\n let rec occur_rec bound ty =\n if not_marked_node ty then\n if TypeSet.is_empty bound then\n (flip_mark_node ty; occur_desc bound ty)\n else try\n let bound' = TypeMap.find ty !visited in\n if not (TypeSet.subset bound' bound) then begin\n visited := TypeMap.add ty (TypeSet.inter bound bound') !visited;\n occur_desc bound ty\n end\n with Not_found ->\n visited := TypeMap.add ty bound !visited;\n occur_desc bound ty\n and occur_desc bound ty =\n match get_desc ty with\n Tunivar _ ->\n if not (TypeSet.mem ty bound) then\n raise_escape_exn (Univ ty)\n | Tpoly (ty, tyl) ->\n let bound = List.fold_right TypeSet.add tyl bound in\n occur_rec bound ty\n | Tconstr (_, [], _) -> ()\n | Tconstr (p, tl, _) ->\n begin try\n let td = Env.find_type p env in\n List.iter2\n (fun t v ->\n (* The null variance only occurs in type abbreviations and\n corresponds to type variables that do not occur in the\n definition (expansion would erase them completely).\n The type-checker consistently ignores type expressions\n in this position. Physical expansion, as done in `occur`,\n would be costly here, since we need to check inside\n object and variant types too. *)\n if Variance.(if inj_only then mem Inj v else not (eq v null))\n then occur_rec bound t)\n tl td.type_variance\n with Not_found ->\n if not inj_only then List.iter (occur_rec bound) tl\n end\n | _ -> iter_type_expr (occur_rec bound) ty\n in\n Misc.try_finally (fun () ->\n occur_rec TypeSet.empty ty\n )\n ~always:(fun () -> unmark_type ty)\n\nlet has_free_univars env ty =\n try occur_univar ~inj_only:false env ty; false with Escape _ -> true\nlet has_injective_univars env ty =\n try occur_univar ~inj_only:true env ty; false with Escape _ -> true\n\nlet occur_univar_for tr_exn env ty =\n try\n occur_univar env ty\n with Escape e -> raise_for tr_exn (Escape e)\n\n(* Grouping univars by families according to their binders *)\nlet add_univars =\n List.fold_left (fun s (t,_) -> TypeSet.add t s)\n\nlet get_univar_family univar_pairs univars =\n if univars = [] then TypeSet.empty else\n let insert s = function\n cl1, (_::_ as cl2) ->\n if List.exists (fun (t1,_) -> TypeSet.mem t1 s) cl1 then\n add_univars s cl2\n else s\n | _ -> s\n in\n let s = List.fold_right TypeSet.add univars TypeSet.empty in\n List.fold_left insert s univar_pairs\n\n(* Whether a family of univars escapes from a type *)\nlet univars_escape env univar_pairs vl ty =\n let family = get_univar_family univar_pairs vl in\n let visited = ref TypeSet.empty in\n let rec occur t =\n if TypeSet.mem t !visited then () else begin\n visited := TypeSet.add t !visited;\n match get_desc t with\n Tpoly (t, tl) ->\n if List.exists (fun t -> TypeSet.mem t family) tl then ()\n else occur t\n | Tunivar _ -> if TypeSet.mem t family then raise_escape_exn (Univ t)\n | Tconstr (_, [], _) -> ()\n | Tconstr (p, tl, _) ->\n begin try\n let td = Env.find_type p env in\n List.iter2\n (* see occur_univar *)\n (fun t v -> if not Variance.(eq v null) then occur t)\n tl td.type_variance\n with Not_found ->\n List.iter occur tl\n end\n | _ ->\n iter_type_expr occur t\n end\n in\n occur ty\n\n(* Wrapper checking that no variable escapes and updating univar_pairs *)\nlet enter_poly env univar_pairs t1 tl1 t2 tl2 f =\n let old_univars = !univar_pairs in\n let known_univars =\n List.fold_left (fun s (cl,_) -> add_univars s cl)\n TypeSet.empty old_univars\n in\n if List.exists (fun t -> TypeSet.mem t known_univars) tl1 then\n univars_escape env old_univars tl1 (newty(Tpoly(t2,tl2)));\n if List.exists (fun t -> TypeSet.mem t known_univars) tl2 then\n univars_escape env old_univars tl2 (newty(Tpoly(t1,tl1)));\n let cl1 = List.map (fun t -> t, ref None) tl1\n and cl2 = List.map (fun t -> t, ref None) tl2 in\n univar_pairs := (cl1,cl2) :: (cl2,cl1) :: old_univars;\n Misc.try_finally (fun () -> f t1 t2)\n ~always:(fun () -> univar_pairs := old_univars)\n\nlet enter_poly_for tr_exn env univar_pairs t1 tl1 t2 tl2 f =\n try\n enter_poly env univar_pairs t1 tl1 t2 tl2 f\n with Escape e -> raise_for tr_exn (Escape e)\n\nlet univar_pairs = ref []\n\n(**** Instantiate a generic type into a poly type ***)\n\nlet polyfy env ty vars =\n let subst_univar scope ty =\n match get_desc ty with\n | Tvar name when get_level ty = generic_level ->\n let t = newty (Tunivar name) in\n For_copy.redirect_desc scope ty (Tsubst (t, None));\n Some t\n | _ -> None\n in\n (* need to expand twice? cf. Ctype.unify2 *)\n let vars = List.map (expand_head env) vars in\n let vars = List.map (expand_head env) vars in\n For_copy.with_scope (fun scope ->\n let vars' = List.filter_map (subst_univar scope) vars in\n let ty = copy scope ty in\n let ty = newty2 ~level:(get_level ty) (Tpoly(ty, vars')) in\n let complete = List.length vars = List.length vars' in\n ty, complete\n )\n\n(* assumption: [ty] is fully generalized. *)\nlet reify_univars env ty =\n let vars = free_variables ty in\n let ty, _ = polyfy env ty vars in\n ty\n\n (*****************)\n (* Unification *)\n (*****************)\n\n\n\nlet rec has_cached_expansion p abbrev =\n match abbrev with\n Mnil -> false\n | Mcons(_, p', _, _, rem) -> Path.same p p' || has_cached_expansion p rem\n | Mlink rem -> has_cached_expansion p !rem\n\n(**** Transform error trace ****)\n(* +++ Move it to some other place ? *)\n(* That's hard to do because it relies on the expansion machinery in Ctype,\n but still might be nice. *)\n\nlet expand_type env ty =\n { ty = ty;\n expanded = full_expand ~may_forget_scope:true env ty }\n\nlet expand_any_trace map env trace =\n map (expand_type env) trace\n\nlet expand_trace env trace =\n expand_any_trace Errortrace.map env trace\n\nlet expand_subtype_trace env trace =\n expand_any_trace Subtype.map env trace\n\nlet expand_to_unification_error env trace =\n unification_error ~trace:(expand_trace env trace)\n\nlet expand_to_equality_error env trace subst =\n equality_error ~trace:(expand_trace env trace) ~subst\n\nlet expand_to_moregen_error env trace =\n moregen_error ~trace:(expand_trace env trace)\n\n(* [expand_trace] and the [expand_to_*_error] functions take care of most of the\n expansion in this file, but we occasionally need to build [Errortrace.error]s\n in other ways/elsewhere, so we expose some machinery for doing so\n*)\n\n(* Equivalent to [expand_trace env [Diff {got; expected}]] for a single\n element *)\nlet expanded_diff env ~got ~expected =\n Diff (map_diff (expand_type env) {got; expected})\n\n(* Diff while transforming a [type_expr] into an [expanded_type] without\n expanding *)\nlet unexpanded_diff ~got ~expected =\n Diff (map_diff trivial_expansion {got; expected})\n\n(**** Unification ****)\n\n(* Return whether [t0] occurs in [ty]. Objects are also traversed. *)\nlet deep_occur t0 ty =\n let rec occur_rec ty =\n if get_level ty >= get_level t0 && try_mark_node ty then begin\n if eq_type ty t0 then raise Occur;\n iter_type_expr occur_rec ty\n end\n in\n try\n occur_rec ty; unmark_type ty; false\n with Occur ->\n unmark_type ty; true\n\nlet gadt_equations_level = ref None\n\nlet get_gadt_equations_level () =\n match !gadt_equations_level with\n | None -> assert false\n | Some x -> x\n\n\n(* a local constraint can be added only if the rhs\n of the constraint does not contain any Tvars.\n They need to be removed using this function *)\nlet reify env t =\n let fresh_constr_scope = get_gadt_equations_level () in\n let create_fresh_constr lev name =\n let name = match name with Some s -> \"$'\"^s | _ -> \"$\" in\n let decl = new_local_type () in\n let (id, new_env) =\n Env.enter_type (get_new_abstract_name name) decl !env\n ~scope:fresh_constr_scope in\n let path = Path.Pident id in\n let t = newty2 ~level:lev (Tconstr (path,[],ref Mnil)) in\n env := new_env;\n path, t\n in\n let visited = ref TypeSet.empty in\n let rec iterator ty =\n if TypeSet.mem ty !visited then () else begin\n visited := TypeSet.add ty !visited;\n match get_desc ty with\n Tvar o ->\n let level = get_level ty in\n let path, t = create_fresh_constr level o in\n link_type ty t;\n if level < fresh_constr_scope then\n raise_for Unify (Escape (escape (Constructor path)))\n | Tvariant r ->\n if not (static_row r) then begin\n if is_fixed r then iterator (row_more r) else\n let m = row_more r in\n match get_desc m with\n Tvar o ->\n let level = get_level m in\n let path, t = create_fresh_constr level o in\n let row =\n let fixed = Some (Reified path) in\n create_row ~fields:[] ~more:t ~fixed\n ~name:(row_name r) ~closed:(row_closed r) in\n link_type m (newty2 ~level (Tvariant row));\n if level < fresh_constr_scope then\n raise_for Unify (Escape (escape (Constructor path)))\n | _ -> assert false\n end;\n iter_row iterator r\n | Tconstr (p, _, _) when is_object_type p ->\n iter_type_expr iterator (full_expand ~may_forget_scope:false !env ty)\n | _ ->\n iter_type_expr iterator ty\n end\n in\n iterator t\n\nlet is_newtype env p =\n try\n let decl = Env.find_type p env in\n decl.type_expansion_scope <> Btype.lowest_level &&\n decl.type_kind = Type_abstract &&\n decl.type_private = Public\n with Not_found -> false\n\nlet non_aliasable p decl =\n (* in_pervasives p || (subsumed by in_current_module) *)\n in_current_module p && not decl.type_is_newtype\n\nlet is_instantiable env p =\n try\n let decl = Env.find_type p env in\n decl.type_kind = Type_abstract &&\n decl.type_private = Public &&\n decl.type_arity = 0 &&\n decl.type_manifest = None &&\n not (non_aliasable p decl)\n with Not_found -> false\n\n\n(* PR#7113: -safe-string should be a global property *)\nlet compatible_paths p1 p2 =\n let open Predef in\n Path.same p1 p2 ||\n Path.same p1 path_bytes && Path.same p2 path_string ||\n Path.same p1 path_string && Path.same p2 path_bytes\n\n(* Check for datatypes carefully; see PR#6348 *)\nlet rec expands_to_datatype env ty =\n match get_desc ty with\n Tconstr (p, _, _) ->\n begin try\n is_datatype (Env.find_type p env) ||\n expands_to_datatype env (try_expand_safe env ty)\n with Not_found | Cannot_expand -> false\n end\n | _ -> false\n\n(* [mcomp] tests if two types are \"compatible\" -- i.e., if they could ever\n unify. (This is distinct from [eqtype], which checks if two types *are*\n exactly the same.) This is used to decide whether GADT cases are\n unreachable. It is broadly part of unification. *)\n\n(* mcomp type_pairs subst env t1 t2 does not raise an\n exception if it is possible that t1 and t2 are actually\n equal, assuming the types in type_pairs are equal and\n that the mapping subst holds.\n Assumes that both t1 and t2 do not contain any tvars\n and that both their objects and variants are closed\n *)\n\nlet rec mcomp type_pairs env t1 t2 =\n if eq_type t1 t2 then () else\n match (get_desc t1, get_desc t2) with\n | (Tvar _, _)\n | (_, Tvar _) ->\n ()\n | (Tconstr (p1, [], _), Tconstr (p2, [], _)) when Path.same p1 p2 ->\n ()\n | _ ->\n let t1' = expand_head_opt env t1 in\n let t2' = expand_head_opt env t2 in\n (* Expansion may have changed the representative of the types... *)\n if eq_type t1' t2' then () else\n if not (TypePairs.mem type_pairs (t1', t2')) then begin\n TypePairs.add type_pairs (t1', t2');\n match (get_desc t1', get_desc t2') with\n | (Tvar _, _)\n | (_, Tvar _) ->\n ()\n | (Tarrow (l1, t1, u1, _), Tarrow (l2, t2, u2, _))\n when l1 = l2 || not (is_optional l1 || is_optional l2) ->\n mcomp type_pairs env t1 t2;\n mcomp type_pairs env u1 u2;\n | (Ttuple tl1, Ttuple tl2) ->\n mcomp_list type_pairs env tl1 tl2\n | (Tconstr (p1, tl1, _), Tconstr (p2, tl2, _)) ->\n mcomp_type_decl type_pairs env p1 p2 tl1 tl2\n | (Tconstr (_, [], _), _) when has_injective_univars env t2' ->\n raise_unexplained_for Unify\n | (_, Tconstr (_, [], _)) when has_injective_univars env t1' ->\n raise_unexplained_for Unify\n | (Tconstr (p, _, _), _) | (_, Tconstr (p, _, _)) ->\n begin try\n let decl = Env.find_type p env in\n if non_aliasable p decl || is_datatype decl then\n raise Incompatible\n with Not_found -> ()\n end\n (*\n | (Tpackage (p1, n1, tl1), Tpackage (p2, n2, tl2)) when n1 = n2 ->\n mcomp_list type_pairs env tl1 tl2\n *)\n | (Tpackage _, Tpackage _) -> ()\n | (Tvariant row1, Tvariant row2) ->\n mcomp_row type_pairs env row1 row2\n | (Tobject (fi1, _), Tobject (fi2, _)) ->\n mcomp_fields type_pairs env fi1 fi2\n | (Tfield _, Tfield _) -> (* Actually unused *)\n mcomp_fields type_pairs env t1' t2'\n | (Tnil, Tnil) ->\n ()\n | (Tpoly (t1, []), Tpoly (t2, [])) ->\n mcomp type_pairs env t1 t2\n | (Tpoly (t1, tl1), Tpoly (t2, tl2)) ->\n (try\n enter_poly env univar_pairs\n t1 tl1 t2 tl2 (mcomp type_pairs env)\n with Escape _ -> raise Incompatible)\n | (Tunivar _, Tunivar _) ->\n (try unify_univar t1' t2' !univar_pairs\n with Cannot_unify_universal_variables -> raise Incompatible)\n | (_, _) ->\n raise Incompatible\n end\n\nand mcomp_list type_pairs env tl1 tl2 =\n if List.length tl1 <> List.length tl2 then\n raise Incompatible;\n List.iter2 (mcomp type_pairs env) tl1 tl2\n\nand mcomp_fields type_pairs env ty1 ty2 =\n if not (concrete_object ty1 && concrete_object ty2) then assert false;\n let (fields2, rest2) = flatten_fields ty2 in\n let (fields1, rest1) = flatten_fields ty1 in\n let (pairs, miss1, miss2) = associate_fields fields1 fields2 in\n let has_present =\n List.exists (fun (_, k, _) -> field_kind_repr k = Fpublic) in\n mcomp type_pairs env rest1 rest2;\n if has_present miss1 && get_desc (object_row ty2) = Tnil\n || has_present miss2 && get_desc (object_row ty1) = Tnil\n then raise Incompatible;\n List.iter\n (function (_n, k1, t1, k2, t2) ->\n mcomp_kind k1 k2;\n mcomp type_pairs env t1 t2)\n pairs\n\nand mcomp_kind k1 k2 =\n let k1 = field_kind_repr k1 in\n let k2 = field_kind_repr k2 in\n match k1, k2 with\n (Fpublic, Fabsent)\n | (Fabsent, Fpublic) -> raise Incompatible\n | _ -> ()\n\nand mcomp_row type_pairs env row1 row2 =\n let r1, r2, pairs = merge_row_fields (row_fields row1) (row_fields row2) in\n let cannot_erase (_,f) =\n match row_field_repr f with\n Rpresent _ -> true\n | Rabsent | Reither _ -> false\n in\n if row_closed row1 && List.exists cannot_erase r2\n || row_closed row2 && List.exists cannot_erase r1 then raise Incompatible;\n List.iter\n (fun (_,f1,f2) ->\n match row_field_repr f1, row_field_repr f2 with\n | Rpresent None, (Rpresent (Some _) | Reither (_, _::_, _) | Rabsent)\n | Rpresent (Some _), (Rpresent None | Reither (true, _, _) | Rabsent)\n | (Reither (_, _::_, _) | Rabsent), Rpresent None\n | (Reither (true, _, _) | Rabsent), Rpresent (Some _) ->\n raise Incompatible\n | Rpresent(Some t1), Rpresent(Some t2) ->\n mcomp type_pairs env t1 t2\n | Rpresent(Some t1), Reither(false, tl2, _) ->\n List.iter (mcomp type_pairs env t1) tl2\n | Reither(false, tl1, _), Rpresent(Some t2) ->\n List.iter (mcomp type_pairs env t2) tl1\n | _ -> ())\n pairs\n\nand mcomp_type_decl type_pairs env p1 p2 tl1 tl2 =\n try\n let decl = Env.find_type p1 env in\n let decl' = Env.find_type p2 env in\n if compatible_paths p1 p2 then begin\n let inj =\n try List.map Variance.(mem Inj) (Env.find_type p1 env).type_variance\n with Not_found -> List.map (fun _ -> false) tl1\n in\n List.iter2\n (fun i (t1,t2) -> if i then mcomp type_pairs env t1 t2)\n inj (List.combine tl1 tl2)\n end else if non_aliasable p1 decl && non_aliasable p2 decl' then\n raise Incompatible\n else\n match decl.type_kind, decl'.type_kind with\n | Type_record (lst,r), Type_record (lst',r') when r = r' ->\n mcomp_list type_pairs env tl1 tl2;\n mcomp_record_description type_pairs env lst lst'\n | Type_variant (v1,r), Type_variant (v2,r') when r = r' ->\n mcomp_list type_pairs env tl1 tl2;\n mcomp_variant_description type_pairs env v1 v2\n | Type_open, Type_open ->\n mcomp_list type_pairs env tl1 tl2\n | Type_abstract, Type_abstract -> ()\n | Type_abstract, _ when not (non_aliasable p1 decl)-> ()\n | _, Type_abstract when not (non_aliasable p2 decl') -> ()\n | _ -> raise Incompatible\n with Not_found -> ()\n\nand mcomp_type_option type_pairs env t t' =\n match t, t' with\n None, None -> ()\n | Some t, Some t' -> mcomp type_pairs env t t'\n | _ -> raise Incompatible\n\nand mcomp_variant_description type_pairs env xs ys =\n let rec iter = fun x y ->\n match x, y with\n | c1 :: xs, c2 :: ys ->\n mcomp_type_option type_pairs env c1.cd_res c2.cd_res;\n begin match c1.cd_args, c2.cd_args with\n | Cstr_tuple l1, Cstr_tuple l2 -> mcomp_list type_pairs env l1 l2\n | Cstr_record l1, Cstr_record l2 ->\n mcomp_record_description type_pairs env l1 l2\n | _ -> raise Incompatible\n end;\n if Ident.name c1.cd_id = Ident.name c2.cd_id\n then iter xs ys\n else raise Incompatible\n | [],[] -> ()\n | _ -> raise Incompatible\n in\n iter xs ys\n\nand mcomp_record_description type_pairs env =\n let rec iter x y =\n match x, y with\n | l1 :: xs, l2 :: ys ->\n mcomp type_pairs env l1.ld_type l2.ld_type;\n if Ident.name l1.ld_id = Ident.name l2.ld_id &&\n l1.ld_mutable = l2.ld_mutable\n then iter xs ys\n else raise Incompatible\n | [], [] -> ()\n | _ -> raise Incompatible\n in\n iter\n\nlet mcomp env t1 t2 =\n mcomp (TypePairs.create 4) env t1 t2\n\nlet mcomp_for tr_exn env t1 t2 =\n try\n mcomp env t1 t2\n with Incompatible -> raise_unexplained_for tr_exn\n\n(* Real unification *)\n\nlet find_lowest_level ty =\n let lowest = ref generic_level in\n let rec find ty =\n if not_marked_node ty then begin\n let level = get_level ty in\n if level < !lowest then lowest := level;\n flip_mark_node ty;\n iter_type_expr find ty\n end\n in find ty; unmark_type ty; !lowest\n\nlet find_expansion_scope env path =\n (Env.find_type path env).type_expansion_scope\n\nlet add_gadt_equation env source destination =\n (* Format.eprintf \"@[add_gadt_equation %s %a@]@.\"\n (Path.name source) !Btype.print_raw destination; *)\n if has_free_univars !env destination then\n occur_univar ~inj_only:true !env destination\n else if local_non_recursive_abbrev !env source destination then begin\n let destination = duplicate_type destination in\n let expansion_scope =\n Int.max (Path.scope source) (get_gadt_equations_level ())\n in\n let decl =\n new_local_type ~manifest_and_scope:(destination, expansion_scope) () in\n env := Env.add_local_type source decl !env;\n cleanup_abbrev ()\n end\n\nlet unify_eq_set = TypePairs.create 11\n\nlet order_type_pair t1 t2 =\n if get_id t1 <= get_id t2 then (t1, t2) else (t2, t1)\n\nlet add_type_equality t1 t2 =\n TypePairs.add unify_eq_set (order_type_pair t1 t2)\n\nlet eq_package_path env p1 p2 =\n Path.same p1 p2 ||\n Path.same (normalize_package_path env p1) (normalize_package_path env p2)\n\nlet nondep_type' = ref (fun _ _ _ -> assert false)\nlet package_subtype = ref (fun _ _ _ _ _ -> assert false)\n\nexception Nondep_cannot_erase of Ident.t\n\nlet rec concat_longident lid1 =\n let open Longident in\n function\n Lident s -> Ldot (lid1, s)\n | Ldot (lid2, s) -> Ldot (concat_longident lid1 lid2, s)\n | Lapply (lid2, lid) -> Lapply (concat_longident lid1 lid2, lid)\n\nlet nondep_instance env level id ty =\n let ty = !nondep_type' env [id] ty in\n if level = generic_level then duplicate_type ty else\n let old = !current_level in\n current_level := level;\n let ty = instance ty in\n current_level := old;\n ty\n\n(* Find the type paths nl1 in the module type mty2, and add them to the\n list (nl2, tl2). raise Not_found if impossible *)\nlet complete_type_list ?(allow_absent=false) env fl1 lv2 mty2 fl2 =\n (* This is morally WRONG: we're adding a (dummy) module without a scope in the\n environment. However no operation which cares about levels/scopes is going\n to happen while this module exists.\n The only operations that happen are:\n - Env.find_type_by_name\n - nondep_instance\n None of which check the scope.\n\n It'd be nice if we avoided creating such temporary dummy modules and broken\n environments though. *)\n let id2 = Ident.create_local \"Pkg\" in\n let env' = Env.add_module id2 Mp_present mty2 env in\n let rec complete fl1 fl2 =\n match fl1, fl2 with\n [], _ -> fl2\n | (n, _) :: nl, (n2, _ as nt2) :: ntl' when n >= n2 ->\n nt2 :: complete (if n = n2 then nl else fl1) ntl'\n | (n, _) :: nl, _ ->\n let lid = concat_longident (Longident.Lident \"Pkg\") n in\n match Env.find_type_by_name lid env' with\n | (_, {type_arity = 0; type_kind = Type_abstract;\n type_private = Public; type_manifest = Some t2}) ->\n begin match nondep_instance env' lv2 id2 t2 with\n | t -> (n, t) :: complete nl fl2\n | exception Nondep_cannot_erase _ ->\n if allow_absent then\n complete nl fl2\n else\n raise Exit\n end\n | (_, {type_arity = 0; type_kind = Type_abstract;\n type_private = Public; type_manifest = None})\n when allow_absent ->\n complete nl fl2\n | _ -> raise Exit\n | exception Not_found when allow_absent->\n complete nl fl2\n in\n match complete fl1 fl2 with\n | res -> res\n | exception Exit -> raise Not_found\n\n(* raise Not_found rather than Unify if the module types are incompatible *)\nlet unify_package env unify_list lv1 p1 fl1 lv2 p2 fl2 =\n let ntl2 = complete_type_list env fl1 lv2 (Mty_ident p2) fl2\n and ntl1 = complete_type_list env fl2 lv1 (Mty_ident p1) fl1 in\n unify_list (List.map snd ntl1) (List.map snd ntl2);\n if eq_package_path env p1 p2\n || !package_subtype env p1 fl1 p2 fl2\n && !package_subtype env p2 fl2 p1 fl1 then () else raise Not_found\n\n\n(* force unification in Reither when one side has a non-conjunctive type *)\nlet rigid_variants = ref false\n\nlet unify_eq t1 t2 =\n eq_type t1 t2 ||\n match !umode with\n | Expression -> false\n | Pattern ->\n TypePairs.mem unify_eq_set (order_type_pair t1 t2)\n\nlet unify1_var env t1 t2 =\n assert (is_Tvar t1);\n occur_for Unify env t1 t2;\n match occur_univar_for Unify env t2 with\n | () ->\n begin\n try\n update_level env (get_level t1) t2;\n update_scope (get_scope t1) t2;\n with Escape e ->\n raise_for Unify (Escape e)\n end;\n link_type t1 t2;\n true\n | exception Unify_trace _ when !umode = Pattern ->\n false\n\n(* Can only be called when generate_equations is true *)\nlet record_equation t1 t2 =\n match !equations_generation with\n | Forbidden -> assert false\n | Allowed { equated_types } ->\n TypePairs.add equated_types (t1, t2)\n\n(* Called from unify3 *)\nlet unify3_var env t1' t2 t2' =\n occur_for Unify !env t1' t2;\n match occur_univar_for Unify !env t2 with\n | () -> link_type t1' t2\n | exception Unify_trace _ when !umode = Pattern ->\n reify env t1';\n reify env t2';\n if can_generate_equations () then begin\n occur_univar ~inj_only:true !env t2';\n record_equation t1' t2';\n end\n\n(*\n 1. When unifying two non-abbreviated types, one type is made a link\n to the other. When unifying an abbreviated type with a\n non-abbreviated type, the non-abbreviated type is made a link to\n the other one. When unifying to abbreviated types, these two\n types are kept distincts, but they are made to (temporally)\n expand to the same type.\n 2. Abbreviations with at least one parameter are systematically\n expanded. The overhead does not seem too high, and that way\n abbreviations where some parameters does not appear in the\n expansion, such as ['a t = int], are correctly handled. In\n particular, for this example, unifying ['a t] with ['b t] keeps\n ['a] and ['b] distincts. (Is it really important ?)\n 3. Unifying an abbreviation ['a t = 'a] with ['a] should not yield\n ['a t as 'a]. Indeed, the type variable would otherwise be lost.\n This problem occurs for abbreviations expanding to a type\n variable, but also to many other constrained abbreviations (for\n instance, [(< x : 'a > -> unit) t = ]). The solution is\n that, if an abbreviation is unified with some subpart of its\n parameters, then the parameter actually does not get\n abbreviated. It would be possible to check whether some\n information is indeed lost, but it probably does not worth it.\n*)\n\nlet rec unify (env:Env.t ref) t1 t2 =\n (* First step: special cases (optimizations) *)\n if unify_eq t1 t2 then () else\n let reset_tracing = check_trace_gadt_instances !env in\n\n try\n type_changed := true;\n begin match (get_desc t1, get_desc t2) with\n (Tvar _, Tconstr _) when deep_occur t1 t2 ->\n unify2 env t1 t2\n | (Tconstr _, Tvar _) when deep_occur t2 t1 ->\n unify2 env t1 t2\n | (Tvar _, _) ->\n if unify1_var !env t1 t2 then () else unify2 env t1 t2\n | (_, Tvar _) ->\n if unify1_var !env t2 t1 then () else unify2 env t1 t2\n | (Tunivar _, Tunivar _) ->\n unify_univar_for Unify t1 t2 !univar_pairs;\n update_level_for Unify !env (get_level t1) t2;\n update_scope_for Unify (get_scope t1) t2;\n link_type t1 t2\n | (Tconstr (p1, [], a1), Tconstr (p2, [], a2))\n when Path.same p1 p2 (* && actual_mode !env = Old *)\n (* This optimization assumes that t1 does not expand to t2\n (and conversely), so we fall back to the general case\n when any of the types has a cached expansion. *)\n && not (has_cached_expansion p1 !a1\n || has_cached_expansion p2 !a2) ->\n update_level_for Unify !env (get_level t1) t2;\n update_scope_for Unify (get_scope t1) t2;\n link_type t1 t2\n | (Tconstr (p1, [], _), Tconstr (p2, [], _))\n when Env.has_local_constraints !env\n && is_newtype !env p1 && is_newtype !env p2 ->\n (* Do not use local constraints more than necessary *)\n begin try\n if find_expansion_scope !env p1 > find_expansion_scope !env p2 then\n unify env t1 (try_expand_safe !env t2)\n else\n unify env (try_expand_safe !env t1) t2\n with Cannot_expand ->\n unify2 env t1 t2\n end\n | _ ->\n unify2 env t1 t2\n end;\n reset_trace_gadt_instances reset_tracing;\n with Unify_trace trace ->\n reset_trace_gadt_instances reset_tracing;\n raise_trace_for Unify (Diff {got = t1; expected = t2} :: trace)\n\nand unify2 env t1 t2 =\n (* Second step: expansion of abbreviations *)\n (* Expansion may change the representative of the types. *)\n ignore (expand_head_unif !env t1);\n ignore (expand_head_unif !env t2);\n let t1' = expand_head_unif !env t1 in\n let t2' = expand_head_unif !env t2 in\n let lv = Int.min (get_level t1') (get_level t2') in\n let scope = Int.max (get_scope t1') (get_scope t2') in\n update_level_for Unify !env lv t2;\n update_level_for Unify !env lv t1;\n update_scope_for Unify scope t2;\n update_scope_for Unify scope t1;\n if unify_eq t1' t2' then () else\n\n let t1, t2 =\n if !Clflags.principal\n && (find_lowest_level t1' < lv || find_lowest_level t2' < lv) then\n (* Expand abbreviations hiding a lower level *)\n (* Should also do it for parameterized types, after unification... *)\n (match get_desc t1 with Tconstr (_, [], _) -> t1' | _ -> t1),\n (match get_desc t2 with Tconstr (_, [], _) -> t2' | _ -> t2)\n else (t1, t2)\n in\n if unify_eq t1 t1' || not (unify_eq t2 t2') then\n unify3 env t1 t1' t2 t2'\n else\n try unify3 env t2 t2' t1 t1' with Unify_trace trace ->\n raise_trace_for Unify (swap_trace trace)\n\nand unify3 env t1 t1' t2 t2' =\n (* Third step: truly unification *)\n (* Assumes either [t1 == t1'] or [t2 != t2'] *)\n let tt1' = Transient_expr.repr t1' in\n let d1 = tt1'.desc and d2 = get_desc t2' in\n let create_recursion =\n (not (eq_type t2 t2')) && (deep_occur t1' t2) in\n\n begin match (d1, d2) with (* handle vars and univars specially *)\n (Tunivar _, Tunivar _) ->\n unify_univar_for Unify t1' t2' !univar_pairs;\n link_type t1' t2'\n | (Tvar _, _) ->\n unify3_var env t1' t2 t2'\n | (_, Tvar _) ->\n unify3_var env t2' t1 t1'\n | (Tfield _, Tfield _) -> (* special case for GADTs *)\n unify_fields env t1' t2'\n | _ ->\n begin match !umode with\n | Expression ->\n occur_for Unify !env t1' t2;\n link_type t1' t2\n | Pattern ->\n add_type_equality t1' t2'\n end;\n try\n begin match (d1, d2) with\n (Tarrow (l1, t1, u1, c1), Tarrow (l2, t2, u2, c2)) when l1 = l2 ||\n (!Clflags.classic || !umode = Pattern) &&\n not (is_optional l1 || is_optional l2) ->\n unify env t1 t2; unify env u1 u2;\n begin match is_commu_ok c1, is_commu_ok c2 with\n | false, true -> set_commu_ok c1\n | true, false -> set_commu_ok c2\n | false, false -> link_commu ~inside:c1 c2\n | true, true -> ()\n end\n | (Ttuple tl1, Ttuple tl2) ->\n unify_list env tl1 tl2\n | (Tconstr (p1, tl1, _), Tconstr (p2, tl2, _)) when Path.same p1 p2 ->\n if !umode = Expression || !equations_generation = Forbidden then\n unify_list env tl1 tl2\n else if !assume_injective then\n set_mode_pattern ~generate:!equations_generation ~injective:false\n ~allow_recursive:!allow_recursive_equation\n (fun () -> unify_list env tl1 tl2)\n else if in_current_module p1 (* || in_pervasives p1 *)\n || List.exists (expands_to_datatype !env) [t1'; t1; t2]\n then\n unify_list env tl1 tl2\n else\n let inj =\n try List.map Variance.(mem Inj)\n (Env.find_type p1 !env).type_variance\n with Not_found -> List.map (fun _ -> false) tl1\n in\n List.iter2\n (fun i (t1, t2) ->\n if i then unify env t1 t2 else\n set_mode_pattern ~generate:Forbidden ~injective:false\n ~allow_recursive:!allow_recursive_equation\n begin fun () ->\n let snap = snapshot () in\n try unify env t1 t2 with Unify_trace _ ->\n backtrack snap;\n reify env t1;\n reify env t2\n end)\n inj (List.combine tl1 tl2)\n | (Tconstr (path,[],_),\n Tconstr (path',[],_))\n when is_instantiable !env path && is_instantiable !env path'\n && can_generate_equations () ->\n let source, destination =\n if Path.scope path > Path.scope path'\n then path , t2'\n else path', t1'\n in\n record_equation t1' t2';\n add_gadt_equation env source destination\n | (Tconstr (path,[],_), _)\n when is_instantiable !env path && can_generate_equations () ->\n reify env t2';\n record_equation t1' t2';\n add_gadt_equation env path t2'\n | (_, Tconstr (path,[],_))\n when is_instantiable !env path && can_generate_equations () ->\n reify env t1';\n record_equation t1' t2';\n add_gadt_equation env path t1'\n | (Tconstr (_,_,_), _) | (_, Tconstr (_,_,_)) when !umode = Pattern ->\n reify env t1';\n reify env t2';\n if can_generate_equations () then (\n mcomp_for Unify !env t1' t2';\n record_equation t1' t2'\n )\n | (Tobject (fi1, nm1), Tobject (fi2, _)) ->\n unify_fields env fi1 fi2;\n (* Type [t2'] may have been instantiated by [unify_fields] *)\n (* XXX One should do some kind of unification... *)\n begin match get_desc t2' with\n Tobject (_, {contents = Some (_, va::_)}) when\n (match get_desc va with\n Tvar _|Tunivar _|Tnil -> true | _ -> false) -> ()\n | Tobject (_, nm2) -> set_name nm2 !nm1\n | _ -> ()\n end\n | (Tvariant row1, Tvariant row2) ->\n if !umode = Expression then\n unify_row env row1 row2\n else begin\n let snap = snapshot () in\n try unify_row env row1 row2\n with Unify_trace _ ->\n backtrack snap;\n reify env t1';\n reify env t2';\n if can_generate_equations () then (\n mcomp_for Unify !env t1' t2';\n record_equation t1' t2'\n )\n end\n | (Tfield(f,kind,_,rem), Tnil) | (Tnil, Tfield(f,kind,_,rem)) ->\n begin match field_kind_repr kind with\n Fprivate when f <> dummy_method ->\n link_kind ~inside:kind field_absent;\n if d2 = Tnil then unify env rem t2'\n else unify env (newgenty Tnil) rem\n | _ ->\n if f = dummy_method then\n raise_for Unify (Obj Self_cannot_be_closed)\n else if d1 = Tnil then\n raise_for Unify (Obj (Missing_field(First, f)))\n else\n raise_for Unify (Obj (Missing_field(Second, f)))\n end\n | (Tnil, Tnil) ->\n ()\n | (Tpoly (t1, []), Tpoly (t2, [])) ->\n unify env t1 t2\n | (Tpoly (t1, tl1), Tpoly (t2, tl2)) ->\n enter_poly_for Unify !env univar_pairs t1 tl1 t2 tl2 (unify env)\n | (Tpackage (p1, fl1), Tpackage (p2, fl2)) ->\n begin try\n unify_package !env (unify_list env)\n (get_level t1) p1 fl1 (get_level t2) p2 fl2\n with Not_found ->\n if !umode = Expression then raise_unexplained_for Unify;\n List.iter (fun (_n, ty) -> reify env ty) (fl1 @ fl2);\n (* if !generate_equations then List.iter2 (mcomp !env) tl1 tl2 *)\n end\n | (Tnil, Tconstr _ ) ->\n raise_for Unify (Obj (Abstract_row Second))\n | (Tconstr _, Tnil ) ->\n raise_for Unify (Obj (Abstract_row First))\n | (_, _) -> raise_unexplained_for Unify\n end;\n (* XXX Commentaires + changer \"create_recursion\"\n ||| Comments + change \"create_recursion\" *)\n if create_recursion then\n match get_desc t2 with\n Tconstr (p, tl, abbrev) ->\n forget_abbrev abbrev p;\n let t2'' = expand_head_unif !env t2 in\n if not (closed_parameterized_type tl t2'') then\n link_type t2 t2'\n | _ ->\n () (* t2 has already been expanded by update_level *)\n with Unify_trace trace ->\n Transient_expr.set_desc tt1' d1;\n raise_trace_for Unify trace\n end\n\nand unify_list env tl1 tl2 =\n if List.length tl1 <> List.length tl2 then\n raise_unexplained_for Unify;\n List.iter2 (unify env) tl1 tl2\n\n(* Build a fresh row variable for unification *)\nand make_rowvar level use1 rest1 use2 rest2 =\n let set_name ty name =\n match get_desc ty with\n Tvar None -> set_type_desc ty (Tvar name)\n | _ -> ()\n in\n let name =\n match get_desc rest1, get_desc rest2 with\n Tvar (Some _ as name1), Tvar (Some _ as name2) ->\n if get_level rest1 <= get_level rest2 then name1 else name2\n | Tvar (Some _ as name), _ ->\n if use2 then set_name rest2 name; name\n | _, Tvar (Some _ as name) ->\n if use1 then set_name rest2 name; name\n | _ -> None\n in\n if use1 then rest1 else\n if use2 then rest2 else newty2 ~level (Tvar name)\n\nand unify_fields env ty1 ty2 = (* Optimization *)\n let (fields1, rest1) = flatten_fields ty1\n and (fields2, rest2) = flatten_fields ty2 in\n let (pairs, miss1, miss2) = associate_fields fields1 fields2 in\n let l1 = get_level ty1 and l2 = get_level ty2 in\n let va = make_rowvar (Int.min l1 l2) (miss2=[]) rest1 (miss1=[]) rest2 in\n let tr1 = Transient_expr.repr rest1 and tr2 = Transient_expr.repr rest2 in\n let d1 = tr1.desc and d2 = tr2.desc in\n try\n unify env (build_fields l1 miss1 va) rest2;\n unify env rest1 (build_fields l2 miss2 va);\n List.iter\n (fun (name, k1, t1, k2, t2) ->\n unify_kind k1 k2;\n try\n if !trace_gadt_instances then begin\n update_level_for Unify !env (get_level va) t1;\n update_scope_for Unify (get_scope va) t1\n end;\n unify env t1 t2\n with Unify_trace trace ->\n raise_trace_for Unify\n (incompatible_fields ~name ~got:t1 ~expected:t2 :: trace)\n )\n pairs\n with exn ->\n Transient_expr.set_desc tr1 d1;\n Transient_expr.set_desc tr2 d2;\n raise exn\n\nand unify_kind k1 k2 =\n match field_kind_repr k1, field_kind_repr k2 with\n (Fprivate, (Fprivate | Fpublic)) -> link_kind ~inside:k1 k2\n | (Fpublic, Fprivate) -> link_kind ~inside:k2 k1\n | (Fpublic, Fpublic) -> ()\n | _ -> assert false\n\nand unify_row env row1 row2 =\n let Row {fields = row1_fields; more = rm1;\n closed = row1_closed; name = row1_name} = row_repr row1 in\n let Row {fields = row2_fields; more = rm2;\n closed = row2_closed; name = row2_name} = row_repr row2 in\n if unify_eq rm1 rm2 then () else\n let r1, r2, pairs = merge_row_fields row1_fields row2_fields in\n if r1 <> [] && r2 <> [] then begin\n let ht = Hashtbl.create (List.length r1) in\n List.iter (fun (l,_) -> Hashtbl.add ht (hash_variant l) l) r1;\n List.iter\n (fun (l,_) ->\n try raise (Tags(l, Hashtbl.find ht (hash_variant l)))\n with Not_found -> ())\n r2\n end;\n let fixed1 = fixed_explanation row1 and fixed2 = fixed_explanation row2 in\n let more = match fixed1, fixed2 with\n | Some _, Some _ -> if get_level rm2 < get_level rm1 then rm2 else rm1\n | Some _, None -> rm1\n | None, Some _ -> rm2\n | None, None ->\n newty2 ~level:(Int.min (get_level rm1) (get_level rm2)) (Tvar None)\n in\n let fixed = merge_fixed_explanation fixed1 fixed2\n and closed = row1_closed || row2_closed in\n let keep switch =\n List.for_all\n (fun (_,f1,f2) ->\n let f1, f2 = switch f1 f2 in\n row_field_repr f1 = Rabsent || row_field_repr f2 <> Rabsent)\n pairs\n in\n let empty fields =\n List.for_all (fun (_,f) -> row_field_repr f = Rabsent) fields in\n (* Check whether we are going to build an empty type *)\n if closed && (empty r1 || row2_closed) && (empty r2 || row1_closed)\n && List.for_all\n (fun (_,f1,f2) ->\n row_field_repr f1 = Rabsent || row_field_repr f2 = Rabsent)\n pairs\n then raise_for Unify (Variant No_intersection);\n let name =\n if row1_name <> None && (row1_closed || empty r2) &&\n (not row2_closed || keep (fun f1 f2 -> f1, f2) && empty r1)\n then row1_name\n else if row2_name <> None && (row2_closed || empty r1) &&\n (not row1_closed || keep (fun f1 f2 -> f2, f1) && empty r2)\n then row2_name\n else None\n in\n let set_more pos row rest =\n let rest =\n if closed then\n filter_row_fields (row_closed row) rest\n else rest in\n begin match fixed_explanation row with\n | None ->\n if rest <> [] && row_closed row then\n raise_for Unify (Variant (No_tags(pos,rest)))\n | Some fixed ->\n if closed && not (row_closed row) then\n raise_for Unify (Variant (Fixed_row(pos,Cannot_be_closed,fixed)))\n else if rest <> [] then\n let case = Cannot_add_tags (List.map fst rest) in\n raise_for Unify (Variant (Fixed_row(pos,case,fixed)))\n end;\n (* The following test is not principal... should rather use Tnil *)\n let rm = row_more row in\n (*if !trace_gadt_instances && rm.desc = Tnil then () else*)\n if !trace_gadt_instances then\n update_level_for Unify !env (get_level rm) (newgenty (Tvariant row));\n if has_fixed_explanation row then\n if eq_type more rm then () else\n if is_Tvar rm then link_type rm more else unify env rm more\n else\n let ty =\n newgenty (Tvariant\n (create_row ~fields:rest ~more ~closed ~fixed ~name))\n in\n update_level_for Unify !env (get_level rm) ty;\n update_scope_for Unify (get_scope rm) ty;\n link_type rm ty\n in\n let tm1 = Transient_expr.repr rm1 and tm2 = Transient_expr.repr rm2 in\n let md1 = tm1.desc and md2 = tm2.desc in\n begin try\n set_more Second row2 r1;\n set_more First row1 r2;\n List.iter\n (fun (l,f1,f2) ->\n try unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2\n with Unify_trace trace ->\n raise_trace_for Unify (Variant (Incompatible_types_for l) :: trace)\n )\n pairs;\n if static_row row1 then begin\n let rm = row_more row1 in\n if is_Tvar rm then link_type rm (newty2 ~level:(get_level rm) Tnil)\n end\n with exn ->\n Transient_expr.set_desc tm1 md1;\n Transient_expr.set_desc tm2 md2;\n raise exn\n end\n\nand unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 =\n let if_not_fixed (pos,fixed) f =\n match fixed with\n | None -> f ()\n | Some fix ->\n let tr = [Variant(Fixed_row(pos,Cannot_add_tags [l],fix))] in\n raise_trace_for Unify tr in\n let first = First, fixed1 and second = Second, fixed2 in\n let either_fixed = match fixed1, fixed2 with\n | None, None -> false\n | _ -> true in\n if f1 == f2 then () else\n match row_field_repr f1, row_field_repr f2 with\n Rpresent(Some t1), Rpresent(Some t2) -> unify env t1 t2\n | Rpresent None, Rpresent None -> ()\n | Reither(c1, tl1, m1), Reither(c2, tl2, m2) ->\n if eq_row_field_ext f1 f2 then () else\n let no_arg = c1 || c2 and matched = m1 || m2 in\n if either_fixed && not no_arg\n && List.length tl1 = List.length tl2 then begin\n (* PR#7496 *)\n let f = rf_either [] ~no_arg ~matched in\n link_row_field_ext ~inside:f1 f; link_row_field_ext ~inside:f2 f;\n List.iter2 (unify env) tl1 tl2\n end\n else let redo =\n (m1 || m2 || either_fixed ||\n !rigid_variants && (List.length tl1 = 1 || List.length tl2 = 1)) &&\n begin match tl1 @ tl2 with [] -> false\n | t1 :: tl ->\n if no_arg then raise_unexplained_for Unify;\n Types.changed_row_field_exts [f1;f2] (fun () ->\n List.iter (unify env t1) tl\n )\n end in\n if redo then unify_row_field env fixed1 fixed2 rm1 rm2 l f1 f2 else\n let remq tl =\n List.filter (fun ty -> not (List.exists (eq_type ty) tl)) in\n let tl1' = remq tl2 tl1 and tl2' = remq tl1 tl2 in\n (* PR#6744 *)\n let (tlu1,tl1') = List.partition (has_free_univars !env) tl1'\n and (tlu2,tl2') = List.partition (has_free_univars !env) tl2' in\n begin match tlu1, tlu2 with\n [], [] -> ()\n | (tu1::tlu1), _ :: _ ->\n (* Attempt to merge all the types containing univars *)\n List.iter (unify env tu1) (tlu1@tlu2)\n | (tu::_, []) | ([], tu::_) ->\n occur_univar_for Unify !env tu\n end;\n (* Is this handling of levels really principal? *)\n let update_levels rm =\n List.iter\n (fun ty ->\n update_level_for Unify !env (get_level rm) ty;\n update_scope_for Unify (get_scope rm) ty)\n in\n update_levels rm2 tl1';\n update_levels rm1 tl2';\n let f1' = rf_either tl2' ~no_arg ~matched in\n let f2' = rf_either tl1' ~use_ext_of:f1' ~no_arg ~matched in\n link_row_field_ext ~inside:f1 f1'; link_row_field_ext ~inside:f2 f2';\n | Reither(_, _, false), Rabsent ->\n if_not_fixed first (fun () -> link_row_field_ext ~inside:f1 f2)\n | Rabsent, Reither(_, _, false) ->\n if_not_fixed second (fun () -> link_row_field_ext ~inside:f2 f1)\n | Rabsent, Rabsent -> ()\n | Reither(false, tl, _), Rpresent(Some t2) ->\n if_not_fixed first (fun () ->\n let s = snapshot () in\n link_row_field_ext ~inside:f1 f2;\n update_level_for Unify !env (get_level rm1) t2;\n update_scope_for Unify (get_scope rm1) t2;\n (try List.iter (fun t1 -> unify env t1 t2) tl\n with exn -> undo_first_change_after s; raise exn)\n )\n | Rpresent(Some t1), Reither(false, tl, _) ->\n if_not_fixed second (fun () ->\n let s = snapshot () in\n link_row_field_ext ~inside:f2 f1;\n update_level_for Unify !env (get_level rm2) t1;\n update_scope_for Unify (get_scope rm2) t1;\n (try List.iter (unify env t1) tl\n with exn -> undo_first_change_after s; raise exn)\n )\n | Reither(true, [], _), Rpresent None ->\n if_not_fixed first (fun () -> link_row_field_ext ~inside:f1 f2)\n | Rpresent None, Reither(true, [], _) ->\n if_not_fixed second (fun () -> link_row_field_ext ~inside:f2 f1)\n | _ -> raise_unexplained_for Unify\n\nlet unify env ty1 ty2 =\n let snap = Btype.snapshot () in\n try\n unify env ty1 ty2\n with\n Unify_trace trace ->\n undo_compress snap;\n raise (Unify (expand_to_unification_error !env trace))\n\nlet unify_gadt ~equations_level:lev ~allow_recursive (env:Env.t ref) ty1 ty2 =\n try\n univar_pairs := [];\n gadt_equations_level := Some lev;\n let equated_types = TypePairs.create 0 in\n set_mode_pattern\n ~generate:(Allowed { equated_types })\n ~injective:true\n ~allow_recursive\n (fun () -> unify env ty1 ty2);\n gadt_equations_level := None;\n TypePairs.clear unify_eq_set;\n equated_types\n with e ->\n gadt_equations_level := None;\n TypePairs.clear unify_eq_set;\n raise e\n\nlet unify_var env t1 t2 =\n if eq_type t1 t2 then () else\n match get_desc t1, get_desc t2 with\n Tvar _, Tconstr _ when deep_occur t1 t2 ->\n unify (ref env) t1 t2\n | Tvar _, _ ->\n let reset_tracing = check_trace_gadt_instances env in\n begin try\n occur_for Unify env t1 t2;\n update_level_for Unify env (get_level t1) t2;\n update_scope_for Unify (get_scope t1) t2;\n link_type t1 t2;\n reset_trace_gadt_instances reset_tracing;\n with Unify_trace trace ->\n reset_trace_gadt_instances reset_tracing;\n raise (Unify (expand_to_unification_error\n env\n (Diff { got = t1; expected = t2 } :: trace)))\n end\n | _ ->\n unify (ref env) t1 t2\n\nlet _ = unify_var' := unify_var\n\nlet unify_pairs env ty1 ty2 pairs =\n univar_pairs := pairs;\n unify env ty1 ty2\n\nlet unify env ty1 ty2 =\n unify_pairs (ref env) ty1 ty2 []\n\n\n\n(**** Special cases of unification ****)\n\nlet expand_head_trace env t =\n let reset_tracing = check_trace_gadt_instances env in\n let t = expand_head_unif env t in\n reset_trace_gadt_instances reset_tracing;\n t\n\n(*\n Unify [t] and [l:'a -> 'b]. Return ['a] and ['b].\n In [-nolabels] mode, label mismatch is accepted when\n (1) the requested label is \"\"\n (2) the original label is not optional\n*)\n\ntype filter_arrow_failure =\n | Unification_error of unification_error\n | Label_mismatch of\n { got : arg_label\n ; expected : arg_label\n ; expected_type : type_expr\n }\n | Not_a_function\n\nexception Filter_arrow_failed of filter_arrow_failure\n\nlet filter_arrow env t l =\n let function_type level =\n let t1 = newvar2 level and t2 = newvar2 level in\n let t' = newty2 ~level (Tarrow (l, t1, t2, commu_ok)) in\n t', t1, t2\n in\n let t =\n try expand_head_trace env t\n with Unify_trace trace ->\n let t', _, _ = function_type (get_level t) in\n raise (Filter_arrow_failed\n (Unification_error\n (expand_to_unification_error\n env\n (Diff { got = t'; expected = t } :: trace))))\n in\n match get_desc t with\n | Tvar _ ->\n let t', t1, t2 = function_type (get_level t) in\n link_type t t';\n (t1, t2)\n | Tarrow(l', t1, t2, _) ->\n if l = l' || !Clflags.classic && l = Nolabel && not (is_optional l')\n then (t1, t2)\n else raise (Filter_arrow_failed\n (Label_mismatch\n { got = l; expected = l'; expected_type = t }))\n | _ ->\n raise (Filter_arrow_failed Not_a_function)\n\ntype filter_method_failure =\n | Unification_error of unification_error\n | Not_a_method\n | Not_an_object of type_expr\n\nexception Filter_method_failed of filter_method_failure\n\n(* Used by [filter_method]. *)\nlet rec filter_method_field env name ty =\n let method_type ~level =\n let ty1 = newvar2 level and ty2 = newvar2 level in\n let ty' = newty2 ~level (Tfield (name, field_public, ty1, ty2)) in\n ty', ty1\n in\n let ty =\n try expand_head_trace env ty\n with Unify_trace trace ->\n let level = get_level ty in\n let ty', _ = method_type ~level in\n raise (Filter_method_failed\n (Unification_error\n (expand_to_unification_error\n env\n (Diff { got = ty; expected = ty' } :: trace))))\n in\n match get_desc ty with\n | Tvar _ ->\n let level = get_level ty in\n let ty', ty1 = method_type ~level in\n link_type ty ty';\n ty1\n | Tfield(n, kind, ty1, ty2) ->\n if n = name then begin\n unify_kind kind field_public;\n ty1\n end else\n filter_method_field env name ty2\n | _ ->\n raise (Filter_method_failed Not_a_method)\n\n(* Unify [ty] and [< name : 'a; .. >]. Return ['a]. *)\nlet filter_method env name ty =\n let object_type ~level ~scope =\n let ty1 = newvar2 level in\n let ty' = newty3 ~level ~scope (Tobject (ty1, ref None)) in\n let ty_meth = filter_method_field env name ty1 in\n (ty', ty_meth)\n in\n let ty =\n try expand_head_trace env ty\n with Unify_trace trace ->\n let level = get_level ty in\n let scope = get_scope ty in\n let ty', _ = object_type ~level ~scope in\n raise (Filter_method_failed\n (Unification_error\n (expand_to_unification_error\n env\n (Diff { got = ty; expected = ty' } :: trace))))\n in\n match get_desc ty with\n | Tvar _ ->\n let level = get_level ty in\n let scope = get_scope ty in\n let ty', ty_meth = object_type ~level ~scope in\n link_type ty ty';\n ty_meth\n | Tobject(f, _) ->\n filter_method_field env name f\n | _ ->\n raise (Filter_method_failed (Not_an_object ty))\n\nexception Filter_method_row_failed\n\nlet rec filter_method_row env name priv ty =\n let ty = expand_head env ty in\n match get_desc ty with\n | Tvar _ ->\n let level = get_level ty in\n let field = newvar2 level in\n let row = newvar2 level in\n let kind, priv =\n match priv with\n | Private ->\n let kind = field_private () in\n kind, Mprivate kind\n | Public ->\n field_public, Mpublic\n in\n let ty' = newty2 ~level (Tfield (name, kind, field, row)) in\n link_type ty ty';\n priv, field, row\n | Tfield(n, kind, ty1, ty2) ->\n if n = name then begin\n let priv =\n match priv with\n | Public ->\n unify_kind kind field_public;\n Mpublic\n | Private -> Mprivate kind\n in\n priv, ty1, ty2\n end else begin\n let level = get_level ty in\n let priv, field, row = filter_method_row env name priv ty2 in\n let row = newty2 ~level (Tfield (n, kind, ty1, row)) in\n priv, field, row\n end\n | Tnil ->\n if name = Btype.dummy_method then raise Filter_method_row_failed\n else begin\n match priv with\n | Public -> raise Filter_method_row_failed\n | Private ->\n let level = get_level ty in\n let kind = field_absent in\n Mprivate kind, newvar2 level, ty\n end\n | _ ->\n raise Filter_method_row_failed\n\n(* Operations on class signatures *)\n\nlet new_class_signature () =\n let row = newvar () in\n let self = newobj row in\n { csig_self = self;\n csig_self_row = row;\n csig_vars = Vars.empty;\n csig_meths = Meths.empty; }\n\nlet add_dummy_method env ~scope sign =\n let _, ty, row =\n filter_method_row env dummy_method Private sign.csig_self_row\n in\n unify env ty (new_scoped_ty scope (Ttuple []));\n sign.csig_self_row <- row\n\ntype add_method_failure =\n | Unexpected_method\n | Type_mismatch of Errortrace.unification_error\n\nexception Add_method_failed of add_method_failure\n\nlet add_method env label priv virt ty sign =\n let meths = sign.csig_meths in\n let priv, virt =\n match Meths.find label meths with\n | (priv', virt', ty') -> begin\n let priv =\n match priv' with\n | Mpublic -> Mpublic\n | Mprivate k ->\n match priv with\n | Public ->\n begin match field_kind_repr k with\n | Fpublic -> ()\n | Fprivate -> link_kind ~inside:k field_public\n | Fabsent -> assert false\n end;\n Mpublic\n | Private -> priv'\n in\n let virt =\n match virt' with\n | Concrete -> Concrete\n | Virtual -> virt\n in\n match unify env ty ty' with\n | () -> priv, virt\n | exception Unify trace ->\n raise (Add_method_failed (Type_mismatch trace))\n end\n | exception Not_found -> begin\n let priv, ty', row =\n match filter_method_row env label priv sign.csig_self_row with\n | priv, ty', row ->\n priv, ty', row\n | exception Filter_method_row_failed ->\n raise (Add_method_failed Unexpected_method)\n in\n match unify env ty ty' with\n | () ->\n sign.csig_self_row <- row;\n priv, virt\n | exception Unify trace ->\n raise (Add_method_failed (Type_mismatch trace))\n end\n in\n let meths = Meths.add label (priv, virt, ty) meths in\n sign.csig_meths <- meths\n\ntype add_instance_variable_failure =\n | Mutability_mismatch of mutable_flag\n | Type_mismatch of Errortrace.unification_error\n\nexception Add_instance_variable_failed of add_instance_variable_failure\n\nlet check_mutability mut mut' =\n match mut, mut' with\n | Mutable, Mutable -> ()\n | Immutable, Immutable -> ()\n | Mutable, Immutable | Immutable, Mutable ->\n raise (Add_instance_variable_failed (Mutability_mismatch mut))\n\nlet add_instance_variable ~strict env label mut virt ty sign =\n let vars = sign.csig_vars in\n let virt =\n match Vars.find label vars with\n | (mut', virt', ty') ->\n let virt =\n match virt' with\n | Concrete -> Concrete\n | Virtual -> virt\n in\n if strict then begin\n check_mutability mut mut';\n match unify env ty ty' with\n | () -> ()\n | exception Unify trace ->\n raise (Add_instance_variable_failed (Type_mismatch trace))\n end;\n virt\n | exception Not_found -> virt\n in\n let vars = Vars.add label (mut, virt, ty) vars in\n sign.csig_vars <- vars\n\ntype inherit_class_signature_failure =\n | Self_type_mismatch of Errortrace.unification_error\n | Method of label * add_method_failure\n | Instance_variable of label * add_instance_variable_failure\n\nexception Inherit_class_signature_failed of inherit_class_signature_failure\n\nlet unify_self_types env sign1 sign2 =\n let self_type1 = sign1.csig_self in\n let self_type2 = sign2.csig_self in\n match unify env self_type1 self_type2 with\n | () -> ()\n | exception Unify err -> begin\n match err.trace with\n | Errortrace.Diff _ :: Errortrace.Incompatible_fields {name; _} :: rem ->\n let err = Errortrace.unification_error ~trace:rem in\n let failure = Method (name, Type_mismatch err) in\n raise (Inherit_class_signature_failed failure)\n | _ ->\n raise (Inherit_class_signature_failed (Self_type_mismatch err))\n end\n\n(* Unify components of sign2 into sign1 *)\nlet inherit_class_signature ~strict env sign1 sign2 =\n unify_self_types env sign1 sign2;\n Meths.iter\n (fun label (priv, virt, ty) ->\n let priv =\n match priv with\n | Mpublic -> Public\n | Mprivate kind ->\n assert (field_kind_repr kind = Fabsent);\n Private\n in\n match add_method env label priv virt ty sign1 with\n | () -> ()\n | exception Add_method_failed failure ->\n let failure = Method(label, failure) in\n raise (Inherit_class_signature_failed failure))\n sign2.csig_meths;\n Vars.iter\n (fun label (mut, virt, ty) ->\n match add_instance_variable ~strict env label mut virt ty sign1 with\n | () -> ()\n | exception Add_instance_variable_failed failure ->\n let failure = Instance_variable(label, failure) in\n raise (Inherit_class_signature_failed failure))\n sign2.csig_vars\n\nlet update_class_signature env sign =\n let self = expand_head env sign.Types.csig_self in\n let fields, row = flatten_fields (object_fields self) in\n let meths, implicitly_public, implicitly_declared =\n List.fold_left\n (fun (meths, implicitly_public, implicitly_declared) (lab, k, ty) ->\n if lab = dummy_method then\n meths, implicitly_public, implicitly_declared\n else begin\n match Meths.find lab meths with\n | priv, virt, ty' ->\n let meths, implicitly_public =\n match priv, field_kind_repr k with\n | Mpublic, _ -> meths, implicitly_public\n | Mprivate _, Fpublic ->\n let meths = Meths.add lab (Mpublic, virt, ty') meths in\n let implicitly_public = lab :: implicitly_public in\n meths, implicitly_public\n | Mprivate _, _ -> meths, implicitly_public\n in\n meths, implicitly_public, implicitly_declared\n | exception Not_found ->\n let meths, implicitly_declared =\n match field_kind_repr k with\n | Fpublic ->\n let meths = Meths.add lab (Mpublic, Virtual, ty) meths in\n let implicitly_declared = lab :: implicitly_declared in\n meths, implicitly_declared\n | Fprivate ->\n let meths =\n Meths.add lab (Mprivate k, Virtual, ty) meths\n in\n let implicitly_declared = lab :: implicitly_declared in\n meths, implicitly_declared\n | Fabsent -> meths, implicitly_declared\n in\n meths, implicitly_public, implicitly_declared\n end)\n (sign.csig_meths, [], []) fields\n in\n sign.csig_meths <- meths;\n sign.csig_self_row <- row;\n implicitly_public, implicitly_declared\n\nlet hide_private_methods env sign =\n let self = expand_head env sign.Types.csig_self in\n let fields, _ = flatten_fields (object_fields self) in\n List.iter\n (fun (_, k, _) ->\n match field_kind_repr k with\n | Fprivate -> link_kind ~inside:k field_absent\n | _ -> ())\n fields\n\nlet close_class_signature env sign =\n let rec close env ty =\n let ty = expand_head env ty in\n match get_desc ty with\n | Tvar _ ->\n let level = get_level ty in\n link_type ty (newty2 ~level Tnil); true\n | Tfield(lab, _, _, _) when lab = dummy_method ->\n false\n | Tfield(_, _, _, ty') -> close env ty'\n | Tnil -> true\n | _ -> assert false\n in\n let self = expand_head env sign.csig_self in\n close env (object_fields self)\n\nlet generalize_class_signature_spine env sign =\n (* Generalize the spine of methods *)\n let meths = sign.csig_meths in\n Meths.iter (fun _ (_, _, ty) -> generalize_spine ty) meths;\n let new_meths =\n Meths.map\n (fun (priv, virt, ty) -> (priv, virt, generic_instance ty))\n meths\n in\n (* But keep levels correct on the type of self *)\n Meths.iter\n (fun _ (_, _, ty) -> unify_var env (newvar ()) ty)\n meths;\n sign.csig_meths <- new_meths\n\n (***********************************)\n (* Matching between type schemes *)\n (***********************************)\n\n(*\n Update the level of [ty]. First check that the levels of generic\n variables from the subject are not lowered.\n*)\nlet moregen_occur env level ty =\n let rec occur ty =\n let lv = get_level ty in\n if lv <= level then () else\n if is_Tvar ty && lv >= generic_level - 1 then raise Occur else\n if try_mark_node ty then iter_type_expr occur ty\n in\n begin try\n occur ty; unmark_type ty\n with Occur ->\n unmark_type ty; raise_unexplained_for Moregen\n end;\n (* also check for free univars *)\n occur_univar_for Moregen env ty;\n update_level_for Moregen env level ty\n\nlet may_instantiate inst_nongen t1 =\n let level = get_level t1 in\n if inst_nongen then level <> generic_level - 1\n else level = generic_level\n\nlet rec moregen inst_nongen type_pairs env t1 t2 =\n if eq_type t1 t2 then () else\n\n try\n match (get_desc t1, get_desc t2) with\n (Tvar _, _) when may_instantiate inst_nongen t1 ->\n moregen_occur env (get_level t1) t2;\n update_scope_for Moregen (get_scope t1) t2;\n occur_for Moregen env t1 t2;\n link_type t1 t2\n | (Tconstr (p1, [], _), Tconstr (p2, [], _)) when Path.same p1 p2 ->\n ()\n | _ ->\n let t1' = expand_head env t1 in\n let t2' = expand_head env t2 in\n (* Expansion may have changed the representative of the types... *)\n if eq_type t1' t2' then () else\n if not (TypePairs.mem type_pairs (t1', t2')) then begin\n TypePairs.add type_pairs (t1', t2');\n match (get_desc t1', get_desc t2') with\n (Tvar _, _) when may_instantiate inst_nongen t1' ->\n moregen_occur env (get_level t1') t2;\n update_scope_for Moregen (get_scope t1') t2;\n link_type t1' t2\n | (Tarrow (l1, t1, u1, _), Tarrow (l2, t2, u2, _)) when l1 = l2\n || !Clflags.classic && not (is_optional l1 || is_optional l2) ->\n moregen inst_nongen type_pairs env t1 t2;\n moregen inst_nongen type_pairs env u1 u2\n | (Ttuple tl1, Ttuple tl2) ->\n moregen_list inst_nongen type_pairs env tl1 tl2\n | (Tconstr (p1, tl1, _), Tconstr (p2, tl2, _))\n when Path.same p1 p2 ->\n moregen_list inst_nongen type_pairs env tl1 tl2\n | (Tpackage (p1, fl1), Tpackage (p2, fl2)) ->\n begin try\n unify_package env (moregen_list inst_nongen type_pairs env)\n (get_level t1') p1 fl1 (get_level t2') p2 fl2\n with Not_found -> raise_unexplained_for Moregen\n end\n | (Tnil, Tconstr _ ) -> raise_for Moregen (Obj (Abstract_row Second))\n | (Tconstr _, Tnil ) -> raise_for Moregen (Obj (Abstract_row First))\n | (Tvariant row1, Tvariant row2) ->\n moregen_row inst_nongen type_pairs env row1 row2\n | (Tobject (fi1, _nm1), Tobject (fi2, _nm2)) ->\n moregen_fields inst_nongen type_pairs env fi1 fi2\n | (Tfield _, Tfield _) -> (* Actually unused *)\n moregen_fields inst_nongen type_pairs env\n t1' t2'\n | (Tnil, Tnil) ->\n ()\n | (Tpoly (t1, []), Tpoly (t2, [])) ->\n moregen inst_nongen type_pairs env t1 t2\n | (Tpoly (t1, tl1), Tpoly (t2, tl2)) ->\n enter_poly_for Moregen env univar_pairs t1 tl1 t2 tl2\n (moregen inst_nongen type_pairs env)\n | (Tunivar _, Tunivar _) ->\n unify_univar_for Moregen t1' t2' !univar_pairs\n | (_, _) ->\n raise_unexplained_for Moregen\n end\n with Moregen_trace trace ->\n raise_trace_for Moregen (Diff {got = t1; expected = t2} :: trace)\n\n\nand moregen_list inst_nongen type_pairs env tl1 tl2 =\n if List.length tl1 <> List.length tl2 then\n raise_unexplained_for Moregen;\n List.iter2 (moregen inst_nongen type_pairs env) tl1 tl2\n\nand moregen_fields inst_nongen type_pairs env ty1 ty2 =\n let (fields1, rest1) = flatten_fields ty1\n and (fields2, rest2) = flatten_fields ty2 in\n let (pairs, miss1, miss2) = associate_fields fields1 fields2 in\n begin\n match miss1 with\n | (n, _, _) :: _ -> raise_for Moregen (Obj (Missing_field (Second, n)))\n | [] -> ()\n end;\n moregen inst_nongen type_pairs env rest1\n (build_fields (get_level ty2) miss2 rest2);\n List.iter\n (fun (name, k1, t1, k2, t2) ->\n (* The below call should never throw [Public_method_to_private_method] *)\n moregen_kind k1 k2;\n try moregen inst_nongen type_pairs env t1 t2 with Moregen_trace trace ->\n raise_trace_for Moregen\n (incompatible_fields ~name ~got:t1 ~expected:t2 :: trace)\n )\n pairs\n\nand moregen_kind k1 k2 =\n match field_kind_repr k1, field_kind_repr k2 with\n (Fprivate, (Fprivate | Fpublic)) -> link_kind ~inside:k1 k2\n | (Fpublic, Fpublic) -> ()\n | (Fpublic, Fprivate) -> raise Public_method_to_private_method\n | (Fabsent, _) | (_, Fabsent) -> assert false\n\nand moregen_row inst_nongen type_pairs env row1 row2 =\n let Row {fields = row1_fields; more = rm1; closed = row1_closed} =\n row_repr row1 in\n let Row {fields = row2_fields; more = rm2; closed = row2_closed;\n fixed = row2_fixed} = row_repr row2 in\n if eq_type rm1 rm2 then () else\n let may_inst =\n is_Tvar rm1 && may_instantiate inst_nongen rm1 || get_desc rm1 = Tnil in\n let r1, r2, pairs = merge_row_fields row1_fields row2_fields in\n let r1, r2 =\n if row2_closed then\n filter_row_fields may_inst r1, filter_row_fields false r2\n else r1, r2\n in\n begin\n if r1 <> [] then raise_for Moregen (Variant (No_tags (Second, r1)))\n end;\n if row1_closed then begin\n match row2_closed, r2 with\n | false, _ -> raise_for Moregen (Variant (Openness Second))\n | _, _ :: _ -> raise_for Moregen (Variant (No_tags (First, r2)))\n | _, [] -> ()\n end;\n let md1 = get_desc rm1 (* This lets us undo a following [link_type] *) in\n begin match md1, get_desc rm2 with\n Tunivar _, Tunivar _ ->\n unify_univar_for Moregen rm1 rm2 !univar_pairs\n | Tunivar _, _ | _, Tunivar _ ->\n raise_unexplained_for Moregen\n | _ when static_row row1 -> ()\n | _ when may_inst ->\n let ext =\n newgenty (Tvariant\n (create_row ~fields:r2 ~more:rm2 ~name:None\n ~fixed:row2_fixed ~closed:row2_closed))\n in\n moregen_occur env (get_level rm1) ext;\n update_scope_for Moregen (get_scope rm1) ext;\n (* This [link_type] has to be undone if the rest of the function fails *)\n link_type rm1 ext\n | Tconstr _, Tconstr _ ->\n moregen inst_nongen type_pairs env rm1 rm2\n | _ -> raise_unexplained_for Moregen\n end;\n try\n List.iter\n (fun (l,f1,f2) ->\n if f1 == f2 then () else\n match row_field_repr f1, row_field_repr f2 with\n (* Both matching [Rpresent]s *)\n | Rpresent(Some t1), Rpresent(Some t2) -> begin\n try\n moregen inst_nongen type_pairs env t1 t2\n with Moregen_trace trace ->\n raise_trace_for Moregen\n (Variant (Incompatible_types_for l) :: trace)\n end\n | Rpresent None, Rpresent None -> ()\n (* Both [Reither] *)\n | Reither(c1, tl1, _), Reither(c2, tl2, m2) -> begin\n try\n if not (eq_row_field_ext f1 f2) then begin\n if c1 && not c2 then raise_unexplained_for Moregen;\n let f2' =\n rf_either [] ~use_ext_of:f2 ~no_arg:c2 ~matched:m2 in\n link_row_field_ext ~inside:f1 f2';\n if List.length tl1 = List.length tl2 then\n List.iter2 (moregen inst_nongen type_pairs env) tl1 tl2\n else match tl2 with\n | t2 :: _ ->\n List.iter\n (fun t1 -> moregen inst_nongen type_pairs env t1 t2)\n tl1\n | [] -> if tl1 <> [] then raise_unexplained_for Moregen\n end\n with Moregen_trace trace ->\n raise_trace_for Moregen\n (Variant (Incompatible_types_for l) :: trace)\n end\n (* Generalizing [Reither] *)\n | Reither(false, tl1, _), Rpresent(Some t2) when may_inst -> begin\n try\n link_row_field_ext ~inside:f1 f2;\n List.iter\n (fun t1 -> moregen inst_nongen type_pairs env t1 t2)\n tl1\n with Moregen_trace trace ->\n raise_trace_for Moregen\n (Variant (Incompatible_types_for l) :: trace)\n end\n | Reither(true, [], _), Rpresent None when may_inst ->\n link_row_field_ext ~inside:f1 f2\n | Reither(_, _, _), Rabsent when may_inst ->\n link_row_field_ext ~inside:f1 f2\n (* Both [Rabsent]s *)\n | Rabsent, Rabsent -> ()\n (* Mismatched constructor arguments *)\n | Rpresent (Some _), Rpresent None\n | Rpresent None, Rpresent (Some _) ->\n raise_for Moregen (Variant (Incompatible_types_for l))\n (* Mismatched presence *)\n | Reither _, Rpresent _ ->\n raise_for Moregen\n (Variant (Presence_not_guaranteed_for (First, l)))\n | Rpresent _, Reither _ ->\n raise_for Moregen\n (Variant (Presence_not_guaranteed_for (Second, l)))\n (* Missing tags *)\n | Rabsent, (Rpresent _ | Reither _) ->\n raise_for Moregen (Variant (No_tags (First, [l, f2])))\n | (Rpresent _ | Reither _), Rabsent ->\n raise_for Moregen (Variant (No_tags (Second, [l, f1]))))\n pairs\n with exn ->\n (* Undo [link_type] if we failed *)\n set_type_desc rm1 md1; raise exn\n\n(* Must empty univar_pairs first *)\nlet moregen inst_nongen type_pairs env patt subj =\n univar_pairs := [];\n moregen inst_nongen type_pairs env patt subj\n\n(*\n Non-generic variable can be instantiated only if [inst_nongen] is\n true. So, [inst_nongen] should be set to false if the subject might\n contain non-generic variables (and we do not want them to be\n instantiated).\n Usually, the subject is given by the user, and the pattern\n is unimportant. So, no need to propagate abbreviations.\n*)\nlet moregeneral env inst_nongen pat_sch subj_sch =\n let old_level = !current_level in\n current_level := generic_level - 1;\n (*\n Generic variables are first duplicated with [instance]. So,\n their levels are lowered to [generic_level - 1]. The subject is\n then copied with [duplicate_type]. That way, its levels won't be\n changed.\n *)\n let subj_inst = instance subj_sch in\n let subj = duplicate_type subj_inst in\n current_level := generic_level;\n (* Duplicate generic variables *)\n let patt = instance pat_sch in\n\n Misc.try_finally\n (fun () ->\n try\n moregen inst_nongen (TypePairs.create 13) env patt subj\n with Moregen_trace trace ->\n (* Moregen splits the generic level into two finer levels:\n [generic_level] and [generic_level - 1]. In order to properly\n detect and print weak variables when printing this error, we need to\n merge them back together, by regeneralizing the levels of the types\n after they were instantiated at [generic_level - 1] above. Because\n [moregen] does some unification that we need to preserve for more\n legible error messages, we have to manually perform the\n regeneralization rather than backtracking. *)\n current_level := generic_level - 2;\n generalize subj_inst;\n raise (Moregen (expand_to_moregen_error env trace)))\n ~always:(fun () -> current_level := old_level)\n\nlet is_moregeneral env inst_nongen pat_sch subj_sch =\n match moregeneral env inst_nongen pat_sch subj_sch with\n | () -> true\n | exception Moregen _ -> false\n\n(* Alternative approach: \"rigidify\" a type scheme,\n and check validity after unification *)\n(* Simpler, no? *)\n\nlet rec rigidify_rec vars ty =\n if try_mark_node ty then\n begin match get_desc ty with\n | Tvar _ ->\n if not (TypeSet.mem ty !vars) then vars := TypeSet.add ty !vars\n | Tvariant row ->\n let Row {more; name; closed} = row_repr row in\n if is_Tvar more && not (has_fixed_explanation row) then begin\n let more' = newty2 ~level:(get_level more) (get_desc more) in\n let row' =\n create_row ~fixed:(Some Rigid) ~fields:[] ~more:more'\n ~name ~closed\n in link_type more (newty2 ~level:(get_level ty) (Tvariant row'))\n end;\n iter_row (rigidify_rec vars) row;\n (* only consider the row variable if the variant is not static *)\n if not (static_row row) then\n rigidify_rec vars (row_more row)\n | _ ->\n iter_type_expr (rigidify_rec vars) ty\n end\n\nlet rigidify ty =\n let vars = ref TypeSet.empty in\n rigidify_rec vars ty;\n unmark_type ty;\n TypeSet.elements !vars\n\nlet all_distinct_vars env vars =\n let tys = ref TypeSet.empty in\n List.for_all\n (fun ty ->\n let ty = expand_head env ty in\n if TypeSet.mem ty !tys then false else\n (tys := TypeSet.add ty !tys; is_Tvar ty))\n vars\n\nlet matches ~expand_error_trace env ty ty' =\n let snap = snapshot () in\n let vars = rigidify ty in\n cleanup_abbrev ();\n match unify env ty ty' with\n | () ->\n if not (all_distinct_vars env vars) then begin\n backtrack snap;\n let diff =\n if expand_error_trace\n then expanded_diff env ~got:ty ~expected:ty'\n else unexpanded_diff ~got:ty ~expected:ty'\n in\n raise (Matches_failure (env, unification_error ~trace:[diff]))\n end;\n backtrack snap\n | exception Unify err ->\n backtrack snap;\n raise (Matches_failure (env, err))\n\nlet does_match env ty ty' =\n match matches ~expand_error_trace:false env ty ty' with\n | () -> true\n | exception Matches_failure (_, _) -> false\n\n (*********************************************)\n (* Equivalence between parameterized types *)\n (*********************************************)\n\nlet expand_head_rigid env ty =\n let old = !rigid_variants in\n rigid_variants := true;\n let ty' = expand_head env ty in\n rigid_variants := old; ty'\n\nlet eqtype_subst type_pairs subst t1 t2 =\n if List.exists\n (fun (t,t') ->\n let found1 = eq_type t1 t in\n let found2 = eq_type t2 t' in\n if found1 && found2 then true else\n if found1 || found2 then raise_unexplained_for Equality else false)\n !subst\n then ()\n else begin\n subst := (t1, t2) :: !subst;\n TypePairs.add type_pairs (t1, t2)\n end\n\nlet rec eqtype rename type_pairs subst env t1 t2 =\n if eq_type t1 t2 then () else\n\n try\n match (get_desc t1, get_desc t2) with\n (Tvar _, Tvar _) when rename ->\n eqtype_subst type_pairs subst t1 t2\n | (Tconstr (p1, [], _), Tconstr (p2, [], _)) when Path.same p1 p2 ->\n ()\n | _ ->\n let t1' = expand_head_rigid env t1 in\n let t2' = expand_head_rigid env t2 in\n (* Expansion may have changed the representative of the types... *)\n if eq_type t1' t2' then () else\n if not (TypePairs.mem type_pairs (t1', t2')) then begin\n TypePairs.add type_pairs (t1', t2');\n match (get_desc t1', get_desc t2') with\n (Tvar _, Tvar _) when rename ->\n eqtype_subst type_pairs subst t1' t2'\n | (Tarrow (l1, t1, u1, _), Tarrow (l2, t2, u2, _)) when l1 = l2\n || !Clflags.classic && not (is_optional l1 || is_optional l2) ->\n eqtype rename type_pairs subst env t1 t2;\n eqtype rename type_pairs subst env u1 u2;\n | (Ttuple tl1, Ttuple tl2) ->\n eqtype_list rename type_pairs subst env tl1 tl2\n | (Tconstr (p1, tl1, _), Tconstr (p2, tl2, _))\n when Path.same p1 p2 ->\n eqtype_list rename type_pairs subst env tl1 tl2\n | (Tpackage (p1, fl1), Tpackage (p2, fl2)) ->\n begin try\n unify_package env (eqtype_list rename type_pairs subst env)\n (get_level t1') p1 fl1 (get_level t2') p2 fl2\n with Not_found -> raise_unexplained_for Equality\n end\n | (Tnil, Tconstr _ ) ->\n raise_for Equality (Obj (Abstract_row Second))\n | (Tconstr _, Tnil ) ->\n raise_for Equality (Obj (Abstract_row First))\n | (Tvariant row1, Tvariant row2) ->\n eqtype_row rename type_pairs subst env row1 row2\n | (Tobject (fi1, _nm1), Tobject (fi2, _nm2)) ->\n eqtype_fields rename type_pairs subst env fi1 fi2\n | (Tfield _, Tfield _) -> (* Actually unused *)\n eqtype_fields rename type_pairs subst env\n t1' t2'\n | (Tnil, Tnil) ->\n ()\n | (Tpoly (t1, []), Tpoly (t2, [])) ->\n eqtype rename type_pairs subst env t1 t2\n | (Tpoly (t1, tl1), Tpoly (t2, tl2)) ->\n enter_poly_for Equality env univar_pairs t1 tl1 t2 tl2\n (eqtype rename type_pairs subst env)\n | (Tunivar _, Tunivar _) ->\n unify_univar_for Equality t1' t2' !univar_pairs\n | (_, _) ->\n raise_unexplained_for Equality\n end\n with Equality_trace trace ->\n raise_trace_for Equality (Diff {got = t1; expected = t2} :: trace)\n\nand eqtype_list rename type_pairs subst env tl1 tl2 =\n if List.length tl1 <> List.length tl2 then\n raise_unexplained_for Equality;\n List.iter2 (eqtype rename type_pairs subst env) tl1 tl2\n\nand eqtype_fields rename type_pairs subst env ty1 ty2 =\n let (fields1, rest1) = flatten_fields ty1 in\n let (fields2, rest2) = flatten_fields ty2 in\n (* First check if same row => already equal *)\n let same_row =\n eq_type rest1 rest2 || TypePairs.mem type_pairs (rest1,rest2)\n in\n if same_row then () else\n (* Try expansion, needed when called from Includecore.type_manifest *)\n match get_desc (expand_head_rigid env rest2) with\n Tobject(ty2,_) -> eqtype_fields rename type_pairs subst env ty1 ty2\n | _ ->\n let (pairs, miss1, miss2) = associate_fields fields1 fields2 in\n eqtype rename type_pairs subst env rest1 rest2;\n match miss1, miss2 with\n | ((n, _, _)::_, _) -> raise_for Equality (Obj (Missing_field (Second, n)))\n | (_, (n, _, _)::_) -> raise_for Equality (Obj (Missing_field (First, n)))\n | [], [] ->\n List.iter\n (function (name, k1, t1, k2, t2) ->\n eqtype_kind k1 k2;\n try\n eqtype rename type_pairs subst env t1 t2;\n with Equality_trace trace ->\n raise_trace_for Equality\n (incompatible_fields ~name ~got:t1 ~expected:t2 :: trace))\n pairs\n\nand eqtype_kind k1 k2 =\n let k1 = field_kind_repr k1 in\n let k2 = field_kind_repr k2 in\n match k1, k2 with\n | (Fprivate, Fprivate)\n | (Fpublic, Fpublic) -> ()\n | _ -> raise_unexplained_for Unify\n (* It's probably not possible to hit this case with\n real OCaml code *)\n\nand eqtype_row rename type_pairs subst env row1 row2 =\n (* Try expansion, needed when called from Includecore.type_manifest *)\n match get_desc (expand_head_rigid env (row_more row2)) with\n Tvariant row2 -> eqtype_row rename type_pairs subst env row1 row2\n | _ ->\n let r1, r2, pairs = merge_row_fields (row_fields row1) (row_fields row2) in\n if row_closed row1 <> row_closed row2 then begin\n raise_for Equality\n (Variant (Openness (if row_closed row2 then First else Second)))\n end;\n if not (row_closed row1) then begin\n match r1, r2 with\n | _::_, _ -> raise_for Equality (Variant (No_tags (Second, r1)))\n | _, _::_ -> raise_for Equality (Variant (No_tags (First, r2)))\n | _, _ -> ()\n end;\n begin\n match filter_row_fields false r1 with\n | [] -> ();\n | _ :: _ as r1 -> raise_for Equality (Variant (No_tags (Second, r1)))\n end;\n begin\n match filter_row_fields false r2 with\n | [] -> ()\n | _ :: _ as r2 -> raise_for Equality (Variant (No_tags (First, r2)))\n end;\n if not (static_row row1) then\n eqtype rename type_pairs subst env (row_more row1) (row_more row2);\n List.iter\n (fun (l,f1,f2) ->\n if f1 == f2 then () else\n match row_field_repr f1, row_field_repr f2 with\n (* Both matching [Rpresent]s *)\n | Rpresent(Some t1), Rpresent(Some t2) -> begin\n try\n eqtype rename type_pairs subst env t1 t2\n with Equality_trace trace ->\n raise_trace_for Equality\n (Variant (Incompatible_types_for l) :: trace)\n end\n | Rpresent None, Rpresent None -> ()\n (* Both matching [Reither]s *)\n | Reither(c1, [], _), Reither(c2, [], _) when c1 = c2 -> ()\n | Reither(c1, t1::tl1, _), Reither(c2, t2::tl2, _)\n when c1 = c2 -> begin\n try\n eqtype rename type_pairs subst env t1 t2;\n if List.length tl1 = List.length tl2 then\n (* if same length allow different types (meaning?) *)\n List.iter2 (eqtype rename type_pairs subst env) tl1 tl2\n else begin\n (* otherwise everything must be equal *)\n List.iter (eqtype rename type_pairs subst env t1) tl2;\n List.iter\n (fun t1 -> eqtype rename type_pairs subst env t1 t2) tl1\n end\n with Equality_trace trace ->\n raise_trace_for Equality\n (Variant (Incompatible_types_for l) :: trace)\n end\n (* Both [Rabsent]s *)\n | Rabsent, Rabsent -> ()\n (* Mismatched constructor arguments *)\n | Rpresent (Some _), Rpresent None\n | Rpresent None, Rpresent (Some _)\n | Reither _, Reither _ ->\n raise_for Equality (Variant (Incompatible_types_for l))\n (* Mismatched presence *)\n | Reither _, Rpresent _ ->\n raise_for Equality\n (Variant (Presence_not_guaranteed_for (First, l)))\n | Rpresent _, Reither _ ->\n raise_for Equality\n (Variant (Presence_not_guaranteed_for (Second, l)))\n (* Missing tags *)\n | Rabsent, (Rpresent _ | Reither _) ->\n raise_for Equality (Variant (No_tags (First, [l, f2])))\n | (Rpresent _ | Reither _), Rabsent ->\n raise_for Equality (Variant (No_tags (Second, [l, f1]))))\n pairs\n\n(* Must empty univar_pairs first *)\nlet eqtype_list rename type_pairs subst env tl1 tl2 =\n univar_pairs := [];\n let snap = Btype.snapshot () in\n Misc.try_finally\n ~always:(fun () -> backtrack snap)\n (fun () -> eqtype_list rename type_pairs subst env tl1 tl2)\n\nlet eqtype rename type_pairs subst env t1 t2 =\n eqtype_list rename type_pairs subst env [t1] [t2]\n\n(* Two modes: with or without renaming of variables *)\nlet equal env rename tyl1 tyl2 =\n let subst = ref [] in\n try eqtype_list rename (TypePairs.create 11) subst env tyl1 tyl2\n with Equality_trace trace ->\n raise (Equality (expand_to_equality_error env trace !subst))\n\nlet is_equal env rename tyl1 tyl2 =\n match equal env rename tyl1 tyl2 with\n | () -> true\n | exception Equality _ -> false\n\nlet rec equal_private env params1 ty1 params2 ty2 =\n match equal env true (params1 @ [ty1]) (params2 @ [ty2]) with\n | () -> ()\n | exception (Equality _ as err) ->\n match try_expand_safe_opt env (expand_head env ty1) with\n | ty1' -> equal_private env params1 ty1' params2 ty2\n | exception Cannot_expand -> raise err\n\n (*************************)\n (* Class type matching *)\n (*************************)\n\ntype class_match_failure =\n CM_Virtual_class\n | CM_Parameter_arity_mismatch of int * int\n | CM_Type_parameter_mismatch of Env.t * equality_error\n | CM_Class_type_mismatch of Env.t * class_type * class_type\n | CM_Parameter_mismatch of Env.t * moregen_error\n | CM_Val_type_mismatch of string * Env.t * comparison_error\n | CM_Meth_type_mismatch of string * Env.t * comparison_error\n | CM_Non_mutable_value of string\n | CM_Non_concrete_value of string\n | CM_Missing_value of string\n | CM_Missing_method of string\n | CM_Hide_public of string\n | CM_Hide_virtual of string * string\n | CM_Public_method of string\n | CM_Private_method of string\n | CM_Virtual_method of string\n\nexception Failure of class_match_failure list\n\nlet match_class_sig_shape ~strict sign1 sign2 =\n let errors =\n Meths.fold\n (fun lab (priv, vr, _) err ->\n match Meths.find lab sign1.csig_meths with\n | exception Not_found -> CM_Missing_method lab::err\n | (priv', vr', _) ->\n match priv', priv with\n | Mpublic, Mprivate _ -> CM_Public_method lab::err\n | Mprivate _, Mpublic when strict -> CM_Private_method lab::err\n | _, _ ->\n match vr', vr with\n | Virtual, Concrete -> CM_Virtual_method lab::err\n | _, _ -> err)\n sign2.csig_meths []\n in\n let errors =\n Meths.fold\n (fun lab (priv, vr, _) err ->\n if Meths.mem lab sign2.csig_meths then err\n else begin\n let err =\n match priv with\n | Mpublic -> CM_Hide_public lab :: err\n | Mprivate _ -> err\n in\n match vr with\n | Virtual -> CM_Hide_virtual (\"method\", lab) :: err\n | Concrete -> err\n end)\n sign1.csig_meths errors\n in\n let errors =\n Vars.fold\n (fun lab (mut, vr, _) err ->\n match Vars.find lab sign1.csig_vars with\n | exception Not_found -> CM_Missing_value lab::err\n | (mut', vr', _) ->\n match mut', mut with\n | Immutable, Mutable -> CM_Non_mutable_value lab::err\n | _, _ ->\n match vr', vr with\n | Virtual, Concrete -> CM_Non_concrete_value lab::err\n | _, _ -> err)\n sign2.csig_vars errors\n in\n Vars.fold\n (fun lab (_,vr,_) err ->\n if vr = Virtual && not (Vars.mem lab sign2.csig_vars) then\n CM_Hide_virtual (\"instance variable\", lab) :: err\n else err)\n sign1.csig_vars errors\n\nlet rec moregen_clty trace type_pairs env cty1 cty2 =\n try\n match cty1, cty2 with\n | Cty_constr (_, _, cty1), _ ->\n moregen_clty true type_pairs env cty1 cty2\n | _, Cty_constr (_, _, cty2) ->\n moregen_clty true type_pairs env cty1 cty2\n | Cty_arrow (l1, ty1, cty1'), Cty_arrow (l2, ty2, cty2') when l1 = l2 ->\n begin\n try moregen true type_pairs env ty1 ty2 with Moregen_trace trace ->\n raise (Failure [\n CM_Parameter_mismatch (env, expand_to_moregen_error env trace)])\n end;\n moregen_clty false type_pairs env cty1' cty2'\n | Cty_signature sign1, Cty_signature sign2 ->\n Meths.iter\n (fun lab (_, _, ty) ->\n match Meths.find lab sign1.csig_meths with\n | exception Not_found ->\n (* This function is only called after checking that\n all methods in sign2 are present in sign1. *)\n assert false\n | (_, _, ty') ->\n match moregen true type_pairs env ty' ty with\n | () -> ()\n | exception Moregen_trace trace ->\n raise (Failure [\n CM_Meth_type_mismatch\n (lab,\n env,\n Moregen_error\n (expand_to_moregen_error env trace))]))\n sign2.csig_meths;\n Vars.iter\n (fun lab (_, _, ty) ->\n match Vars.find lab sign1.csig_vars with\n | exception Not_found ->\n (* This function is only called after checking that\n all instance variables in sign2 are present in sign1. *)\n assert false\n | (_, _, ty') ->\n match moregen true type_pairs env ty' ty with\n | () -> ()\n | exception Moregen_trace trace ->\n raise (Failure [\n CM_Val_type_mismatch\n (lab,\n env,\n Moregen_error\n (expand_to_moregen_error env trace))]))\n sign2.csig_vars\n | _ ->\n raise (Failure [])\n with\n Failure error when trace || error = [] ->\n raise (Failure (CM_Class_type_mismatch (env, cty1, cty2)::error))\n\nlet match_class_types ?(trace=true) env pat_sch subj_sch =\n let sign1 = signature_of_class_type pat_sch in\n let sign2 = signature_of_class_type subj_sch in\n let errors = match_class_sig_shape ~strict:false sign1 sign2 in\n match errors with\n | [] ->\n let old_level = !current_level in\n current_level := generic_level - 1;\n (*\n Generic variables are first duplicated with [instance]. So,\n their levels are lowered to [generic_level - 1]. The subject is\n then copied with [duplicate_type]. That way, its levels won't be\n changed.\n *)\n let (_, subj_inst) = instance_class [] subj_sch in\n let subj = duplicate_class_type subj_inst in\n current_level := generic_level;\n (* Duplicate generic variables *)\n let (_, patt) = instance_class [] pat_sch in\n let type_pairs = TypePairs.create 53 in\n let sign1 = signature_of_class_type patt in\n let sign2 = signature_of_class_type subj in\n let self1 = sign1.csig_self in\n let self2 = sign2.csig_self in\n let row1 = sign1.csig_self_row in\n let row2 = sign2.csig_self_row in\n TypePairs.add type_pairs (self1, self2);\n (* Always succeeds *)\n moregen true type_pairs env row1 row2;\n let res =\n match moregen_clty trace type_pairs env patt subj with\n | () -> []\n | exception Failure res ->\n (* We've found an error. Moregen splits the generic level into two\n finer levels: [generic_level] and [generic_level - 1]. In order\n to properly detect and print weak variables when printing this\n error, we need to merge them back together, by regeneralizing the\n levels of the types after they were instantiated at\n [generic_level - 1] above. Because [moregen] does some\n unification that we need to preserve for more legible error\n messages, we have to manually perform the regeneralization rather\n than backtracking. *)\n current_level := generic_level - 2;\n generalize_class_type subj_inst;\n res\n in\n current_level := old_level;\n res\n | errors ->\n CM_Class_type_mismatch (env, pat_sch, subj_sch) :: errors\n\nlet equal_clsig trace type_pairs subst env sign1 sign2 =\n try\n Meths.iter\n (fun lab (_, _, ty) ->\n match Meths.find lab sign1.csig_meths with\n | exception Not_found ->\n (* This function is only called after checking that\n all methods in sign2 are present in sign1. *)\n assert false\n | (_, _, ty') ->\n match eqtype true type_pairs subst env ty' ty with\n | () -> ()\n | exception Equality_trace trace ->\n raise (Failure [\n CM_Meth_type_mismatch\n (lab,\n env,\n Equality_error\n (expand_to_equality_error env trace !subst))]))\n sign2.csig_meths;\n Vars.iter\n (fun lab (_, _, ty) ->\n match Vars.find lab sign1.csig_vars with\n | exception Not_found ->\n (* This function is only called after checking that\n all instance variables in sign2 are present in sign1. *)\n assert false\n | (_, _, ty') ->\n match eqtype true type_pairs subst env ty' ty with\n | () -> ()\n | exception Equality_trace trace ->\n raise (Failure [\n CM_Val_type_mismatch\n (lab,\n env,\n Equality_error\n (expand_to_equality_error env trace !subst))]))\n sign2.csig_vars\n with\n Failure error when trace ->\n raise (Failure (CM_Class_type_mismatch\n (env, Cty_signature sign1, Cty_signature sign2)::error))\n\nlet match_class_declarations env patt_params patt_type subj_params subj_type =\n let sign1 = signature_of_class_type patt_type in\n let sign2 = signature_of_class_type subj_type in\n let errors = match_class_sig_shape ~strict:true sign1 sign2 in\n match errors with\n | [] -> begin\n try\n let subst = ref [] in\n let type_pairs = TypePairs.create 53 in\n let self1 = sign1.csig_self in\n let self2 = sign2.csig_self in\n let row1 = sign1.csig_self_row in\n let row2 = sign2.csig_self_row in\n TypePairs.add type_pairs (self1, self2);\n (* Always succeeds *)\n eqtype true type_pairs subst env row1 row2;\n let lp = List.length patt_params in\n let ls = List.length subj_params in\n if lp <> ls then\n raise (Failure [CM_Parameter_arity_mismatch (lp, ls)]);\n List.iter2 (fun p s ->\n try eqtype true type_pairs subst env p s with Equality_trace trace ->\n raise (Failure\n [CM_Type_parameter_mismatch\n (env, expand_to_equality_error env trace !subst)]))\n patt_params subj_params;\n (* old code: equal_clty false type_pairs subst env patt_type subj_type; *)\n equal_clsig false type_pairs subst env sign1 sign2;\n (* Use moregeneral for class parameters, need to recheck everything to\n keeps relationships (PR#4824) *)\n let clty_params =\n List.fold_right (fun ty cty -> Cty_arrow (Labelled \"*\",ty,cty)) in\n match_class_types ~trace:false env\n (clty_params patt_params patt_type)\n (clty_params subj_params subj_type)\n with Failure r -> r\n end\n | error ->\n error\n\n\n (***************)\n (* Subtyping *)\n (***************)\n\n\n(**** Build a subtype of a given type. ****)\n\n(* build_subtype:\n [visited] traces traversed object and variant types\n [loops] is a mapping from variables to variables, to reproduce\n positive loops in a class type\n [posi] true if the current variance is positive\n [level] number of expansions/enlargement allowed on this branch *)\n\nlet warn = ref false (* whether double coercion might do better *)\nlet pred_expand n = if n mod 2 = 0 && n > 0 then pred n else n\nlet pred_enlarge n = if n mod 2 = 1 then pred n else n\n\ntype change = Unchanged | Equiv | Changed\nlet max_change c1 c2 =\n match c1, c2 with\n | _, Changed | Changed, _ -> Changed\n | Equiv, _ | _, Equiv -> Equiv\n | _ -> Unchanged\n\nlet collect l = List.fold_left (fun c1 (_, c2) -> max_change c1 c2) Unchanged l\n\nlet rec filter_visited = function\n [] -> []\n | {desc=Tobject _|Tvariant _} :: _ as l -> l\n | _ :: l -> filter_visited l\n\nlet memq_warn t visited =\n if List.memq t visited then (warn := true; true) else false\n\nlet find_cltype_for_path env p =\n let cl_abbr = Env.find_hash_type p env in\n match cl_abbr.type_manifest with\n Some ty ->\n begin match get_desc ty with\n Tobject(_,{contents=Some(p',_)}) when Path.same p p' -> cl_abbr, ty\n | _ -> raise Not_found\n end\n | None -> assert false\n\nlet has_constr_row' env t =\n has_constr_row (expand_abbrev env t)\n\nlet rec build_subtype env (visited : transient_expr list)\n (loops : (int * type_expr) list) posi level t =\n match get_desc t with\n Tvar _ ->\n if posi then\n try\n let t' = List.assq (get_id t) loops in\n warn := true;\n (t', Equiv)\n with Not_found ->\n (t, Unchanged)\n else\n (t, Unchanged)\n | Tarrow(l, t1, t2, _) ->\n let tt = Transient_expr.repr t in\n if memq_warn tt visited then (t, Unchanged) else\n let visited = tt :: visited in\n let (t1', c1) = build_subtype env visited loops (not posi) level t1 in\n let (t2', c2) = build_subtype env visited loops posi level t2 in\n let c = max_change c1 c2 in\n if c > Unchanged\n then (newty (Tarrow(l, t1', t2', commu_ok)), c)\n else (t, Unchanged)\n | Ttuple tlist ->\n let tt = Transient_expr.repr t in\n if memq_warn tt visited then (t, Unchanged) else\n let visited = tt :: visited in\n let tlist' =\n List.map (build_subtype env visited loops posi level) tlist\n in\n let c = collect tlist' in\n if c > Unchanged then (newty (Ttuple (List.map fst tlist')), c)\n else (t, Unchanged)\n | Tconstr(p, tl, abbrev)\n when level > 0 && generic_abbrev env p && safe_abbrev env t\n && not (has_constr_row' env t) ->\n let t' = expand_abbrev env t in\n let level' = pred_expand level in\n begin try match get_desc t' with\n Tobject _ when posi && not (opened_object t') ->\n let cl_abbr, body = find_cltype_for_path env p in\n let ty =\n try\n subst env !current_level Public abbrev None\n cl_abbr.type_params tl body\n with Cannot_subst -> assert false in\n let ty1, tl1 =\n match get_desc ty with\n Tobject(ty1,{contents=Some(p',tl1)}) when Path.same p p' ->\n ty1, tl1\n | _ -> raise Not_found\n in\n (* Fix PR#4505: do not set ty to Tvar when it appears in tl1,\n as this occurrence might break the occur check.\n XXX not clear whether this correct anyway... *)\n if List.exists (deep_occur ty) tl1 then raise Not_found;\n set_type_desc ty (Tvar None);\n let t'' = newvar () in\n let loops = (get_id ty, t'') :: loops in\n (* May discard [visited] as level is going down *)\n let (ty1', c) =\n build_subtype env [Transient_expr.repr t']\n loops posi (pred_enlarge level') ty1 in\n assert (is_Tvar t'');\n let nm =\n if c > Equiv || deep_occur ty ty1' then None else Some(p,tl1) in\n set_type_desc t'' (Tobject (ty1', ref nm));\n (try unify_var env ty t with Unify _ -> assert false);\n ( t'', Changed)\n | _ -> raise Not_found\n with Not_found ->\n let (t'',c) =\n build_subtype env visited loops posi level' t' in\n if c > Unchanged then (t'',c)\n else (t, Unchanged)\n end\n | Tconstr(p, tl, _abbrev) ->\n (* Must check recursion on constructors, since we do not always\n expand them *)\n let tt = Transient_expr.repr t in\n if memq_warn tt visited then (t, Unchanged) else\n let visited = tt :: visited in\n begin try\n let decl = Env.find_type p env in\n if level = 0 && generic_abbrev env p && safe_abbrev env t\n && not (has_constr_row' env t)\n then warn := true;\n let tl' =\n List.map2\n (fun v t ->\n let (co,cn) = Variance.get_upper v in\n if cn then\n if co then (t, Unchanged)\n else build_subtype env visited loops (not posi) level t\n else\n if co then build_subtype env visited loops posi level t\n else (newvar(), Changed))\n decl.type_variance tl\n in\n let c = collect tl' in\n if c > Unchanged then (newconstr p (List.map fst tl'), c)\n else (t, Unchanged)\n with Not_found ->\n (t, Unchanged)\n end\n | Tvariant row ->\n let tt = Transient_expr.repr t in\n if memq_warn tt visited || not (static_row row) then (t, Unchanged) else\n let level' = pred_enlarge level in\n let visited =\n tt :: if level' < level then [] else filter_visited visited in\n let fields = filter_row_fields false (row_fields row) in\n let fields =\n List.map\n (fun (l,f as orig) -> match row_field_repr f with\n Rpresent None ->\n if posi then\n (l, rf_either_of None), Unchanged\n else\n orig, Unchanged\n | Rpresent(Some t) ->\n let (t', c) = build_subtype env visited loops posi level' t in\n let f =\n if posi && level > 0\n then rf_either_of (Some t')\n else rf_present (Some t')\n in (l, f), c\n | _ -> assert false)\n fields\n in\n let c = collect fields in\n let row =\n create_row ~fields:(List.map fst fields) ~more:(newvar ())\n ~closed:posi ~fixed:None\n ~name:(if c > Unchanged then None else row_name row)\n in\n (newty (Tvariant row), Changed)\n | Tobject (t1, _) ->\n let tt = Transient_expr.repr t in\n if memq_warn tt visited || opened_object t1 then (t, Unchanged) else\n let level' = pred_enlarge level in\n let visited =\n tt :: if level' < level then [] else filter_visited visited in\n let (t1', c) = build_subtype env visited loops posi level' t1 in\n if c > Unchanged then (newty (Tobject (t1', ref None)), c)\n else (t, Unchanged)\n | Tfield(s, _, t1, t2) (* Always present *) ->\n let (t1', c1) = build_subtype env visited loops posi level t1 in\n let (t2', c2) = build_subtype env visited loops posi level t2 in\n let c = max_change c1 c2 in\n if c > Unchanged then (newty (Tfield(s, field_public, t1', t2')), c)\n else (t, Unchanged)\n | Tnil ->\n if posi then\n let v = newvar () in\n (v, Changed)\n else begin\n warn := true;\n (t, Unchanged)\n end\n | Tsubst _ | Tlink _ ->\n assert false\n | Tpoly(t1, tl) ->\n let (t1', c) = build_subtype env visited loops posi level t1 in\n if c > Unchanged then (newty (Tpoly(t1', tl)), c)\n else (t, Unchanged)\n | Tunivar _ | Tpackage _ ->\n (t, Unchanged)\n\nlet enlarge_type env ty =\n warn := false;\n (* [level = 4] allows 2 expansions involving objects/variants *)\n let (ty', _) = build_subtype env [] [] true 4 ty in\n (ty', !warn)\n\n(**** Check whether a type is a subtype of another type. ****)\n\n(*\n During the traversal, a trace of visited types is maintained. It\n is printed in case of error.\n Constraints (pairs of types that must be equals) are accumulated\n rather than being enforced straight. Indeed, the result would\n otherwise depend on the order in which these constraints are\n enforced.\n A function enforcing these constraints is returned. That way, type\n variables can be bound to their actual values before this function\n is called (see Typecore).\n Only well-defined abbreviations are expanded (hence the tests\n [generic_abbrev ...]).\n*)\n\nlet subtypes = TypePairs.create 17\n\nlet subtype_error ~env ~trace ~unification_trace =\n raise (Subtype (Subtype.error\n ~trace:(expand_subtype_trace env (List.rev trace))\n ~unification_trace))\n\nlet rec subtype_rec env trace t1 t2 cstrs =\n if eq_type t1 t2 then cstrs else\n\n if TypePairs.mem subtypes (t1, t2) then\n cstrs\n else begin\n TypePairs.add subtypes (t1, t2);\n match (get_desc t1, get_desc t2) with\n (Tvar _, _) | (_, Tvar _) ->\n (trace, t1, t2, !univar_pairs)::cstrs\n | (Tarrow(l1, t1, u1, _), Tarrow(l2, t2, u2, _)) when l1 = l2\n || !Clflags.classic && not (is_optional l1 || is_optional l2) ->\n let cstrs =\n subtype_rec\n env\n (Subtype.Diff {got = t2; expected = t1} :: trace)\n t2 t1\n cstrs\n in\n subtype_rec\n env\n (Subtype.Diff {got = u1; expected = u2} :: trace)\n u1 u2\n cstrs\n | (Ttuple tl1, Ttuple tl2) ->\n subtype_list env trace tl1 tl2 cstrs\n | (Tconstr(p1, [], _), Tconstr(p2, [], _)) when Path.same p1 p2 ->\n cstrs\n | (Tconstr(p1, _tl1, _abbrev1), _)\n when generic_abbrev env p1 && safe_abbrev env t1 ->\n subtype_rec env trace (expand_abbrev env t1) t2 cstrs\n | (_, Tconstr(p2, _tl2, _abbrev2))\n when generic_abbrev env p2 && safe_abbrev env t2 ->\n subtype_rec env trace t1 (expand_abbrev env t2) cstrs\n | (Tconstr(p1, tl1, _), Tconstr(p2, tl2, _)) when Path.same p1 p2 ->\n begin try\n let decl = Env.find_type p1 env in\n List.fold_left2\n (fun cstrs v (t1, t2) ->\n let (co, cn) = Variance.get_upper v in\n if co then\n if cn then\n (trace, newty2 ~level:(get_level t1) (Ttuple[t1]),\n newty2 ~level:(get_level t2) (Ttuple[t2]), !univar_pairs)\n :: cstrs\n else\n subtype_rec\n env\n (Subtype.Diff {got = t1; expected = t2} :: trace)\n t1 t2\n cstrs\n else\n if cn\n then\n subtype_rec\n env\n (Subtype.Diff {got = t2; expected = t1} :: trace)\n t2 t1\n cstrs\n else cstrs)\n cstrs decl.type_variance (List.combine tl1 tl2)\n with Not_found ->\n (trace, t1, t2, !univar_pairs)::cstrs\n end\n | (Tconstr(p1, _, _), _)\n when generic_private_abbrev env p1 && safe_abbrev_opt env t1 ->\n subtype_rec env trace (expand_abbrev_opt env t1) t2 cstrs\n(* | (_, Tconstr(p2, _, _)) when generic_private_abbrev false env p2 ->\n subtype_rec env trace t1 (expand_abbrev_opt env t2) cstrs *)\n | (Tobject (f1, _), Tobject (f2, _))\n when is_Tvar (object_row f1) && is_Tvar (object_row f2) ->\n (* Same row variable implies same object. *)\n (trace, t1, t2, !univar_pairs)::cstrs\n | (Tobject (f1, _), Tobject (f2, _)) ->\n subtype_fields env trace f1 f2 cstrs\n | (Tvariant row1, Tvariant row2) ->\n begin try\n subtype_row env trace row1 row2 cstrs\n with Exit ->\n (trace, t1, t2, !univar_pairs)::cstrs\n end\n | (Tpoly (u1, []), Tpoly (u2, [])) ->\n subtype_rec env trace u1 u2 cstrs\n | (Tpoly (u1, tl1), Tpoly (u2, [])) ->\n let _, u1' = instance_poly false tl1 u1 in\n subtype_rec env trace u1' u2 cstrs\n | (Tpoly (u1, tl1), Tpoly (u2,tl2)) ->\n begin try\n enter_poly env univar_pairs u1 tl1 u2 tl2\n (fun t1 t2 -> subtype_rec env trace t1 t2 cstrs)\n with Escape _ ->\n (trace, t1, t2, !univar_pairs)::cstrs\n end\n | (Tpackage (p1, fl1), Tpackage (p2, fl2)) ->\n begin try\n let ntl1 =\n complete_type_list env fl2 (get_level t1) (Mty_ident p1) fl1\n and ntl2 =\n complete_type_list env fl1 (get_level t2) (Mty_ident p2) fl2\n ~allow_absent:true in\n let cstrs' =\n List.map\n (fun (n2,t2) -> (trace, List.assoc n2 ntl1, t2, !univar_pairs))\n ntl2\n in\n if eq_package_path env p1 p2 then cstrs' @ cstrs\n else begin\n (* need to check module subtyping *)\n let snap = Btype.snapshot () in\n match List.iter (fun (_, t1, t2, _) -> unify env t1 t2) cstrs' with\n | () when !package_subtype env p1 fl1 p2 fl2 ->\n Btype.backtrack snap; cstrs' @ cstrs\n | () | exception Unify _ ->\n Btype.backtrack snap; raise Not_found\n end\n with Not_found ->\n (trace, t1, t2, !univar_pairs)::cstrs\n end\n | (_, _) ->\n (trace, t1, t2, !univar_pairs)::cstrs\n end\n\nand subtype_list env trace tl1 tl2 cstrs =\n if List.length tl1 <> List.length tl2 then\n subtype_error ~env ~trace ~unification_trace:[];\n List.fold_left2\n (fun cstrs t1 t2 ->\n subtype_rec\n env\n (Subtype.Diff { got = t1; expected = t2 } :: trace)\n t1 t2\n cstrs)\n cstrs tl1 tl2\n\nand subtype_fields env trace ty1 ty2 cstrs =\n (* Assume that either rest1 or rest2 is not Tvar *)\n let (fields1, rest1) = flatten_fields ty1 in\n let (fields2, rest2) = flatten_fields ty2 in\n let (pairs, miss1, miss2) = associate_fields fields1 fields2 in\n let cstrs =\n if get_desc rest2 = Tnil then cstrs else\n if miss1 = [] then\n subtype_rec\n env\n (Subtype.Diff {got = rest1; expected = rest2} :: trace)\n rest1 rest2\n cstrs\n else\n (trace, build_fields (get_level ty1) miss1 rest1, rest2,\n !univar_pairs) :: cstrs\n in\n let cstrs =\n if miss2 = [] then cstrs else\n (trace, rest1, build_fields (get_level ty2) miss2 (newvar ()),\n !univar_pairs) :: cstrs\n in\n List.fold_left\n (fun cstrs (_, _k1, t1, _k2, t2) ->\n (* These fields are always present *)\n subtype_rec\n env\n (Subtype.Diff {got = t1; expected = t2} :: trace)\n t1 t2\n cstrs)\n cstrs pairs\n\nand subtype_row env trace row1 row2 cstrs =\n let Row {fields = row1_fields; more = more1; closed = row1_closed} =\n row_repr row1 in\n let Row {fields = row2_fields; more = more2; closed = row2_closed} =\n row_repr row2 in\n let r1, r2, pairs =\n merge_row_fields row1_fields row2_fields in\n let r1 = if row2_closed then filter_row_fields false r1 else r1 in\n let r2 = if row1_closed then filter_row_fields false r2 else r2 in\n match get_desc more1, get_desc more2 with\n Tconstr(p1,_,_), Tconstr(p2,_,_) when Path.same p1 p2 ->\n subtype_rec\n env\n (Subtype.Diff {got = more1; expected = more2} :: trace)\n more1 more2\n cstrs\n | (Tvar _|Tconstr _|Tnil), (Tvar _|Tconstr _|Tnil)\n when row1_closed && r1 = [] ->\n List.fold_left\n (fun cstrs (_,f1,f2) ->\n match row_field_repr f1, row_field_repr f2 with\n (Rpresent None|Reither(true,_,_)), Rpresent None ->\n cstrs\n | Rpresent(Some t1), Rpresent(Some t2) ->\n subtype_rec\n env\n (Subtype.Diff {got = t1; expected = t2} :: trace)\n t1 t2\n cstrs\n | Reither(false, t1::_, _), Rpresent(Some t2) ->\n subtype_rec\n env\n (Subtype.Diff {got = t1; expected = t2} :: trace)\n t1 t2\n cstrs\n | Rabsent, _ -> cstrs\n | _ -> raise Exit)\n cstrs pairs\n | Tunivar _, Tunivar _\n when row1_closed = row2_closed && r1 = [] && r2 = [] ->\n let cstrs =\n subtype_rec\n env\n (Subtype.Diff {got = more1; expected = more2} :: trace)\n more1 more2\n cstrs\n in\n List.fold_left\n (fun cstrs (_,f1,f2) ->\n match row_field_repr f1, row_field_repr f2 with\n Rpresent None, Rpresent None\n | Reither(true,[],_), Reither(true,[],_)\n | Rabsent, Rabsent ->\n cstrs\n | Rpresent(Some t1), Rpresent(Some t2)\n | Reither(false,[t1],_), Reither(false,[t2],_) ->\n subtype_rec\n env\n (Subtype.Diff {got = t1; expected = t2} :: trace)\n t1 t2\n cstrs\n | _ -> raise Exit)\n cstrs pairs\n | _ ->\n raise Exit\n\nlet subtype env ty1 ty2 =\n TypePairs.clear subtypes;\n univar_pairs := [];\n (* Build constraint set. *)\n let cstrs =\n subtype_rec env [Subtype.Diff {got = ty1; expected = ty2}] ty1 ty2 []\n in\n TypePairs.clear subtypes;\n (* Enforce constraints. *)\n function () ->\n List.iter\n (function (trace0, t1, t2, pairs) ->\n try unify_pairs (ref env) t1 t2 pairs with Unify {trace} ->\n subtype_error ~env ~trace:trace0 ~unification_trace:(List.tl trace))\n (List.rev cstrs)\n\n (*******************)\n (* Miscellaneous *)\n (*******************)\n\n(* Utility for printing. The resulting type is not used in computation. *)\nlet rec unalias_object ty =\n let level = get_level ty in\n match get_desc ty with\n Tfield (s, k, t1, t2) ->\n newty2 ~level (Tfield (s, k, t1, unalias_object t2))\n | Tvar _ | Tnil as desc ->\n newty2 ~level desc\n | Tunivar _ ->\n ty\n | Tconstr _ ->\n newvar2 level\n | _ ->\n assert false\n\nlet unalias ty =\n let level = get_level ty in\n match get_desc ty with\n Tvar _ | Tunivar _ ->\n ty\n | Tvariant row ->\n let Row {fields; more; name; fixed; closed} = row_repr row in\n newty2 ~level\n (Tvariant\n (create_row ~fields ~name ~fixed ~closed ~more:\n (newty2 ~level:(get_level more) (get_desc more))))\n | Tobject (ty, nm) ->\n newty2 ~level (Tobject (unalias_object ty, nm))\n | desc ->\n newty2 ~level desc\n\n(* Return the arity (as for curried functions) of the given type. *)\nlet rec arity ty =\n match get_desc ty with\n Tarrow(_, _t1, t2, _) -> 1 + arity t2\n | _ -> 0\n\n(* Check for non-generalizable type variables *)\nexception Nongen\nlet visited = ref TypeSet.empty\n\nlet rec nongen_schema_rec env ty =\n if TypeSet.mem ty !visited then () else begin\n visited := TypeSet.add ty !visited;\n match get_desc ty with\n Tvar _ when get_level ty <> generic_level ->\n raise Nongen\n | Tconstr _ ->\n let old = !visited in\n begin try iter_type_expr (nongen_schema_rec env) ty\n with Nongen -> try\n visited := old;\n nongen_schema_rec env (try_expand_head try_expand_safe env ty)\n with Cannot_expand ->\n raise Nongen\n end\n | Tfield(_, kind, t1, t2) ->\n if field_kind_repr kind = Fpublic then\n nongen_schema_rec env t1;\n nongen_schema_rec env t2\n | Tvariant row ->\n iter_row (nongen_schema_rec env) row;\n if not (static_row row) then nongen_schema_rec env (row_more row)\n | _ ->\n iter_type_expr (nongen_schema_rec env) ty\n end\n\n(* Return whether all variables of type [ty] are generic. *)\nlet nongen_schema env ty =\n visited := TypeSet.empty;\n try\n nongen_schema_rec env ty;\n visited := TypeSet.empty;\n false\n with Nongen ->\n visited := TypeSet.empty;\n true\n\n(* Check that all type variables are generalizable *)\n(* Use Env.empty to prevent expansion of recursively defined object types;\n cf. typing-poly/poly.ml *)\nlet rec nongen_class_type = function\n | Cty_constr (_, params, _) ->\n List.exists (nongen_schema Env.empty) params\n | Cty_signature sign ->\n nongen_schema Env.empty sign.csig_self\n || nongen_schema Env.empty sign.csig_self_row\n || Meths.exists\n (fun _ (_, _, ty) -> nongen_schema Env.empty ty)\n sign.csig_meths\n || Vars.exists\n (fun _ (_, _, ty) -> nongen_schema Env.empty ty)\n sign.csig_vars\n | Cty_arrow (_, ty, cty) ->\n nongen_schema Env.empty ty\n || nongen_class_type cty\n\nlet nongen_class_declaration cty =\n List.exists (nongen_schema Env.empty) cty.cty_params\n || nongen_class_type cty.cty_type\n\n\n(* Normalize a type before printing, saving... *)\n(* Cannot use mark_type because deep_occur uses it too *)\nlet rec normalize_type_rec visited ty =\n if not (TypeSet.mem ty !visited) then begin\n visited := TypeSet.add ty !visited;\n let tm = row_of_type ty in\n begin if not (is_Tconstr ty) && is_constr_row ~allow_ident:false tm then\n match get_desc tm with (* PR#7348 *)\n Tconstr (Path.Pdot(m,i), tl, _abbrev) ->\n let i' = String.sub i 0 (String.length i - 4) in\n set_type_desc ty (Tconstr(Path.Pdot(m,i'), tl, ref Mnil))\n | _ -> assert false\n else match get_desc ty with\n | Tvariant row ->\n let Row {fields = orig_fields; more; name; fixed; closed} =\n row_repr row in\n let fields = List.map\n (fun (l,f) ->\n l,\n match row_field_repr f with Reither(b, ty::(_::_ as tyl), m) ->\n let tyl' =\n List.fold_left\n (fun tyl ty ->\n if List.exists\n (fun ty' -> is_equal Env.empty false [ty] [ty'])\n tyl\n then tyl\n else ty::tyl)\n [ty] tyl\n in\n if List.length tyl' <= List.length tyl then\n rf_either (List.rev tyl') ~use_ext_of:f ~no_arg:b ~matched:m\n else f\n | _ -> f)\n orig_fields in\n let fields =\n List.sort (fun (p,_) (q,_) -> compare p q)\n (List.filter (fun (_,fi) -> row_field_repr fi <> Rabsent) fields) in\n set_type_desc ty (Tvariant\n (create_row ~fields ~more ~name ~fixed ~closed))\n | Tobject (fi, nm) ->\n begin match !nm with\n | None -> ()\n | Some (n, v :: l) ->\n if deep_occur ty (newgenty (Ttuple l)) then\n (* The abbreviation may be hiding something, so remove it *)\n set_name nm None\n else\n begin match get_desc v with\n | Tvar _ | Tunivar _ -> ()\n | Tnil -> set_type_desc ty (Tconstr (n, l, ref Mnil))\n | _ -> set_name nm None\n end\n | _ ->\n fatal_error \"Ctype.normalize_type_rec\"\n end;\n let level = get_level fi in\n if level < lowest_level then () else\n let fields, row = flatten_fields fi in\n let fi' = build_fields level fields row in\n set_type_desc fi (get_desc fi')\n | _ -> ()\n end;\n iter_type_expr (normalize_type_rec visited) ty;\n end\n\nlet normalize_type ty =\n normalize_type_rec (ref TypeSet.empty) ty\n\n\n (*************************)\n (* Remove dependencies *)\n (*************************)\n\n\n(*\n Variables are left unchanged. Other type nodes are duplicated, with\n levels set to generic level.\n We cannot use Tsubst here, because unification may be called by\n expand_abbrev.\n*)\n\nlet nondep_hash = TypeHash.create 47\nlet nondep_variants = TypeHash.create 17\nlet clear_hash () =\n TypeHash.clear nondep_hash; TypeHash.clear nondep_variants\n\nlet rec nondep_type_rec ?(expand_private=false) env ids ty =\n let try_expand env t =\n if expand_private then try_expand_safe_opt env t\n else try_expand_safe env t\n in\n match get_desc ty with\n Tvar _ | Tunivar _ -> ty\n | _ -> try TypeHash.find nondep_hash ty\n with Not_found ->\n let ty' = newgenstub ~scope:(get_scope ty) in\n TypeHash.add nondep_hash ty ty';\n let desc =\n match get_desc ty with\n | Tconstr(p, tl, _abbrev) as desc ->\n begin try\n (* First, try keeping the same type constructor p *)\n match Path.find_free_opt ids p with\n | Some id ->\n raise (Nondep_cannot_erase id)\n | None ->\n Tconstr(p, List.map (nondep_type_rec env ids) tl, ref Mnil)\n with (Nondep_cannot_erase _) as exn ->\n (* If that doesn't work, try expanding abbrevs *)\n try Tlink (nondep_type_rec ~expand_private env ids\n (try_expand env (newty2 ~level:(get_level ty) desc)))\n (*\n The [Tlink] is important. The expanded type may be a\n variable, or may not be completely copied yet\n (recursive type), so one cannot just take its\n description.\n *)\n with Cannot_expand -> raise exn\n end\n | Tpackage(p, fl) when Path.exists_free ids p ->\n let p' = normalize_package_path env p in\n begin match Path.find_free_opt ids p' with\n | Some id -> raise (Nondep_cannot_erase id)\n | None ->\n let nondep_field_rec (n, ty) = (n, nondep_type_rec env ids ty) in\n Tpackage (p', List.map nondep_field_rec fl)\n end\n | Tobject (t1, name) ->\n Tobject (nondep_type_rec env ids t1,\n ref (match !name with\n None -> None\n | Some (p, tl) ->\n if Path.exists_free ids p then None\n else Some (p, List.map (nondep_type_rec env ids) tl)))\n | Tvariant row ->\n let more = row_more row in\n (* We must keep sharing according to the row variable *)\n begin try\n let ty2 = TypeHash.find nondep_variants more in\n (* This variant type has been already copied *)\n TypeHash.add nondep_hash ty ty2;\n Tlink ty2\n with Not_found ->\n (* Register new type first for recursion *)\n TypeHash.add nondep_variants more ty';\n let static = static_row row in\n let more' =\n if static then newgenty Tnil else nondep_type_rec env ids more\n in\n (* Return a new copy *)\n let row =\n copy_row (nondep_type_rec env ids) true row true more' in\n match row_name row with\n Some (p, _tl) when Path.exists_free ids p ->\n Tvariant (set_row_name row None)\n | _ -> Tvariant row\n end\n | desc -> copy_type_desc (nondep_type_rec env ids) desc\n in\n Transient_expr.set_stub_desc ty' desc;\n ty'\n\nlet nondep_type env id ty =\n try\n let ty' = nondep_type_rec env id ty in\n clear_hash ();\n ty'\n with Nondep_cannot_erase _ as exn ->\n clear_hash ();\n raise exn\n\nlet () = nondep_type' := nondep_type\n\n(* Preserve sharing inside type declarations. *)\nlet nondep_type_decl env mid is_covariant decl =\n try\n let params = List.map (nondep_type_rec env mid) decl.type_params in\n let tk =\n try map_kind (nondep_type_rec env mid) decl.type_kind\n with Nondep_cannot_erase _ when is_covariant -> Type_abstract\n and tm, priv =\n match decl.type_manifest with\n | None -> None, decl.type_private\n | Some ty ->\n try Some (nondep_type_rec env mid ty), decl.type_private\n with Nondep_cannot_erase _ when is_covariant ->\n clear_hash ();\n try Some (nondep_type_rec ~expand_private:true env mid ty),\n Private\n with Nondep_cannot_erase _ ->\n None, decl.type_private\n in\n clear_hash ();\n let priv =\n match tm with\n | Some ty when Btype.has_constr_row ty -> Private\n | _ -> priv\n in\n { type_params = params;\n type_arity = decl.type_arity;\n type_kind = tk;\n type_manifest = tm;\n type_private = priv;\n type_variance = decl.type_variance;\n type_separability = decl.type_separability;\n type_is_newtype = false;\n type_expansion_scope = Btype.lowest_level;\n type_loc = decl.type_loc;\n type_attributes = decl.type_attributes;\n type_immediate = decl.type_immediate;\n type_unboxed_default = decl.type_unboxed_default;\n type_uid = decl.type_uid;\n }\n with Nondep_cannot_erase _ as exn ->\n clear_hash ();\n raise exn\n\n(* Preserve sharing inside extension constructors. *)\nlet nondep_extension_constructor env ids ext =\n try\n let type_path, type_params =\n match Path.find_free_opt ids ext.ext_type_path with\n | Some id ->\n begin\n let ty =\n newgenty (Tconstr(ext.ext_type_path, ext.ext_type_params, ref Mnil))\n in\n let ty' = nondep_type_rec env ids ty in\n match get_desc ty' with\n Tconstr(p, tl, _) -> p, tl\n | _ -> raise (Nondep_cannot_erase id)\n end\n | None ->\n let type_params =\n List.map (nondep_type_rec env ids) ext.ext_type_params\n in\n ext.ext_type_path, type_params\n in\n let args = map_type_expr_cstr_args (nondep_type_rec env ids) ext.ext_args in\n let ret_type = Option.map (nondep_type_rec env ids) ext.ext_ret_type in\n clear_hash ();\n { ext_type_path = type_path;\n ext_type_params = type_params;\n ext_args = args;\n ext_ret_type = ret_type;\n ext_private = ext.ext_private;\n ext_attributes = ext.ext_attributes;\n ext_loc = ext.ext_loc;\n ext_uid = ext.ext_uid;\n }\n with Nondep_cannot_erase _ as exn ->\n clear_hash ();\n raise exn\n\n\n(* Preserve sharing inside class types. *)\nlet nondep_class_signature env id sign =\n { csig_self = nondep_type_rec env id sign.csig_self;\n csig_self_row = nondep_type_rec env id sign.csig_self_row;\n csig_vars =\n Vars.map (function (m, v, t) -> (m, v, nondep_type_rec env id t))\n sign.csig_vars;\n csig_meths =\n Meths.map (function (p, v, t) -> (p, v, nondep_type_rec env id t))\n sign.csig_meths }\n\nlet rec nondep_class_type env ids =\n function\n Cty_constr (p, _, cty) when Path.exists_free ids p ->\n nondep_class_type env ids cty\n | Cty_constr (p, tyl, cty) ->\n Cty_constr (p, List.map (nondep_type_rec env ids) tyl,\n nondep_class_type env ids cty)\n | Cty_signature sign ->\n Cty_signature (nondep_class_signature env ids sign)\n | Cty_arrow (l, ty, cty) ->\n Cty_arrow (l, nondep_type_rec env ids ty, nondep_class_type env ids cty)\n\nlet nondep_class_declaration env ids decl =\n assert (not (Path.exists_free ids decl.cty_path));\n let decl =\n { cty_params = List.map (nondep_type_rec env ids) decl.cty_params;\n cty_variance = decl.cty_variance;\n cty_type = nondep_class_type env ids decl.cty_type;\n cty_path = decl.cty_path;\n cty_new =\n begin match decl.cty_new with\n None -> None\n | Some ty -> Some (nondep_type_rec env ids ty)\n end;\n cty_loc = decl.cty_loc;\n cty_attributes = decl.cty_attributes;\n cty_uid = decl.cty_uid;\n }\n in\n clear_hash ();\n decl\n\nlet nondep_cltype_declaration env ids decl =\n assert (not (Path.exists_free ids decl.clty_path));\n let decl =\n { clty_params = List.map (nondep_type_rec env ids) decl.clty_params;\n clty_variance = decl.clty_variance;\n clty_type = nondep_class_type env ids decl.clty_type;\n clty_path = decl.clty_path;\n clty_loc = decl.clty_loc;\n clty_attributes = decl.clty_attributes;\n clty_uid = decl.clty_uid;\n }\n in\n clear_hash ();\n decl\n\n(* collapse conjunctive types in class parameters *)\nlet rec collapse_conj env visited ty =\n let id = get_id ty in\n if List.memq id visited then () else\n let visited = id :: visited in\n match get_desc ty with\n Tvariant row ->\n List.iter\n (fun (_l,fi) ->\n match row_field_repr fi with\n Reither (_c, t1::(_::_ as tl), _m) ->\n List.iter (unify env t1) tl\n | _ ->\n ())\n (row_fields row);\n iter_row (collapse_conj env visited) row\n | _ ->\n iter_type_expr (collapse_conj env visited) ty\n\nlet collapse_conj_params env params =\n List.iter (collapse_conj env []) params\n\nlet same_constr env t1 t2 =\n let t1 = expand_head env t1 in\n let t2 = expand_head env t2 in\n match get_desc t1, get_desc t2 with\n | Tconstr (p1, _, _), Tconstr (p2, _, _) -> Path.same p1 p2\n | _ -> false\n\nlet () =\n Env.same_constr := same_constr\n\nlet immediacy env typ =\n match get_desc typ with\n | Tconstr(p, _args, _abbrev) ->\n begin try\n let type_decl = Env.find_type p env in\n type_decl.type_immediate\n with Not_found -> Type_immediacy.Unknown\n (* This can happen due to e.g. missing -I options,\n causing some .cmi files to be unavailable.\n Maybe we should emit a warning. *)\n end\n | Tvariant row ->\n (* if all labels are devoid of arguments, not a pointer *)\n if\n not (row_closed row)\n || List.exists\n (fun (_, f) -> match row_field_repr f with\n | Rpresent (Some _) | Reither (false, _, _) -> true\n | _ -> false)\n (row_fields row)\n then\n Type_immediacy.Unknown\n else\n Type_immediacy.Always\n | _ -> Type_immediacy.Unknown\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(* Inclusion checks for the core language *)\n\nopen Asttypes\nopen Path\nopen Types\nopen Typedtree\n\ntype position = Errortrace.position = First | Second\n\n(* Inclusion between value descriptions *)\n\ntype primitive_mismatch =\n | Name\n | Arity\n | No_alloc of position\n | Native_name\n | Result_repr\n | Argument_repr of int\n\nlet native_repr_args nra1 nra2 =\n let rec loop i nra1 nra2 =\n match nra1, nra2 with\n | [], [] -> None\n | [], _ :: _ -> assert false\n | _ :: _, [] -> assert false\n | nr1 :: nra1, nr2 :: nra2 ->\n if not (Primitive.equal_native_repr nr1 nr2) then Some (Argument_repr i)\n else loop (i+1) nra1 nra2\n in\n loop 1 nra1 nra2\n\nlet primitive_descriptions pd1 pd2 =\n let open Primitive in\n if not (String.equal pd1.prim_name pd2.prim_name) then\n Some Name\n else if not (Int.equal pd1.prim_arity pd2.prim_arity) then\n Some Arity\n else if (not pd1.prim_alloc) && pd2.prim_alloc then\n Some (No_alloc First)\n else if pd1.prim_alloc && (not pd2.prim_alloc) then\n Some (No_alloc Second)\n else if not (String.equal pd1.prim_native_name pd2.prim_native_name) then\n Some Native_name\n else if not\n (Primitive.equal_native_repr\n pd1.prim_native_repr_res pd2.prim_native_repr_res) then\n Some Result_repr\n else\n native_repr_args pd1.prim_native_repr_args pd2.prim_native_repr_args\n\ntype value_mismatch =\n | Primitive_mismatch of primitive_mismatch\n | Not_a_primitive\n | Type of Errortrace.moregen_error\n\nexception Dont_match of value_mismatch\n\nlet value_descriptions ~loc env name\n (vd1 : Types.value_description)\n (vd2 : Types.value_description) =\n Builtin_attributes.check_alerts_inclusion\n ~def:vd1.val_loc\n ~use:vd2.val_loc\n loc\n vd1.val_attributes vd2.val_attributes\n name;\n match Ctype.moregeneral env true vd1.val_type vd2.val_type with\n | exception Ctype.Moregen err -> raise (Dont_match (Type err))\n | () -> begin\n match (vd1.val_kind, vd2.val_kind) with\n | (Val_prim p1, Val_prim p2) -> begin\n match primitive_descriptions p1 p2 with\n | None -> Tcoerce_none\n | Some err -> raise (Dont_match (Primitive_mismatch err))\n end\n | (Val_prim p, _) ->\n let pc =\n { pc_desc = p; pc_type = vd2.Types.val_type;\n pc_env = env; pc_loc = vd1.Types.val_loc; }\n in\n Tcoerce_primitive pc\n | (_, Val_prim _) -> raise (Dont_match Not_a_primitive)\n | (_, _) -> Tcoerce_none\n end\n\n(* Inclusion between manifest types (particularly for private row types) *)\n\nlet is_absrow env ty =\n match get_desc ty with\n | Tconstr(Pident _, _, _) ->\n (* This function is checking for an abstract row on the side that is being\n included into (usually numbered with \"2\" in this file). In this case,\n the abstract row variable has been substituted for an object or variant\n type. *)\n begin match get_desc (Ctype.expand_head env ty) with\n | Tobject _|Tvariant _ -> true\n | _ -> false\n end\n | _ -> false\n\n(* Inclusion between type declarations *)\n\nlet choose ord first second =\n match ord with\n | First -> first\n | Second -> second\n\nlet choose_other ord first second =\n match ord with\n | First -> choose Second first second\n | Second -> choose First first second\n\n(* Documents which kind of private thing would be revealed *)\ntype privacy_mismatch =\n | Private_type_abbreviation\n | Private_variant_type\n | Private_record_type\n | Private_extensible_variant\n | Private_row_type\n\ntype label_mismatch =\n | Type of Errortrace.equality_error\n | Mutability of position\n\ntype record_change =\n (Types.label_declaration, Types.label_declaration, label_mismatch)\n Diffing_with_keys.change\n\ntype record_mismatch =\n | Label_mismatch of record_change list\n | Unboxed_float_representation of position\n\ntype constructor_mismatch =\n | Type of Errortrace.equality_error\n | Arity\n | Inline_record of record_change list\n | Kind of position\n | Explicit_return_type of position\n\ntype extension_constructor_mismatch =\n | Constructor_privacy\n | Constructor_mismatch of Ident.t\n * Types.extension_constructor\n * Types.extension_constructor\n * constructor_mismatch\n\ntype private_variant_mismatch =\n | Only_outer_closed (* It's only dangerous in one direction *)\n | Missing of position * string\n | Presence of string\n | Incompatible_types_for of string\n | Types of Errortrace.equality_error\n\ntype private_object_mismatch =\n | Missing of string\n | Types of Errortrace.equality_error\n\ntype variant_change =\n (Types.constructor_declaration as 'l, 'l, constructor_mismatch)\n Diffing_with_keys.change\n\ntype type_mismatch =\n | Arity\n | Privacy of privacy_mismatch\n | Kind\n | Constraint of Errortrace.equality_error\n | Manifest of Errortrace.equality_error\n | Private_variant of type_expr * type_expr * private_variant_mismatch\n | Private_object of type_expr * type_expr * private_object_mismatch\n | Variance\n | Record_mismatch of record_mismatch\n | Variant_mismatch of variant_change list\n | Unboxed_representation of position\n | Immediate of Type_immediacy.Violation.t\n\nlet report_primitive_mismatch first second ppf err =\n let pr fmt = Format.fprintf ppf fmt in\n match (err : primitive_mismatch) with\n | Name ->\n pr \"The names of the primitives are not the same\"\n | Arity ->\n pr \"The syntactic arities of these primitives were not the same.@ \\\n (They must have the same number of arrows present in the source.)\"\n | No_alloc ord ->\n pr \"%s primitive is [@@@@noalloc] but %s is not\"\n (String.capitalize_ascii (choose ord first second))\n (choose_other ord first second)\n | Native_name ->\n pr \"The native names of the primitives are not the same\"\n | Result_repr ->\n pr \"The two primitives' results have different representations\"\n | Argument_repr n ->\n pr \"The two primitives' %d%s arguments have different representations\"\n n (Misc.ordinal_suffix n)\n\nlet report_value_mismatch first second env ppf err =\n let pr fmt = Format.fprintf ppf fmt in\n pr \"@ \";\n match (err : value_mismatch) with\n | Primitive_mismatch pm ->\n report_primitive_mismatch first second ppf pm\n | Not_a_primitive ->\n pr \"The implementation is not a primitive.\"\n | Type trace ->\n Printtyp.report_moregen_error ppf Type_scheme env trace\n (fun ppf -> Format.fprintf ppf \"The type\")\n (fun ppf -> Format.fprintf ppf \"is not compatible with the type\")\n\nlet report_type_inequality env ppf err =\n Printtyp.report_equality_error ppf Type_scheme env err\n (fun ppf -> Format.fprintf ppf \"The type\")\n (fun ppf -> Format.fprintf ppf \"is not equal to the type\")\n\nlet report_privacy_mismatch ppf err =\n let singular, item =\n match err with\n | Private_type_abbreviation -> true, \"type abbreviation\"\n | Private_variant_type -> false, \"variant constructor(s)\"\n | Private_record_type -> true, \"record constructor\"\n | Private_extensible_variant -> true, \"extensible variant\"\n | Private_row_type -> true, \"row type\"\n in Format.fprintf ppf \"%s %s would be revealed.\"\n (if singular then \"A private\" else \"Private\")\n item\n\nlet report_label_mismatch first second env ppf err =\n match (err : label_mismatch) with\n | Type err ->\n report_type_inequality env ppf err\n | Mutability ord ->\n Format.fprintf ppf \"%s is mutable and %s is not.\"\n (String.capitalize_ascii (choose ord first second))\n (choose_other ord first second)\n\nlet pp_record_diff first second prefix decl env ppf (x : record_change) =\n match x with\n | Delete cd ->\n Format.fprintf ppf \"%aAn extra field, %s, is provided in %s %s.\"\n prefix x (Ident.name cd.delete.ld_id) first decl\n | Insert cd ->\n Format.fprintf ppf \"%aA field, %s, is missing in %s %s.\"\n prefix x (Ident.name cd.insert.ld_id) first decl\n | Change Type {got=lbl1; expected=lbl2; reason} ->\n Format.fprintf ppf\n \"@[%aFields do not match:@;<1 2>\\\n %a@ is not the same as:\\\n @;<1 2>%a@ %a@]\"\n prefix x\n Printtyp.label lbl1\n Printtyp.label lbl2\n (report_label_mismatch first second env) reason\n | Change Name n ->\n Format.fprintf ppf \"%aFields have different names, %s and %s.\"\n prefix x n.got n.expected\n | Swap sw ->\n Format.fprintf ppf \"%aFields %s and %s have been swapped.\"\n prefix x sw.first sw.last\n | Move {name; got; expected } ->\n Format.fprintf ppf\n \"@[<2>%aField %s has been moved@ from@ position %d@ to %d.@]\"\n prefix x name expected got\n\nlet report_patch pr_diff first second decl env ppf patch =\n let nl ppf () = Format.fprintf ppf \"@,\" in\n let no_prefix _ppf _ = () in\n match patch with\n | [ elt ] ->\n Format.fprintf ppf \"@[%a@]\"\n (pr_diff first second no_prefix decl env) elt\n | _ ->\n let pp_diff = pr_diff first second Diffing_with_keys.prefix decl env in\n Format.fprintf ppf \"@[%a@]\"\n (Format.pp_print_list ~pp_sep:nl pp_diff) patch\n\nlet report_record_mismatch first second decl env ppf err =\n let pr fmt = Format.fprintf ppf fmt in\n match err with\n | Label_mismatch patch ->\n report_patch pp_record_diff first second decl env ppf patch\n | Unboxed_float_representation ord ->\n pr \"@[Their internal representations differ:@ %s %s %s.@]\"\n (choose ord first second) decl\n \"uses unboxed float representation\"\n\nlet report_constructor_mismatch first second decl env ppf err =\n let pr fmt = Format.fprintf ppf fmt in\n match (err : constructor_mismatch) with\n | Type err -> report_type_inequality env ppf err\n | Arity -> pr \"They have different arities.\"\n | Inline_record err ->\n report_patch pp_record_diff first second decl env ppf err\n | Kind ord ->\n pr \"%s uses inline records and %s doesn't.\"\n (String.capitalize_ascii (choose ord first second))\n (choose_other ord first second)\n | Explicit_return_type ord ->\n pr \"%s has explicit return type and %s doesn't.\"\n (String.capitalize_ascii (choose ord first second))\n (choose_other ord first second)\n\nlet pp_variant_diff first second prefix decl env ppf (x : variant_change) =\n match x with\n | Delete cd ->\n Format.fprintf ppf \"%aAn extra constructor, %s, is provided in %s %s.\"\n prefix x (Ident.name cd.delete.cd_id) first decl\n | Insert cd ->\n Format.fprintf ppf \"%aA constructor, %s, is missing in %s %s.\"\n prefix x (Ident.name cd.insert.cd_id) first decl\n | Change Type {got; expected; reason} ->\n Format.fprintf ppf\n \"@[%aConstructors do not match:@;<1 2>\\\n %a@ is not the same as:\\\n @;<1 2>%a@ %a@]\"\n prefix x\n Printtyp.constructor got\n Printtyp.constructor expected\n (report_constructor_mismatch first second decl env) reason\n | Change Name n ->\n Format.fprintf ppf\n \"%aConstructors have different names, %s and %s.\"\n prefix x n.got n.expected\n | Swap sw ->\n Format.fprintf ppf\n \"%aConstructors %s and %s have been swapped.\"\n prefix x sw.first sw.last\n | Move {name; got; expected} ->\n Format.fprintf ppf\n \"@[<2>%aConstructor %s has been moved@ from@ position %d@ to %d.@]\"\n prefix x name expected got\n\nlet report_extension_constructor_mismatch first second decl env ppf err =\n let pr fmt = Format.fprintf ppf fmt in\n match (err : extension_constructor_mismatch) with\n | Constructor_privacy ->\n pr \"Private extension constructor(s) would be revealed.\"\n | Constructor_mismatch (id, ext1, ext2, err) ->\n pr \"@[Constructors do not match:@;<1 2>%a@ is not the same as:\\\n @;<1 2>%a@ %a@]\"\n (Printtyp.extension_only_constructor id) ext1\n (Printtyp.extension_only_constructor id) ext2\n (report_constructor_mismatch first second decl env) err\n\nlet report_private_variant_mismatch first second decl env ppf err =\n let pr fmt = Format.fprintf ppf fmt in\n match (err : private_variant_mismatch) with\n | Only_outer_closed ->\n (* It's only dangerous in one direction, so we don't have a position *)\n pr \"%s is private and closed, but %s is not closed\"\n (String.capitalize_ascii second) first\n | Missing (ord, name) ->\n pr \"The constructor %s is only present in %s %s.\"\n name (choose ord first second) decl\n | Presence s ->\n pr \"The tag `%s is present in the %s %s,@ but might not be in the %s\"\n s second decl first\n | Incompatible_types_for s -> pr \"Types for tag `%s are incompatible\" s\n | Types err ->\n report_type_inequality env ppf err\n\nlet report_private_object_mismatch env ppf err =\n let pr fmt = Format.fprintf ppf fmt in\n match (err : private_object_mismatch) with\n | Missing s -> pr \"The implementation is missing the method %s\" s\n | Types err -> report_type_inequality env ppf err\n\nlet report_type_mismatch first second decl env ppf err =\n let pr fmt = Format.fprintf ppf fmt in\n pr \"@ \";\n match err with\n | Arity ->\n pr \"They have different arities.\"\n | Privacy err ->\n report_privacy_mismatch ppf err\n | Kind ->\n pr \"Their kinds differ.\"\n | Constraint err ->\n (* This error can come from implicit parameter disagreement or from\n explicit `constraint`s. Both affect the parameters, hence this choice\n of explanatory text *)\n pr \"Their parameters differ@,\";\n report_type_inequality env ppf err\n | Manifest err ->\n report_type_inequality env ppf err\n | Private_variant (_ty1, _ty2, mismatch) ->\n report_private_variant_mismatch first second decl env ppf mismatch\n | Private_object (_ty1, _ty2, mismatch) ->\n report_private_object_mismatch env ppf mismatch\n | Variance ->\n pr \"Their variances do not agree.\"\n | Record_mismatch err ->\n report_record_mismatch first second decl env ppf err\n | Variant_mismatch err ->\n report_patch pp_variant_diff first second decl env ppf err\n | Unboxed_representation ord ->\n pr \"Their internal representations differ:@ %s %s %s.\"\n (choose ord first second) decl\n \"uses unboxed representation\"\n | Immediate violation ->\n let first = StringLabels.capitalize_ascii first in\n match violation with\n | Type_immediacy.Violation.Not_always_immediate ->\n pr \"%s is not an immediate type.\" first\n | Type_immediacy.Violation.Not_always_immediate_on_64bits ->\n pr \"%s is not a type that is always immediate on 64 bit platforms.\"\n first\n\nmodule Record_diffing = struct\n\n let compare_labels env params1 params2\n (ld1 : Types.label_declaration)\n (ld2 : Types.label_declaration) =\n if ld1.ld_mutable <> ld2.ld_mutable\n then\n let ord = if ld1.ld_mutable = Asttypes.Mutable then First else Second in\n Some (Mutability ord)\n else\n let tl1 = params1 @ [ld1.ld_type] in\n let tl2 = params2 @ [ld2.ld_type] in\n match Ctype.equal env true tl1 tl2 with\n | exception Ctype.Equality err ->\n Some (Type err : label_mismatch)\n | () -> None\n\n let rec equal ~loc env params1 params2\n (labels1 : Types.label_declaration list)\n (labels2 : Types.label_declaration list) =\n match labels1, labels2 with\n | [], [] -> true\n | _ :: _ , [] | [], _ :: _ -> false\n | ld1 :: rem1, ld2 :: rem2 ->\n if Ident.name ld1.ld_id <> Ident.name ld2.ld_id\n then false\n else begin\n Builtin_attributes.check_deprecated_mutable_inclusion\n ~def:ld1.ld_loc\n ~use:ld2.ld_loc\n loc\n ld1.ld_attributes ld2.ld_attributes\n (Ident.name ld1.ld_id);\n match compare_labels env params1 params2 ld1 ld2 with\n | Some _ -> false\n (* add arguments to the parameters, cf. PR#7378 *)\n | None ->\n equal ~loc env\n (ld1.ld_type::params1) (ld2.ld_type::params2)\n rem1 rem2\n end\n\n module Defs = struct\n type left = Types.label_declaration\n type right = left\n type diff = label_mismatch\n type state = type_expr list * type_expr list\n end\n module Diff = Diffing_with_keys.Define(Defs)\n\n let update (d:Diff.change) (params1,params2 as st) =\n match d with\n | Insert _ | Change _ | Delete _ -> st\n | Keep (x,y,_) ->\n (* We need to add equality between existential type parameters\n (in inline records) *)\n x.data.ld_type::params1, y.data.ld_type::params2\n\n let test _loc env (params1,params2)\n ({pos; data=lbl1}: Diff.left)\n ({data=lbl2; _ }: Diff.right)\n =\n let name1, name2 = Ident.name lbl1.ld_id, Ident.name lbl2.ld_id in\n if name1 <> name2 then\n let types_match =\n match compare_labels env params1 params2 lbl1 lbl2 with\n | Some _ -> false\n | None -> true\n in\n Error\n (Diffing_with_keys.Name {types_match; pos; got=name1; expected=name2})\n else\n match compare_labels env params1 params2 lbl1 lbl2 with\n | Some reason ->\n Error (\n Diffing_with_keys.Type {pos; got=lbl1; expected=lbl2; reason}\n )\n | None -> Ok ()\n\n let weight: Diff.change -> _ = function\n | Insert _ -> 10\n | Delete _ -> 10\n | Keep _ -> 0\n | Change (_,_,Diffing_with_keys.Name t ) ->\n if t.types_match then 10 else 15\n | Change _ -> 10\n\n\n\n let key (x: Defs.left) = Ident.name x.ld_id\n let diffing loc env params1 params2 cstrs_1 cstrs_2 =\n let module Compute = Diff.Simple(struct\n let key_left = key\n let key_right = key\n let update = update\n let test = test loc env\n let weight = weight\n end)\n in\n Compute.diff (params1,params2) cstrs_1 cstrs_2\n\n let compare ~loc env params1 params2 l r =\n if equal ~loc env params1 params2 l r then\n None\n else\n Some (diffing loc env params1 params2 l r)\n\n\n let compare_with_representation ~loc env params1 params2 l r rep1 rep2 =\n if not (equal ~loc env params1 params2 l r) then\n let patch = diffing loc env params1 params2 l r in\n Some (Record_mismatch (Label_mismatch patch))\n else\n match rep1, rep2 with\n | Record_unboxed _, Record_unboxed _ -> None\n | Record_unboxed _, _ -> Some (Unboxed_representation First)\n | _, Record_unboxed _ -> Some (Unboxed_representation Second)\n\n | Record_float, Record_float -> None\n | Record_float, _ ->\n Some (Record_mismatch (Unboxed_float_representation First))\n | _, Record_float ->\n Some (Record_mismatch (Unboxed_float_representation Second))\n\n | Record_regular, Record_regular\n | Record_inlined _, Record_inlined _\n | Record_extension _, Record_extension _ -> None\n | (Record_regular|Record_inlined _|Record_extension _),\n (Record_regular|Record_inlined _|Record_extension _) ->\n assert false\n\nend\n\n\nmodule Variant_diffing = struct\n\n let compare_constructor_arguments ~loc env params1 params2 arg1 arg2 =\n match arg1, arg2 with\n | Types.Cstr_tuple arg1, Types.Cstr_tuple arg2 ->\n if List.length arg1 <> List.length arg2 then\n Some (Arity : constructor_mismatch)\n else begin\n (* Ctype.equal must be called on all arguments at once, cf. PR#7378 *)\n match Ctype.equal env true (params1 @ arg1) (params2 @ arg2) with\n | exception Ctype.Equality err -> Some (Type err)\n | () -> None\n end\n | Types.Cstr_record l1, Types.Cstr_record l2 ->\n Option.map\n (fun rec_err -> Inline_record rec_err)\n (Record_diffing.compare env ~loc params1 params2 l1 l2)\n | Types.Cstr_record _, _ -> Some (Kind First : constructor_mismatch)\n | _, Types.Cstr_record _ -> Some (Kind Second : constructor_mismatch)\n\n let compare_constructors ~loc env params1 params2 res1 res2 args1 args2 =\n match res1, res2 with\n | Some r1, Some r2 ->\n begin match Ctype.equal env true [r1] [r2] with\n | exception Ctype.Equality err -> Some (Type err)\n | () -> compare_constructor_arguments ~loc env [r1] [r2] args1 args2\n end\n | Some _, None -> Some (Explicit_return_type First)\n | None, Some _ -> Some (Explicit_return_type Second)\n | None, None ->\n compare_constructor_arguments ~loc env params1 params2 args1 args2\n\n let equal ~loc env params1 params2\n (cstrs1 : Types.constructor_declaration list)\n (cstrs2 : Types.constructor_declaration list) =\n List.length cstrs1 = List.length cstrs2 &&\n List.for_all2 (fun (cd1:Types.constructor_declaration)\n (cd2:Types.constructor_declaration) ->\n Ident.name cd1.cd_id = Ident.name cd2.cd_id\n &&\n begin\n Builtin_attributes.check_alerts_inclusion\n ~def:cd1.cd_loc\n ~use:cd2.cd_loc\n loc\n cd1.cd_attributes cd2.cd_attributes\n (Ident.name cd1.cd_id)\n ;\n match compare_constructors ~loc env params1 params2\n cd1.cd_res cd2.cd_res cd1.cd_args cd2.cd_args with\n | Some _ -> false\n | None -> true\n end) cstrs1 cstrs2\n\n module Defs = struct\n type left = Types.constructor_declaration\n type right = left\n type diff = constructor_mismatch\n type state = type_expr list * type_expr list\n end\n module D = Diffing_with_keys.Define(Defs)\n\n let update _ st = st\n\n let weight: D.change -> _ = function\n | Insert _ -> 10\n | Delete _ -> 10\n | Keep _ -> 0\n | Change (_,_,Diffing_with_keys.Name t) ->\n if t.types_match then 10 else 15\n | Change _ -> 10\n\n\n let test loc env (params1,params2)\n ({pos; data=cd1}: D.left)\n ({data=cd2; _}: D.right) =\n let name1, name2 = Ident.name cd1.cd_id, Ident.name cd2.cd_id in\n if name1 <> name2 then\n let types_match =\n match compare_constructors ~loc env params1 params2\n cd1.cd_res cd2.cd_res cd1.cd_args cd2.cd_args with\n | Some _ -> false\n | None -> true\n in\n Error\n (Diffing_with_keys.Name {types_match; pos; got=name1; expected=name2})\n else\n match compare_constructors ~loc env params1 params2\n cd1.cd_res cd2.cd_res cd1.cd_args cd2.cd_args with\n | Some reason ->\n Error (Diffing_with_keys.Type {pos; got=cd1; expected=cd2; reason})\n | None -> Ok ()\n\n let diffing loc env params1 params2 cstrs_1 cstrs_2 =\n let key (x:Defs.left) = Ident.name x.cd_id in\n let module Compute = D.Simple(struct\n let key_left = key\n let key_right = key\n let test = test loc env\n let update = update\n let weight = weight\n end)\n in\n Compute.diff (params1,params2) cstrs_1 cstrs_2\n\n let compare ~loc env params1 params2 l r =\n if equal ~loc env params1 params2 l r then\n None\n else\n Some (diffing loc env params1 params2 l r)\n\n let compare_with_representation ~loc env params1 params2\n cstrs1 cstrs2 rep1 rep2\n =\n let err = compare ~loc env params1 params2 cstrs1 cstrs2 in\n match err, rep1, rep2 with\n | None, Variant_regular, Variant_regular\n | None, Variant_unboxed, Variant_unboxed ->\n None\n | Some err, _, _ ->\n Some (Variant_mismatch err)\n | None, Variant_unboxed, Variant_regular ->\n Some (Unboxed_representation First)\n | None, Variant_regular, Variant_unboxed ->\n Some (Unboxed_representation Second)\nend\n\n(* Inclusion between \"private\" annotations *)\nlet privacy_mismatch env decl1 decl2 =\n match decl1.type_private, decl2.type_private with\n | Private, Public -> begin\n match decl1.type_kind, decl2.type_kind with\n | Type_record _, Type_record _ -> Some Private_record_type\n | Type_variant _, Type_variant _ -> Some Private_variant_type\n | Type_open, Type_open -> Some Private_extensible_variant\n | Type_abstract, Type_abstract\n when Option.is_some decl2.type_manifest -> begin\n match decl1.type_manifest with\n | Some ty1 -> begin\n let ty1 = Ctype.expand_head env ty1 in\n match get_desc ty1 with\n | Tvariant row when Btype.is_constr_row ~allow_ident:true\n (row_more row) ->\n Some Private_row_type\n | Tobject (fi, _) when Btype.is_constr_row ~allow_ident:true\n (snd (Ctype.flatten_fields fi)) ->\n Some Private_row_type\n | _ ->\n Some Private_type_abbreviation\n end\n | None ->\n None\n end\n | _, _ ->\n None\n end\n | _, _ ->\n None\n\nlet private_variant env row1 params1 row2 params2 =\n let r1, r2, pairs =\n Ctype.merge_row_fields (row_fields row1) (row_fields row2)\n in\n let row1_closed = row_closed row1 in\n let row2_closed = row_closed row2 in\n let err =\n if row2_closed && not row1_closed then Some Only_outer_closed\n else begin\n match row2_closed, Ctype.filter_row_fields false r1 with\n | true, (s, _) :: _ ->\n Some (Missing (Second, s) : private_variant_mismatch)\n | _, _ -> None\n end\n in\n if err <> None then err else\n let err =\n let missing =\n List.find_opt\n (fun (_,f) ->\n match row_field_repr f with\n | Rabsent | Reither _ -> false\n | Rpresent _ -> true)\n r2\n in\n match missing with\n | None -> None\n | Some (s, _) -> Some (Missing (First, s) : private_variant_mismatch)\n in\n if err <> None then err else\n let rec loop tl1 tl2 pairs =\n match pairs with\n | [] -> begin\n match Ctype.equal env true tl1 tl2 with\n | exception Ctype.Equality err ->\n Some (Types err : private_variant_mismatch)\n | () -> None\n end\n | (s, f1, f2) :: pairs -> begin\n match row_field_repr f1, row_field_repr f2 with\n | Rpresent to1, Rpresent to2 -> begin\n match to1, to2 with\n | Some t1, Some t2 ->\n loop (t1 :: tl1) (t2 :: tl2) pairs\n | None, None ->\n loop tl1 tl2 pairs\n | Some _, None | None, Some _ ->\n Some (Incompatible_types_for s)\n end\n | Rpresent to1, Reither(const2, ts2, _) -> begin\n match to1, const2, ts2 with\n | Some t1, false, [t2] -> loop (t1 :: tl1) (t2 :: tl2) pairs\n | None, true, [] -> loop tl1 tl2 pairs\n | _, _, _ -> Some (Incompatible_types_for s)\n end\n | Rpresent _, Rabsent ->\n Some (Missing (Second, s) : private_variant_mismatch)\n | Reither(const1, ts1, _), Reither(const2, ts2, _) ->\n if const1 = const2 && List.length ts1 = List.length ts2 then\n loop (ts1 @ tl1) (ts2 @ tl2) pairs\n else\n Some (Incompatible_types_for s)\n | Reither _, Rpresent _ ->\n Some (Presence s)\n | Reither _, Rabsent ->\n Some (Missing (Second, s) : private_variant_mismatch)\n | Rabsent, (Reither _ | Rabsent) ->\n loop tl1 tl2 pairs\n | Rabsent, Rpresent _ ->\n Some (Missing (First, s) : private_variant_mismatch)\n end\n in\n loop params1 params2 pairs\n\nlet private_object env fields1 params1 fields2 params2 =\n let pairs, _miss1, miss2 = Ctype.associate_fields fields1 fields2 in\n let err =\n match miss2 with\n | [] -> None\n | (f, _, _) :: _ -> Some (Missing f)\n in\n if err <> None then err else\n let tl1, tl2 =\n List.split (List.map (fun (_,_,t1,_,t2) -> t1, t2) pairs)\n in\n begin\n match Ctype.equal env true (params1 @ tl1) (params2 @ tl2) with\n | exception Ctype.Equality err -> Some (Types err)\n | () -> None\n end\n\nlet type_manifest env ty1 params1 ty2 params2 priv2 kind2 =\n let ty1' = Ctype.expand_head env ty1 and ty2' = Ctype.expand_head env ty2 in\n match get_desc ty1', get_desc ty2' with\n | Tvariant row1, Tvariant row2\n when is_absrow env (row_more row2) -> begin\n assert (Ctype.is_equal env true (ty1::params1) (row_more row2::params2));\n match private_variant env row1 params1 row2 params2 with\n | None -> None\n | Some err -> Some (Private_variant(ty1, ty2, err))\n end\n | Tobject (fi1, _), Tobject (fi2, _)\n when is_absrow env (snd (Ctype.flatten_fields fi2)) -> begin\n let (fields2,rest2) = Ctype.flatten_fields fi2 in\n let (fields1,_) = Ctype.flatten_fields fi1 in\n assert (Ctype.is_equal env true (ty1::params1) (rest2::params2));\n match private_object env fields1 params1 fields2 params2 with\n | None -> None\n | Some err -> Some (Private_object(ty1, ty2, err))\n end\n | _ -> begin\n let is_private_abbrev_2 =\n match priv2, kind2 with\n | Private, Type_abstract -> begin\n (* Same checks as the [when] guards from above, inverted *)\n match get_desc ty2' with\n | Tvariant row ->\n not (is_absrow env (row_more row))\n | Tobject (fi, _) ->\n not (is_absrow env (snd (Ctype.flatten_fields fi)))\n | _ -> true\n end\n | _, _ -> false\n in\n match\n if is_private_abbrev_2 then\n Ctype.equal_private env params1 ty1 params2 ty2\n else\n Ctype.equal env true (params1 @ [ty1]) (params2 @ [ty2])\n with\n | exception Ctype.Equality err -> Some (Manifest err)\n | () -> None\n end\n\nlet type_declarations ?(equality = false) ~loc env ~mark name\n decl1 path decl2 =\n Builtin_attributes.check_alerts_inclusion\n ~def:decl1.type_loc\n ~use:decl2.type_loc\n loc\n decl1.type_attributes decl2.type_attributes\n name;\n if decl1.type_arity <> decl2.type_arity then Some Arity else\n let err =\n match privacy_mismatch env decl1 decl2 with\n | Some err -> Some (Privacy err)\n | None -> None\n in\n if err <> None then err else\n let err = match (decl1.type_manifest, decl2.type_manifest) with\n (_, None) ->\n begin\n match Ctype.equal env true decl1.type_params decl2.type_params with\n | exception Ctype.Equality err -> Some (Constraint err)\n | () -> None\n end\n | (Some ty1, Some ty2) ->\n type_manifest env ty1 decl1.type_params ty2 decl2.type_params\n decl2.type_private decl2.type_kind\n | (None, Some ty2) ->\n let ty1 =\n Btype.newgenty (Tconstr(path, decl2.type_params, ref Mnil))\n in\n match Ctype.equal env true decl1.type_params decl2.type_params with\n | exception Ctype.Equality err -> Some (Constraint err)\n | () ->\n match Ctype.equal env false [ty1] [ty2] with\n | exception Ctype.Equality err -> Some (Manifest err)\n | () -> None\n in\n if err <> None then err else\n let err = match (decl1.type_kind, decl2.type_kind) with\n (_, Type_abstract) -> None\n | (Type_variant (cstrs1, rep1), Type_variant (cstrs2, rep2)) ->\n if mark then begin\n let mark usage cstrs =\n List.iter (Env.mark_constructor_used usage) cstrs\n in\n let usage : Env.constructor_usage =\n if decl2.type_private = Public then Env.Exported\n else Env.Exported_private\n in\n mark usage cstrs1;\n if equality then mark Env.Exported cstrs2\n end;\n Variant_diffing.compare_with_representation ~loc env\n decl1.type_params\n decl2.type_params\n cstrs1\n cstrs2\n rep1\n rep2\n | (Type_record(labels1,rep1), Type_record(labels2,rep2)) ->\n if mark then begin\n let mark usage lbls =\n List.iter (Env.mark_label_used usage) lbls\n in\n let usage : Env.label_usage =\n if decl2.type_private = Public then Env.Exported\n else Env.Exported_private\n in\n mark usage labels1;\n if equality then mark Env.Exported labels2\n end;\n Record_diffing.compare_with_representation ~loc env\n decl1.type_params decl2.type_params\n labels1 labels2\n rep1 rep2\n | (Type_open, Type_open) -> None\n | (_, _) -> Some Kind\n in\n if err <> None then err else\n let abstr = decl2.type_kind = Type_abstract && decl2.type_manifest = None in\n (* If attempt to assign a non-immediate type (e.g. string) to a type that\n * must be immediate, then we error *)\n let err =\n if not abstr then\n None\n else\n match\n Type_immediacy.coerce decl1.type_immediate ~as_:decl2.type_immediate\n with\n | Ok () -> None\n | Error violation -> Some (Immediate violation)\n in\n if err <> None then err else\n let need_variance =\n abstr || decl1.type_private = Private || decl1.type_kind = Type_open in\n if not need_variance then None else\n let abstr = abstr || decl2.type_private = Private in\n let opn = decl2.type_kind = Type_open && decl2.type_manifest = None in\n let constrained ty = not (Btype.is_Tvar ty) in\n if List.for_all2\n (fun ty (v1,v2) ->\n let open Variance in\n let imp a b = not a || b in\n let (co1,cn1) = get_upper v1 and (co2,cn2) = get_upper v2 in\n (if abstr then (imp co1 co2 && imp cn1 cn2)\n else if opn || constrained ty then (co1 = co2 && cn1 = cn2)\n else true) &&\n let (p1,n1,i1,j1) = get_lower v1 and (p2,n2,i2,j2) = get_lower v2 in\n imp abstr (imp p2 p1 && imp n2 n1 && imp i2 i1 && imp j2 j1))\n decl2.type_params (List.combine decl1.type_variance decl2.type_variance)\n then None else Some Variance\n\n(* Inclusion between extension constructors *)\n\nlet extension_constructors ~loc env ~mark id ext1 ext2 =\n if mark then begin\n let usage : Env.constructor_usage =\n if ext2.ext_private = Public then Env.Exported\n else Env.Exported_private\n in\n Env.mark_extension_used usage ext1\n end;\n let ty1 =\n Btype.newgenty (Tconstr(ext1.ext_type_path, ext1.ext_type_params, ref Mnil))\n in\n let ty2 =\n Btype.newgenty (Tconstr(ext2.ext_type_path, ext2.ext_type_params, ref Mnil))\n in\n let tl1 = ty1 :: ext1.ext_type_params in\n let tl2 = ty2 :: ext2.ext_type_params in\n match Ctype.equal env true tl1 tl2 with\n | exception Ctype.Equality err ->\n Some (Constructor_mismatch (id, ext1, ext2, Type err))\n | () ->\n let r =\n Variant_diffing.compare_constructors ~loc env\n ext1.ext_type_params ext2.ext_type_params\n ext1.ext_ret_type ext2.ext_ret_type\n ext1.ext_args ext2.ext_args\n in\n match r with\n | Some r -> Some (Constructor_mismatch (id, ext1, ext2, r))\n | None ->\n match ext1.ext_private, ext2.ext_private with\n | Private, Public -> Some Constructor_privacy\n | _, _ -> None\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(* Detection of partial matches and unused match cases. *)\n\nopen Misc\nopen Asttypes\nopen Types\nopen Typedtree\n\n\n(*************************************)\n(* Utilities for building patterns *)\n(*************************************)\n\nlet make_pat desc ty tenv =\n {pat_desc = desc; pat_loc = Location.none; pat_extra = [];\n pat_type = ty ; pat_env = tenv;\n pat_attributes = [];\n }\n\nlet omega = Patterns.omega\nlet omegas = Patterns.omegas\nlet omega_list = Patterns.omega_list\n\nlet extra_pat =\n make_pat\n (Tpat_var (Ident.create_local \"+\", mknoloc \"+\"))\n Ctype.none Env.empty\n\n\n(*******************)\n(* Coherence check *)\n(*******************)\n\n(* For some of the operations we do in this module, we would like (because it\n simplifies matters) to assume that patterns appearing on a given column in a\n pattern matrix are /coherent/ (think \"of the same type\").\n Unfortunately that is not always true.\n\n Consider the following (well-typed) example:\n {[\n type _ t = S : string t | U : unit t\n\n let f (type a) (t1 : a t) (t2 : a t) (a : a) =\n match t1, t2, a with\n | U, _, () -> ()\n | _, S, \"\" -> ()\n ]}\n\n Clearly the 3rd column contains incoherent patterns.\n\n On the example above, most of the algorithms will explore the pattern matrix\n as illustrated by the following tree:\n\n {v\n S\n -------> | \"\" |\n U | S, \"\" | __/ | () |\n --------> | _, () | \\ not S\n | U, _, () | __/ -------> | () |\n | _, S, \"\" | \\\n ---------> | S, \"\" | ----------> | \"\" |\n not U S\n v}\n\n where following an edge labelled by a pattern P means \"assuming the value I\n am matching on is filtered by [P] on the column I am currently looking at,\n then the following submatrix is still reachable\".\n\n Notice that at any point of that tree, if the first column of a matrix is\n incoherent, then the branch leading to it can only be taken if the scrutinee\n is ill-typed.\n In the example above the only case where we have a matrix with an incoherent\n first column is when we consider [t1, t2, a] to be [U, S, ...]. However such\n a value would be ill-typed, so we can never actually get there.\n\n Checking the first column at each step of the recursion and making the\n conscious decision of \"aborting\" the algorithm whenever the first column\n becomes incoherent, allows us to retain the initial assumption in later\n stages of the algorithms.\n\n ---\n\n N.B. two patterns can be considered coherent even though they might not be of\n the same type.\n\n That's in part because we only care about the \"head\" of patterns and leave\n checking coherence of subpatterns for the next steps of the algorithm:\n ('a', 'b') and (1, ()) will be deemed coherent because they are both a tuples\n of arity 2 (we'll notice at a later stage the incoherence of 'a' and 1).\n\n But also because it can be hard/costly to determine exactly whether two\n patterns are of the same type or not (eg. in the example above with _ and S,\n but see also the module [Coherence_illustration] in\n testsuite/tests/basic-more/robustmatch.ml).\n\n For the moment our weak, loosely-syntactic, coherence check seems to be\n enough and we leave it to each user to consider (and document!) what happens\n when an \"incoherence\" is not detected by this check.\n*)\n\n(* Given the first column of a simplified matrix, this function first looks for\n a \"discriminating\" pattern on that column (i.e. a non-omega one) and then\n check that every other head pattern in the column is coherent with that one.\n*)\nlet all_coherent column =\n let open Patterns.Head in\n let coherent_heads hp1 hp2 =\n match hp1.pat_desc, hp2.pat_desc with\n | Construct c, Construct c' ->\n c.cstr_consts = c'.cstr_consts\n && c.cstr_nonconsts = c'.cstr_nonconsts\n | Constant c1, Constant c2 -> begin\n match c1, c2 with\n | Const_char _, Const_char _\n | Const_int _, Const_int _\n | Const_int32 _, Const_int32 _\n | Const_int64 _, Const_int64 _\n | Const_nativeint _, Const_nativeint _\n | Const_float _, Const_float _\n | Const_string _, Const_string _ -> true\n | ( Const_char _\n | Const_int _\n | Const_int32 _\n | Const_int64 _\n | Const_nativeint _\n | Const_float _\n | Const_string _), _ -> false\n end\n | Tuple l1, Tuple l2 -> l1 = l2\n | Record (lbl1 :: _), Record (lbl2 :: _) ->\n Array.length lbl1.lbl_all = Array.length lbl2.lbl_all\n | Any, _\n | _, Any\n | Record [], Record []\n | Variant _, Variant _\n | Array _, Array _\n | Lazy, Lazy -> true\n | _, _ -> false\n in\n match\n List.find\n (function\n | { pat_desc = Any } -> false\n | _ -> true)\n column\n with\n | exception Not_found ->\n (* only omegas on the column: the column is coherent. *)\n true\n | discr_pat ->\n List.for_all (coherent_heads discr_pat) column\n\nlet first_column simplified_matrix =\n List.map (fun ((head, _args), _rest) -> head) simplified_matrix\n\n(***********************)\n(* Compatibility check *)\n(***********************)\n\n(* Patterns p and q compatible means:\n there exists value V that matches both, However....\n\n The case of extension types is dubious, as constructor rebind permits\n that different constructors are the same (and are thus compatible).\n\n Compilation must take this into account, consider:\n\n type t = ..\n type t += A|B\n type t += C=A\n\n let f x y = match x,y with\n | true,A -> '1'\n | _,C -> '2'\n | false,A -> '3'\n | _,_ -> '_'\n\n As C is bound to A the value of f false A is '2' (and not '3' as it would\n be in the absence of rebinding).\n\n Not considering rebinding, patterns \"false,A\" and \"_,C\" are incompatible\n and the compiler can swap the second and third clause, resulting in the\n (more efficiently compiled) matching\n\n match x,y with\n | true,A -> '1'\n | false,A -> '3'\n | _,C -> '2'\n | _,_ -> '_'\n\n This is not correct: when C is bound to A, \"f false A\" returns '2' (not '3')\n\n\n However, diagnostics do not take constructor rebinding into account.\n Notice, that due to module abstraction constructor rebinding is hidden.\n\n module X : sig type t = .. type t += A|B end = struct\n type t = ..\n type t += A\n type t += B=A\n end\n\n open X\n\n let f x = match x with\n | A -> '1'\n | B -> '2'\n | _ -> '_'\n\n The second clause above will NOT (and cannot) be flagged as useless.\n\n Finally, there are two compatibility functions:\n compat p q ---> 'syntactic compatibility, used for diagnostics.\n may_compat p q ---> a safe approximation of possible compat,\n for compilation\n\n*)\n\n\nlet is_absent tag row = row_field_repr (get_row_field tag !row) = Rabsent\n\nlet is_absent_pat d =\n match d.pat_desc with\n | Patterns.Head.Variant { tag; cstr_row; _ } -> is_absent tag cstr_row\n | _ -> false\n\nlet const_compare x y =\n match x,y with\n | Const_float f1, Const_float f2 ->\n Stdlib.compare (float_of_string f1) (float_of_string f2)\n | Const_string (s1, _, _), Const_string (s2, _, _) ->\n String.compare s1 s2\n | (Const_int _\n |Const_char _\n |Const_string (_, _, _)\n |Const_float _\n |Const_int32 _\n |Const_int64 _\n |Const_nativeint _\n ), _ -> Stdlib.compare x y\n\nlet records_args l1 l2 =\n (* Invariant: fields are already sorted by Typecore.type_label_a_list *)\n let rec combine r1 r2 l1 l2 = match l1,l2 with\n | [],[] -> List.rev r1, List.rev r2\n | [],(_,_,p2)::rem2 -> combine (omega::r1) (p2::r2) [] rem2\n | (_,_,p1)::rem1,[] -> combine (p1::r1) (omega::r2) rem1 []\n | (_,lbl1,p1)::rem1, ( _,lbl2,p2)::rem2 ->\n if lbl1.lbl_pos < lbl2.lbl_pos then\n combine (p1::r1) (omega::r2) rem1 l2\n else if lbl1.lbl_pos > lbl2.lbl_pos then\n combine (omega::r1) (p2::r2) l1 rem2\n else (* same label on both sides *)\n combine (p1::r1) (p2::r2) rem1 rem2 in\n combine [] [] l1 l2\n\n\n\nmodule Compat\n (Constr:sig\n val equal :\n Types.constructor_description ->\n Types.constructor_description ->\n bool\n end) = struct\n\n let rec compat p q = match p.pat_desc,q.pat_desc with\n(* Variables match any value *)\n | ((Tpat_any|Tpat_var _),_)\n | (_,(Tpat_any|Tpat_var _)) -> true\n(* Structural induction *)\n | Tpat_alias (p,_,_),_ -> compat p q\n | _,Tpat_alias (q,_,_) -> compat p q\n | Tpat_or (p1,p2,_),_ ->\n (compat p1 q || compat p2 q)\n | _,Tpat_or (q1,q2,_) ->\n (compat p q1 || compat p q2)\n(* Constructors, with special case for extension *)\n | Tpat_construct (_, c1, ps1, _), Tpat_construct (_, c2, ps2, _) ->\n Constr.equal c1 c2 && compats ps1 ps2\n(* More standard stuff *)\n | Tpat_variant(l1,op1, _), Tpat_variant(l2,op2,_) ->\n l1=l2 && ocompat op1 op2\n | Tpat_constant c1, Tpat_constant c2 ->\n const_compare c1 c2 = 0\n | Tpat_tuple ps, Tpat_tuple qs -> compats ps qs\n | Tpat_lazy p, Tpat_lazy q -> compat p q\n | Tpat_record (l1,_),Tpat_record (l2,_) ->\n let ps,qs = records_args l1 l2 in\n compats ps qs\n | Tpat_array ps, Tpat_array qs ->\n List.length ps = List.length qs &&\n compats ps qs\n | _,_ -> false\n\n and ocompat op oq = match op,oq with\n | None,None -> true\n | Some p,Some q -> compat p q\n | (None,Some _)|(Some _,None) -> false\n\n and compats ps qs = match ps,qs with\n | [], [] -> true\n | p::ps, q::qs -> compat p q && compats ps qs\n | _,_ -> false\n\nend\n\nmodule SyntacticCompat =\n Compat\n (struct\n let equal c1 c2 = Types.equal_tag c1.cstr_tag c2.cstr_tag\n end)\n\nlet compat = SyntacticCompat.compat\nand compats = SyntacticCompat.compats\n\n(* Due to (potential) rebinding, two extension constructors\n of the same arity type may equal *)\n\nexception Empty (* Empty pattern *)\n\n(****************************************)\n(* Utilities for retrieving type paths *)\n(****************************************)\n\n(* May need a clean copy, cf. PR#4745 *)\nlet clean_copy ty =\n if get_level ty = Btype.generic_level then ty\n else Subst.type_expr Subst.identity ty\n\nlet get_constructor_type_path ty tenv =\n let ty = Ctype.expand_head tenv (clean_copy ty) in\n match get_desc ty with\n | Tconstr (path,_,_) -> path\n | _ -> assert false\n\n(****************************)\n(* Utilities for matching *)\n(****************************)\n\n(* Check top matching *)\nlet simple_match d h =\n let open Patterns.Head in\n match d.pat_desc, h.pat_desc with\n | Construct c1, Construct c2 ->\n Types.equal_tag c1.cstr_tag c2.cstr_tag\n | Variant { tag = t1; _ }, Variant { tag = t2 } ->\n t1 = t2\n | Constant c1, Constant c2 -> const_compare c1 c2 = 0\n | Lazy, Lazy -> true\n | Record _, Record _ -> true\n | Tuple len1, Tuple len2\n | Array len1, Array len2 -> len1 = len2\n | _, Any -> true\n | _, _ -> false\n\n\n\n(* extract record fields as a whole *)\nlet record_arg ph =\n let open Patterns.Head in\n match ph.pat_desc with\n | Any -> []\n | Record args -> args\n | _ -> fatal_error \"Parmatch.as_record\"\n\n\nlet extract_fields lbls arg =\n let get_field pos arg =\n match List.find (fun (lbl,_) -> pos = lbl.lbl_pos) arg with\n | _, p -> p\n | exception Not_found -> omega\n in\n List.map (fun lbl -> get_field lbl.lbl_pos arg) lbls\n\n(* Build argument list when p2 >= p1, where p1 is a simple pattern *)\nlet simple_match_args discr head args =\n let open Patterns.Head in\n match head.pat_desc with\n | Constant _ -> []\n | Construct _\n | Variant _\n | Tuple _\n | Array _\n | Lazy -> args\n | Record lbls -> extract_fields (record_arg discr) (List.combine lbls args)\n | Any ->\n begin match discr.pat_desc with\n | Construct cstr -> Patterns.omegas cstr.cstr_arity\n | Variant { has_arg = true }\n | Lazy -> [Patterns.omega]\n | Record lbls -> omega_list lbls\n | Array len\n | Tuple len -> Patterns.omegas len\n | Variant { has_arg = false }\n | Any\n | Constant _ -> []\n end\n\n(* Consider a pattern matrix whose first column has been simplified to contain\n only _ or a head constructor\n | p1, r1...\n | p2, r2...\n | p3, r3...\n | ...\n\n We build a normalized /discriminating/ pattern from a pattern [q] by folding\n over the first column of the matrix, \"refining\" [q] as we go:\n\n - when we encounter a row starting with [Tuple] or [Lazy] then we\n can stop and return that head, as we cannot refine any further. Indeed,\n these constructors are alone in their signature, so they will subsume\n whatever other head we might find, as well as the head we're threading\n along.\n\n - when we find a [Record] then it is a bit more involved: it is also alone\n in its signature, however it might only be matching a subset of the\n record fields. We use these fields to refine our accumulator and keep going\n as another row might match on different fields.\n\n - rows starting with a wildcard do not bring any information, so we ignore\n them and keep going\n\n - if we encounter anything else (i.e. any other constructor), then we just\n stop and return our accumulator.\n*)\nlet discr_pat q pss =\n let open Patterns.Head in\n let rec refine_pat acc = function\n | [] -> acc\n | ((head, _), _) :: rows ->\n match head.pat_desc with\n | Any -> refine_pat acc rows\n | Tuple _ | Lazy -> head\n | Record lbls ->\n (* N.B. we could make this case \"simpler\" by refining the record case\n using [all_record_args].\n In which case we wouldn't need to fold over the first column for\n records.\n However it makes the witness we generate for the exhaustivity warning\n less pretty. *)\n let fields =\n List.fold_right (fun lbl r ->\n if List.exists (fun l -> l.lbl_pos = lbl.lbl_pos) r then\n r\n else\n lbl :: r\n ) lbls (record_arg acc)\n in\n let d = { head with pat_desc = Record fields } in\n refine_pat d rows\n | _ -> acc\n in\n let q, _ = deconstruct q in\n match q.pat_desc with\n (* short-circuiting: clearly if we have anything other than [Record] or\n [Any] to start with, we're not going to be able refine at all. So\n there's no point going over the matrix. *)\n | Any | Record _ -> refine_pat q pss\n | _ -> q\n\n(*\n In case a matching value is found, set actual arguments\n of the matching pattern.\n*)\n\nlet rec read_args xs r = match xs,r with\n| [],_ -> [],r\n| _::xs, arg::rest ->\n let args,rest = read_args xs rest in\n arg::args,rest\n| _,_ ->\n fatal_error \"Parmatch.read_args\"\n\nlet do_set_args ~erase_mutable q r = match q with\n| {pat_desc = Tpat_tuple omegas} ->\n let args,rest = read_args omegas r in\n make_pat (Tpat_tuple args) q.pat_type q.pat_env::rest\n| {pat_desc = Tpat_record (omegas,closed)} ->\n let args,rest = read_args omegas r in\n make_pat\n (Tpat_record\n (List.map2 (fun (lid, lbl,_) arg ->\n if\n erase_mutable &&\n (match lbl.lbl_mut with\n | Mutable -> true | Immutable -> false)\n then\n lid, lbl, omega\n else\n lid, lbl, arg)\n omegas args, closed))\n q.pat_type q.pat_env::\n rest\n| {pat_desc = Tpat_construct (lid, c, omegas, _)} ->\n let args,rest = read_args omegas r in\n make_pat\n (Tpat_construct (lid, c, args, None))\n q.pat_type q.pat_env::\n rest\n| {pat_desc = Tpat_variant (l, omega, row)} ->\n let arg, rest =\n match omega, r with\n Some _, a::r -> Some a, r\n | None, r -> None, r\n | _ -> assert false\n in\n make_pat\n (Tpat_variant (l, arg, row)) q.pat_type q.pat_env::\n rest\n| {pat_desc = Tpat_lazy _omega} ->\n begin match r with\n arg::rest ->\n make_pat (Tpat_lazy arg) q.pat_type q.pat_env::rest\n | _ -> fatal_error \"Parmatch.do_set_args (lazy)\"\n end\n| {pat_desc = Tpat_array omegas} ->\n let args,rest = read_args omegas r in\n make_pat\n (Tpat_array args) q.pat_type q.pat_env::\n rest\n| {pat_desc=Tpat_constant _|Tpat_any} ->\n q::r (* case any is used in matching.ml *)\n| _ -> fatal_error \"Parmatch.set_args\"\n\nlet set_args q r = do_set_args ~erase_mutable:false q r\nand set_args_erase_mutable q r = do_set_args ~erase_mutable:true q r\n\n(* Given a matrix of non-empty rows\n p1 :: r1...\n p2 :: r2...\n p3 :: r3...\n\n Simplify the first column [p1 p2 p3] by splitting all or-patterns.\n The result is a list of pairs\n ((pattern head, arguments), rest of row)\n\n For example,\n x :: r1\n (Some _) as y :: r2\n (None as x) as y :: r3\n (Some x | (None as x)) :: r4\n becomes\n (( _ , [ ] ), r1)\n (( Some, [_] ), r2)\n (( None, [ ] ), r3)\n (( Some, [x] ), r4)\n (( None, [ ] ), r4)\n *)\nlet simplify_head_pat ~add_column p ps k =\n let rec simplify_head_pat p ps k =\n match Patterns.General.(view p |> strip_vars).pat_desc with\n | `Or (p1,p2,_) -> simplify_head_pat p1 ps (simplify_head_pat p2 ps k)\n | #Patterns.Simple.view as view ->\n add_column (Patterns.Head.deconstruct { p with pat_desc = view }) ps k\n in simplify_head_pat p ps k\n\nlet rec simplify_first_col = function\n | [] -> []\n | [] :: _ -> assert false (* the rows are non-empty! *)\n | (p::ps) :: rows ->\n let add_column p ps k = (p, ps) :: k in\n simplify_head_pat ~add_column p ps (simplify_first_col rows)\n\n\n(* Builds the specialized matrix of [pss] according to the discriminating\n pattern head [d].\n See section 3.1 of http://moscova.inria.fr/~maranget/papers/warn/warn.pdf\n\n NOTES:\n - we are polymorphic on the type of matrices we work on, in particular a row\n might not simply be a [pattern list]. That's why we have the [extend_row]\n parameter.\n*)\nlet build_specialized_submatrix ~extend_row discr pss =\n let rec filter_rec = function\n | ((head, args), ps) :: pss ->\n if simple_match discr head\n then extend_row (simple_match_args discr head args) ps :: filter_rec pss\n else filter_rec pss\n | _ -> [] in\n filter_rec pss\n\n(* The \"default\" and \"specialized\" matrices of a given matrix.\n See section 3.1 of http://moscova.inria.fr/~maranget/papers/warn/warn.pdf .\n*)\ntype 'matrix specialized_matrices = {\n default : 'matrix;\n constrs : (Patterns.Head.t * 'matrix) list;\n}\n\n(* Consider a pattern matrix whose first column has been simplified\n to contain only _ or a head constructor\n | p1, r1...\n | p2, r2...\n | p3, r3...\n | ...\n\n We split this matrix into a list of /specialized/ sub-matrices, one for\n each head constructor appearing in the first column. For each row whose\n first column starts with a head constructor, remove this head\n column, prepend one column for each argument of the constructor,\n and add the resulting row in the sub-matrix corresponding to this\n head constructor.\n\n Rows whose left column is omega (the Any pattern _) may match any\n head constructor, so they are added to all sub-matrices.\n\n In the case where all the rows in the matrix have an omega on their first\n column, then there is only one /specialized/ sub-matrix, formed of all these\n omega rows.\n This matrix is also called the /default/ matrix.\n\n See the documentation of [build_specialized_submatrix] for an explanation of\n the [extend_row] parameter.\n*)\nlet build_specialized_submatrices ~extend_row discr rows =\n let extend_group discr p args r rs =\n let r = extend_row (simple_match_args discr p args) r in\n (discr, r :: rs)\n in\n\n (* insert a row of head [p] and rest [r] into the right group\n\n Note: with this implementation, the order of the groups\n is the order of their first row in the source order.\n This is a nice property to get exhaustivity counter-examples\n in source order.\n *)\n let rec insert_constr head args r = function\n | [] ->\n (* if no group matched this row, it has a head constructor that\n was never seen before; add a new sub-matrix for this head *)\n [extend_group head head args r []]\n | (q0,rs) as bd::env ->\n if simple_match q0 head\n then extend_group q0 head args r rs :: env\n else bd :: insert_constr head args r env\n in\n\n (* insert a row of head omega into all groups *)\n let insert_omega r env =\n List.map (fun (q0,rs) -> extend_group q0 Patterns.Head.omega [] r rs) env\n in\n\n let rec form_groups constr_groups omega_tails = function\n | [] -> (constr_groups, omega_tails)\n | ((head, args), tail) :: rest ->\n match head.pat_desc with\n | Patterns.Head.Any ->\n (* note that calling insert_omega here would be wrong\n as some groups may not have been formed yet, if the\n first row with this head pattern comes after in the list *)\n form_groups constr_groups (tail :: omega_tails) rest\n | _ ->\n form_groups\n (insert_constr head args tail constr_groups) omega_tails rest\n in\n\n let constr_groups, omega_tails =\n let initial_constr_group =\n let open Patterns.Head in\n match discr.pat_desc with\n | Record _ | Tuple _ | Lazy ->\n (* [discr] comes from [discr_pat], and in this case subsumes any of the\n patterns we could find on the first column of [rows]. So it is better\n to use it for our initial environment than any of the normalized\n pattern we might obtain from the first column. *)\n [discr,[]]\n | _ -> []\n in\n form_groups initial_constr_group [] rows\n in\n\n (* groups are accumulated in reverse order;\n we restore the order of rows in the source code *)\n let default = List.rev omega_tails in\n let constrs =\n List.fold_right insert_omega omega_tails constr_groups\n |> List.map (fun (discr, rs) -> (discr, List.rev rs))\n in\n { default; constrs; }\n\n(* Variant related functions *)\n\nlet set_last a =\n let rec loop = function\n | [] -> assert false\n | [_] -> [Patterns.General.erase a]\n | x::l -> x :: loop l\n in\n function\n | (_, []) -> (Patterns.Head.deconstruct a, [])\n | (first, row) -> (first, loop row)\n\n(* mark constructor lines for failure when they are incomplete *)\nlet mark_partial =\n let zero = make_pat (`Constant (Const_int 0)) Ctype.none Env.empty in\n List.map (fun ((hp, _), _ as ps) ->\n match hp.pat_desc with\n | Patterns.Head.Any -> ps\n | _ -> set_last zero ps\n )\n\nlet close_variant env row =\n let Row {fields; more; name=orig_name; closed; fixed} = row_repr row in\n let name, static =\n List.fold_left\n (fun (nm, static) (_tag,f) ->\n match row_field_repr f with\n | Reither(_, _, false) ->\n (* fixed=false means that this tag is not explicitly matched *)\n link_row_field_ext ~inside:f rf_absent;\n (None, static)\n | Reither (_, _, true) -> (nm, false)\n | Rabsent | Rpresent _ -> (nm, static))\n (orig_name, true) fields in\n if not closed || name != orig_name then begin\n let more' = if static then Btype.newgenty Tnil else Btype.newgenvar () in\n (* this unification cannot fail *)\n Ctype.unify env more\n (Btype.newgenty\n (Tvariant\n (create_row ~fields:[] ~more:more'\n ~closed:true ~name ~fixed)))\n end\n\n(*\n Check whether the first column of env makes up a complete signature or\n not. We work on the discriminating pattern heads of each sub-matrix: they\n are not omega/Any.\n*)\nlet full_match closing env = match env with\n| [] -> false\n| (discr, _) :: _ ->\n let open Patterns.Head in\n match discr.pat_desc with\n | Any -> assert false\n | Construct { cstr_tag = Cstr_extension _ ; _ } -> false\n | Construct c -> List.length env = c.cstr_consts + c.cstr_nonconsts\n | Variant { type_row; _ } ->\n let fields =\n List.map\n (fun (d, _) ->\n match d.pat_desc with\n | Variant { tag } -> tag\n | _ -> assert false)\n env\n in\n let row = type_row () in\n if closing && not (Btype.has_fixed_explanation row) then\n (* closing=true, we are considering the variant as closed *)\n List.for_all\n (fun (tag,f) ->\n match row_field_repr f with\n Rabsent | Reither(_, _, false) -> true\n | Reither (_, _, true)\n (* m=true, do not discard matched tags, rather warn *)\n | Rpresent _ -> List.mem tag fields)\n (row_fields row)\n else\n row_closed row &&\n List.for_all\n (fun (tag,f) ->\n row_field_repr f = Rabsent || List.mem tag fields)\n (row_fields row)\n | Constant Const_char _ ->\n List.length env = 256\n | Constant _\n | Array _ -> false\n | Tuple _\n | Record _\n | Lazy -> true\n\n(* Written as a non-fragile matching, PR#7451 originated from a fragile matching\n below. *)\nlet should_extend ext env = match ext with\n| None -> false\n| Some ext -> begin match env with\n | [] -> assert false\n | (p,_)::_ ->\n let open Patterns.Head in\n begin match p.pat_desc with\n | Construct {cstr_tag=(Cstr_constant _|Cstr_block _|Cstr_unboxed)} ->\n let path = get_constructor_type_path p.pat_type p.pat_env in\n Path.same path ext\n | Construct {cstr_tag=(Cstr_extension _)} -> false\n | Constant _ | Tuple _ | Variant _ | Record _ | Array _ | Lazy -> false\n | Any -> assert false\n end\nend\n\n(* build a pattern from a constructor description *)\nlet pat_of_constr ex_pat cstr =\n {ex_pat with pat_desc =\n Tpat_construct (mknoloc (Longident.Lident cstr.cstr_name),\n cstr, omegas cstr.cstr_arity, None)}\n\nlet orify x y = make_pat (Tpat_or (x, y, None)) x.pat_type x.pat_env\n\nlet rec orify_many = function\n| [] -> assert false\n| [x] -> x\n| x :: xs -> orify x (orify_many xs)\n\n(* build an or-pattern from a constructor list *)\nlet pat_of_constrs ex_pat cstrs =\n let ex_pat = Patterns.Head.to_omega_pattern ex_pat in\n if cstrs = [] then raise Empty else\n orify_many (List.map (pat_of_constr ex_pat) cstrs)\n\nlet pats_of_type ?(always=false) env ty =\n let ty' = Ctype.expand_head env ty in\n match get_desc ty' with\n | Tconstr (path, _, _) ->\n begin match Env.find_type_descrs path env with\n | exception Not_found -> [omega]\n | Type_variant (cstrs,_) when always || List.length cstrs <= 1 ||\n (* Only explode when all constructors are GADTs *)\n List.for_all (fun cd -> cd.cstr_generalized) cstrs ->\n List.map (pat_of_constr (make_pat Tpat_any ty env)) cstrs\n | Type_record (labels, _) ->\n let fields =\n List.map (fun ld ->\n mknoloc (Longident.Lident ld.lbl_name), ld, omega)\n labels\n in\n [make_pat (Tpat_record (fields, Closed)) ty env]\n | Type_variant _ | Type_abstract | Type_open -> [omega]\n end\n | Ttuple tl ->\n [make_pat (Tpat_tuple (omegas (List.length tl))) ty env]\n | _ -> [omega]\n\nlet rec get_variant_constructors env ty =\n match get_desc ty with\n | Tconstr (path,_,_) -> begin\n try match Env.find_type path env, Env.find_type_descrs path env with\n | _, Type_variant (cstrs,_) -> cstrs\n | {type_manifest = Some _}, _ ->\n get_variant_constructors env\n (Ctype.expand_head_once env (clean_copy ty))\n | _ -> fatal_error \"Parmatch.get_variant_constructors\"\n with Not_found ->\n fatal_error \"Parmatch.get_variant_constructors\"\n end\n | _ -> fatal_error \"Parmatch.get_variant_constructors\"\n\nmodule ConstructorSet = Set.Make(struct\n type t = constructor_description\n let compare c1 c2 = String.compare c1.cstr_name c2.cstr_name\nend)\n\n(* Sends back a pattern that complements the given constructors used_constrs *)\nlet complete_constrs constr used_constrs =\n let c = constr.pat_desc in\n let constrs = get_variant_constructors constr.pat_env c.cstr_res in\n let used_constrs = ConstructorSet.of_list used_constrs in\n let others =\n List.filter\n (fun cnstr -> not (ConstructorSet.mem cnstr used_constrs))\n constrs in\n (* Split constructors to put constant ones first *)\n let const, nonconst =\n List.partition (fun cnstr -> cnstr.cstr_arity = 0) others in\n const @ nonconst\n\nlet build_other_constrs env p =\n let open Patterns.Head in\n match p.pat_desc with\n | Construct ({ cstr_tag = Cstr_extension _ }) -> extra_pat\n | Construct\n ({ cstr_tag = Cstr_constant _ | Cstr_block _ | Cstr_unboxed } as c) ->\n let constr = { p with pat_desc = c } in\n let get_constr q =\n match q.pat_desc with\n | Construct c -> c\n | _ -> fatal_error \"Parmatch.get_constr\" in\n let used_constrs = List.map (fun (p,_) -> get_constr p) env in\n pat_of_constrs p (complete_constrs constr used_constrs)\n | _ -> extra_pat\n\n(* Auxiliary for build_other *)\n\nlet build_other_constant proj make first next p env =\n let all = List.map (fun (p, _) -> proj p.pat_desc) env in\n let rec try_const i =\n if List.mem i all\n then try_const (next i)\n else make_pat (make i) p.pat_type p.pat_env\n in try_const first\n\n(*\n Builds a pattern that is incompatible with all patterns in\n the first column of env\n*)\n\nlet some_private_tag = \"\"\n\nlet build_other ext env =\n match env with\n | [] -> omega\n | (d, _) :: _ ->\n let open Patterns.Head in\n match d.pat_desc with\n | Construct { cstr_tag = Cstr_extension _ } ->\n (* let c = {c with cstr_name = \"*extension*\"} in *) (* PR#7330 *)\n make_pat\n (Tpat_var (Ident.create_local \"*extension*\",\n {txt=\"*extension*\"; loc = d.pat_loc}))\n Ctype.none Env.empty\n | Construct _ ->\n begin match ext with\n | Some ext ->\n if Path.same ext (get_constructor_type_path d.pat_type d.pat_env)\n then\n extra_pat\n else\n build_other_constrs env d\n | _ ->\n build_other_constrs env d\n end\n | Variant { cstr_row; type_row } ->\n let tags =\n List.map\n (fun (d, _) ->\n match d.pat_desc with\n | Variant { tag } -> tag\n | _ -> assert false)\n env\n in\n let make_other_pat tag const =\n let arg = if const then None else Some Patterns.omega in\n make_pat (Tpat_variant(tag, arg, cstr_row)) d.pat_type d.pat_env\n in\n let row = type_row () in\n begin match\n List.fold_left\n (fun others (tag,f) ->\n if List.mem tag tags then others else\n match row_field_repr f with\n Rabsent (* | Reither _ *) -> others\n (* This one is called after erasing pattern info *)\n | Reither (c, _, _) -> make_other_pat tag c :: others\n | Rpresent arg -> make_other_pat tag (arg = None) :: others)\n [] (row_fields row)\n with\n [] ->\n let tag =\n if Btype.has_fixed_explanation row then some_private_tag else\n let rec mktag tag =\n if List.mem tag tags then mktag (tag ^ \"'\") else tag in\n mktag \"AnyOtherTag\"\n in make_other_pat tag true\n | pat::other_pats ->\n List.fold_left\n (fun p_res pat ->\n make_pat (Tpat_or (pat, p_res, None)) d.pat_type d.pat_env)\n pat other_pats\n end\n | Constant Const_char _ ->\n let all_chars =\n List.map\n (fun (p,_) -> match p.pat_desc with\n | Constant (Const_char c) -> c\n | _ -> assert false)\n env\n in\n let rec find_other i imax =\n if i > imax then raise Not_found\n else\n let ci = Char.chr i in\n if List.mem ci all_chars then\n find_other (i+1) imax\n else\n make_pat (Tpat_constant (Const_char ci)) d.pat_type d.pat_env\n in\n let rec try_chars = function\n | [] -> Patterns.omega\n | (c1,c2) :: rest ->\n try\n find_other (Char.code c1) (Char.code c2)\n with\n | Not_found -> try_chars rest\n in\n try_chars\n [ 'a', 'z' ; 'A', 'Z' ; '0', '9' ;\n ' ', '~' ; Char.chr 0 , Char.chr 255]\n | Constant Const_int _ ->\n build_other_constant\n (function Constant(Const_int i) -> i | _ -> assert false)\n (function i -> Tpat_constant(Const_int i))\n 0 succ d env\n | Constant Const_int32 _ ->\n build_other_constant\n (function Constant(Const_int32 i) -> i | _ -> assert false)\n (function i -> Tpat_constant(Const_int32 i))\n 0l Int32.succ d env\n | Constant Const_int64 _ ->\n build_other_constant\n (function Constant(Const_int64 i) -> i | _ -> assert false)\n (function i -> Tpat_constant(Const_int64 i))\n 0L Int64.succ d env\n | Constant Const_nativeint _ ->\n build_other_constant\n (function Constant(Const_nativeint i) -> i | _ -> assert false)\n (function i -> Tpat_constant(Const_nativeint i))\n 0n Nativeint.succ d env\n | Constant Const_string _ ->\n build_other_constant\n (function Constant(Const_string (s, _, _)) -> String.length s\n | _ -> assert false)\n (function i ->\n Tpat_constant\n (Const_string(String.make i '*',Location.none,None)))\n 0 succ d env\n | Constant Const_float _ ->\n build_other_constant\n (function Constant(Const_float f) -> float_of_string f\n | _ -> assert false)\n (function f -> Tpat_constant(Const_float (string_of_float f)))\n 0.0 (fun f -> f +. 1.0) d env\n | Array _ ->\n let all_lengths =\n List.map\n (fun (p,_) -> match p.pat_desc with\n | Array len -> len\n | _ -> assert false)\n env in\n let rec try_arrays l =\n if List.mem l all_lengths then try_arrays (l+1)\n else\n make_pat (Tpat_array (omegas l)) d.pat_type d.pat_env in\n try_arrays 0\n | _ -> Patterns.omega\n\nlet rec has_instance p = match p.pat_desc with\n | Tpat_variant (l,_,r) when is_absent l r -> false\n | Tpat_any | Tpat_var _ | Tpat_constant _ | Tpat_variant (_,None,_) -> true\n | Tpat_alias (p,_,_) | Tpat_variant (_,Some p,_) -> has_instance p\n | Tpat_or (p1,p2,_) -> has_instance p1 || has_instance p2\n | Tpat_construct (_,_,ps,_) | Tpat_tuple ps | Tpat_array ps ->\n has_instances ps\n | Tpat_record (lps,_) -> has_instances (List.map (fun (_,_,x) -> x) lps)\n | Tpat_lazy p\n -> has_instance p\n\nand has_instances = function\n | [] -> true\n | q::rem -> has_instance q && has_instances rem\n\n(*\n Core function :\n Is the last row of pattern matrix pss + qs satisfiable ?\n That is :\n Does there exists at least one value vector, es such that :\n 1- for all ps in pss ps # es (ps and es are not compatible)\n 2- qs <= es (es matches qs)\n\n ---\n\n In two places in the following function, we check the coherence of the first\n column of (pss + qs).\n If it is incoherent, then we exit early saying that (pss + qs) is not\n satisfiable (which is equivalent to saying \"oh, we shouldn't have considered\n that branch, no good result came come from here\").\n\n But what happens if we have a coherent but ill-typed column?\n - we might end up returning [false], which is equivalent to noticing the\n incompatibility: clearly this is fine.\n - if we end up returning [true] then we're saying that [qs] is useful while\n it is not. This is sad but not the end of the world, we're just allowing dead\n code to survive.\n*)\nlet rec satisfiable pss qs = match pss with\n| [] -> has_instances qs\n| _ ->\n match qs with\n | [] -> false\n | q::qs ->\n match Patterns.General.(view q |> strip_vars).pat_desc with\n | `Or(q1,q2,_) ->\n satisfiable pss (q1::qs) || satisfiable pss (q2::qs)\n | `Any ->\n let pss = simplify_first_col pss in\n if not (all_coherent (first_column pss)) then\n false\n else begin\n let { default; constrs } =\n let q0 = discr_pat Patterns.Simple.omega pss in\n build_specialized_submatrices ~extend_row:(@) q0 pss in\n if not (full_match false constrs) then\n satisfiable default qs\n else\n List.exists\n (fun (p,pss) ->\n not (is_absent_pat p) &&\n satisfiable pss\n (simple_match_args p Patterns.Head.omega [] @ qs))\n constrs\n end\n | `Variant (l,_,r) when is_absent l r -> false\n | #Patterns.Simple.view as view ->\n let q = { q with pat_desc = view } in\n let pss = simplify_first_col pss in\n let hq, qargs = Patterns.Head.deconstruct q in\n if not (all_coherent (hq :: first_column pss)) then\n false\n else begin\n let q0 = discr_pat q pss in\n satisfiable (build_specialized_submatrix ~extend_row:(@) q0 pss)\n (simple_match_args q0 hq qargs @ qs)\n end\n\n(* While [satisfiable] only checks whether the last row of [pss + qs] is\n satisfiable, this function returns the (possibly empty) list of vectors [es]\n which verify:\n 1- for all ps in pss, ps # es (ps and es are not compatible)\n 2- qs <= es (es matches qs)\n\n This is done to enable GADT handling\n\n For considerations regarding the coherence check, see the comment on\n [satisfiable] above. *)\nlet rec list_satisfying_vectors pss qs =\n match pss with\n | [] -> if has_instances qs then [qs] else []\n | _ ->\n match qs with\n | [] -> []\n | q :: qs ->\n match Patterns.General.(view q |> strip_vars).pat_desc with\n | `Or(q1,q2,_) ->\n list_satisfying_vectors pss (q1::qs) @\n list_satisfying_vectors pss (q2::qs)\n | `Any ->\n let pss = simplify_first_col pss in\n if not (all_coherent (first_column pss)) then\n []\n else begin\n let q0 = discr_pat Patterns.Simple.omega pss in\n let wild default_matrix p =\n List.map (fun qs -> p::qs)\n (list_satisfying_vectors default_matrix qs)\n in\n match build_specialized_submatrices ~extend_row:(@) q0 pss with\n | { default; constrs = [] } ->\n (* first column of pss is made of variables only *)\n wild default omega\n | { default; constrs = ((p,_)::_ as constrs) } ->\n let for_constrs () =\n List.flatten (\n List.map (fun (p,pss) ->\n if is_absent_pat p then\n []\n else\n let witnesses =\n list_satisfying_vectors pss\n (simple_match_args p Patterns.Head.omega [] @ qs)\n in\n let p = Patterns.Head.to_omega_pattern p in\n List.map (set_args p) witnesses\n ) constrs\n )\n in\n if full_match false constrs then for_constrs () else\n begin match p.pat_desc with\n | Construct _ ->\n (* activate this code\n for checking non-gadt constructors *)\n wild default (build_other_constrs constrs p)\n @ for_constrs ()\n | _ ->\n wild default Patterns.omega\n end\n end\n | `Variant (l, _, r) when is_absent l r -> []\n | #Patterns.Simple.view as view ->\n let q = { q with pat_desc = view } in\n let hq, qargs = Patterns.Head.deconstruct q in\n let pss = simplify_first_col pss in\n if not (all_coherent (hq :: first_column pss)) then\n []\n else begin\n let q0 = discr_pat q pss in\n List.map (set_args (Patterns.Head.to_omega_pattern q0))\n (list_satisfying_vectors\n (build_specialized_submatrix ~extend_row:(@) q0 pss)\n (simple_match_args q0 hq qargs @ qs))\n end\n\n(******************************************)\n(* Look for a row that matches some value *)\n(******************************************)\n\n(*\n Useful for seeing if the example of\n non-matched value can indeed be matched\n (by a guarded clause)\n*)\n\nlet rec do_match pss qs = match qs with\n| [] ->\n begin match pss with\n | []::_ -> true\n | _ -> false\n end\n| q::qs -> match Patterns.General.(view q |> strip_vars).pat_desc with\n | `Or (q1,q2,_) ->\n do_match pss (q1::qs) || do_match pss (q2::qs)\n | `Any ->\n let rec remove_first_column = function\n | (_::ps)::rem -> ps::remove_first_column rem\n | _ -> []\n in\n do_match (remove_first_column pss) qs\n | #Patterns.Simple.view as view ->\n let q = { q with pat_desc = view } in\n let q0, qargs = Patterns.Head.deconstruct q in\n let pss = simplify_first_col pss in\n (* [pss] will (or won't) match [q0 :: qs] regardless of the coherence of\n its first column. *)\n do_match\n (build_specialized_submatrix ~extend_row:(@) q0 pss)\n (qargs @ qs)\n\n(*\nlet print_pat pat =\n let rec string_of_pat pat =\n match pat.pat_desc with\n Tpat_var _ -> \"v\"\n | Tpat_any -> \"_\"\n | Tpat_alias (p, x) -> Printf.sprintf \"(%s) as ?\" (string_of_pat p)\n | Tpat_constant n -> \"0\"\n | Tpat_construct (_, lid, _) ->\n Printf.sprintf \"%s\" (String.concat \".\" (Longident.flatten lid.txt))\n | Tpat_lazy p ->\n Printf.sprintf \"(lazy %s)\" (string_of_pat p)\n | Tpat_or (p1,p2,_) ->\n Printf.sprintf \"(%s | %s)\" (string_of_pat p1) (string_of_pat p2)\n | Tpat_tuple list ->\n Printf.sprintf \"(%s)\" (String.concat \",\" (List.map string_of_pat list))\n | Tpat_variant (_, _, _) -> \"variant\"\n | Tpat_record (_, _) -> \"record\"\n | Tpat_array _ -> \"array\"\n in\n Printf.fprintf stderr \"PAT[%s]\\n%!\" (string_of_pat pat)\n*)\n\n(*\n Now another satisfiable function that additionally\n supplies an example of a matching value.\n\n This function should be called for exhaustiveness check only.\n*)\nlet rec exhaust (ext:Path.t option) pss n = match pss with\n| [] -> Seq.return (omegas n)\n| []::_ -> Seq.empty\n| [(p :: ps)] -> exhaust_single_row ext p ps n\n| pss -> specialize_and_exhaust ext pss n\n\nand exhaust_single_row ext p ps n =\n (* Shortcut: in the single-row case p :: ps we know that all\n counter-examples are either of the form\n counter-example(p) :: omegas\n or\n p :: counter-examples(ps)\n\n This is very interesting in the case where p contains\n or-patterns, as the non-shortcut path below would do a separate\n search for each constructor of the or-pattern, which can lead to\n an exponential blowup on examples such as\n\n | (A|B), (A|B), (A|B), (A|B) -> foo\n\n Note that this shortcut also applies to examples such as\n\n | A, A, A, A -> foo | (A|B), (A|B), (A|B), (A|B) -> bar\n\n thanks to the [get_mins] preprocessing step which will drop the\n first row (subsumed by the second). Code with this shape does\n occur naturally when people want to avoid fragile pattern\n matches: if A and B are the only two constructors, this is the\n best way to make a non-fragile distinction between \"all As\" and\n \"at least one B\".\n *)\n List.to_seq [Some p; None] |> Seq.flat_map\n (function\n | Some p ->\n let sub_witnesses = exhaust ext [ps] (n - 1) in\n Seq.map (fun row -> p :: row) sub_witnesses\n | None ->\n (* note: calling [exhaust] recursively of p would\n result in an infinite loop in the case n=1 *)\n let p_witnesses = specialize_and_exhaust ext [[p]] 1 in\n Seq.map (fun p_row -> p_row @ omegas (n - 1)) p_witnesses\n )\n\nand specialize_and_exhaust ext pss n =\n let pss = simplify_first_col pss in\n if not (all_coherent (first_column pss)) then\n (* We're considering an ill-typed branch, we won't actually be able to\n produce a well typed value taking that branch. *)\n Seq.empty\n else begin\n (* Assuming the first column is ill-typed but considered coherent, we\n might end up producing an ill-typed witness of non-exhaustivity\n corresponding to the current branch.\n\n If [exhaust] has been called by [do_check_partial], then the witnesses\n produced get typechecked and the ill-typed ones are discarded.\n\n If [exhaust] has been called by [do_check_fragile], then it is possible\n we might fail to warn the user that the matching is fragile. See for\n example testsuite/tests/warnings/w04_failure.ml. *)\n let q0 = discr_pat Patterns.Simple.omega pss in\n match build_specialized_submatrices ~extend_row:(@) q0 pss with\n | { default; constrs = [] } ->\n (* first column of pss is made of variables only *)\n let sub_witnesses = exhaust ext default (n-1) in\n let q0 = Patterns.Head.to_omega_pattern q0 in\n Seq.map (fun row -> q0::row) sub_witnesses\n | { default; constrs } ->\n let try_non_omega (p,pss) =\n if is_absent_pat p then\n Seq.empty\n else\n let sub_witnesses =\n exhaust\n ext pss\n (List.length (simple_match_args p Patterns.Head.omega [])\n + n - 1)\n in\n let p = Patterns.Head.to_omega_pattern p in\n Seq.map (set_args p) sub_witnesses\n in\n let try_omega () =\n if full_match false constrs && not (should_extend ext constrs) then\n Seq.empty\n else\n let sub_witnesses = exhaust ext default (n-1) in\n match build_other ext constrs with\n | exception Empty ->\n (* cannot occur, since constructors don't make\n a full signature *)\n fatal_error \"Parmatch.exhaust\"\n | p ->\n Seq.map (fun tail -> p :: tail) sub_witnesses\n in\n (* Lazily compute witnesses for all constructor submatrices\n (Some constr_mat) then the wildcard/default submatrix (None).\n Note that the call to [try_omega ()] is delayed to after\n all constructor matrices have been traversed. *)\n List.map (fun constr_mat -> Some constr_mat) constrs @ [None]\n |> List.to_seq\n |> Seq.flat_map\n (function\n | Some constr_mat -> try_non_omega constr_mat\n | None -> try_omega ())\n end\n\nlet exhaust ext pss n =\n exhaust ext pss n\n |> Seq.map (function\n | [x] -> x\n | _ -> assert false)\n\n(*\n Another exhaustiveness check, enforcing variant typing.\n Note that it does not check exact exhaustiveness, but whether a\n matching could be made exhaustive by closing all variant types.\n When this is true of all other columns, the current column is left\n open (even if it means that the whole matching is not exhaustive as\n a result).\n When this is false for the matrix minus the current column, and the\n current column is composed of variant tags, we close the variant\n (even if it doesn't help in making the matching exhaustive).\n*)\n\nlet rec pressure_variants tdefs = function\n | [] -> false\n | []::_ -> true\n | pss ->\n let pss = simplify_first_col pss in\n if not (all_coherent (first_column pss)) then\n true\n else begin\n let q0 = discr_pat Patterns.Simple.omega pss in\n match build_specialized_submatrices ~extend_row:(@) q0 pss with\n | { default; constrs = [] } -> pressure_variants tdefs default\n | { default; constrs } ->\n let rec try_non_omega = function\n | (_p,pss) :: rem ->\n let ok = pressure_variants tdefs pss in\n (* The order below matters : we want [pressure_variants] to be\n called on all the specialized submatrices because we might\n close some variant in any of them regardless of whether [ok]\n is true for [pss] or not *)\n try_non_omega rem && ok\n | [] -> true\n in\n if full_match (tdefs=None) constrs then\n try_non_omega constrs\n else if tdefs = None then\n pressure_variants None default\n else\n let full = full_match true constrs in\n let ok =\n if full then\n try_non_omega constrs\n else begin\n let { constrs = partial_constrs; _ } =\n build_specialized_submatrices ~extend_row:(@) q0\n (mark_partial pss)\n in\n try_non_omega partial_constrs\n end\n in\n begin match constrs, tdefs with\n | [], _\n | _, None -> ()\n | (d, _) :: _, Some env ->\n match d.pat_desc with\n | Variant { type_row; _ } ->\n let row = type_row () in\n if Btype.has_fixed_explanation row\n || pressure_variants None default then ()\n else close_variant env row\n | _ -> ()\n end;\n ok\n end\n\n\n(* Yet another satisfiable function *)\n\n(*\n This time every_satisfiable pss qs checks the\n utility of every expansion of qs.\n Expansion means expansion of or-patterns inside qs\n*)\n\ntype answer =\n | Used (* Useful pattern *)\n | Unused (* Useless pattern *)\n | Upartial of Typedtree.pattern list (* Mixed, with list of useless ones *)\n\n\n\n(* this row type enable column processing inside the matrix\n - left -> elements not to be processed,\n - right -> elements to be processed\n*)\ntype usefulness_row =\n {no_ors : pattern list ; ors : pattern list ; active : pattern list}\n\n(*\nlet pretty_row {ors=ors ; no_ors=no_ors; active=active} =\n pretty_line ors ; prerr_string \" *\" ;\n pretty_line no_ors ; prerr_string \" *\" ;\n pretty_line active\n\nlet pretty_rows rs =\n prerr_endline \"begin matrix\" ;\n List.iter\n (fun r ->\n pretty_row r ;\n prerr_endline \"\")\n rs ;\n prerr_endline \"end matrix\"\n*)\n\n(* Initial build *)\nlet make_row ps = {ors=[] ; no_ors=[]; active=ps}\n\nlet make_rows pss = List.map make_row pss\n\n\n(* Useful to detect and expand or pats inside as pats *)\nlet is_var p = match Patterns.General.(view p |> strip_vars).pat_desc with\n| `Any -> true\n| _ -> false\n\nlet is_var_column rs =\n List.for_all\n (fun r -> match r.active with\n | p::_ -> is_var p\n | [] -> assert false)\n rs\n\n(* Standard or-args for left-to-right matching *)\nlet rec or_args p = match p.pat_desc with\n| Tpat_or (p1,p2,_) -> p1,p2\n| Tpat_alias (p,_,_) -> or_args p\n| _ -> assert false\n\n(* Just remove current column *)\nlet remove r = match r.active with\n| _::rem -> {r with active=rem}\n| [] -> assert false\n\nlet remove_column rs = List.map remove rs\n\n(* Current column has been processed *)\nlet push_no_or r = match r.active with\n| p::rem -> { r with no_ors = p::r.no_ors ; active=rem}\n| [] -> assert false\n\nlet push_or r = match r.active with\n| p::rem -> { r with ors = p::r.ors ; active=rem}\n| [] -> assert false\n\nlet push_or_column rs = List.map push_or rs\nand push_no_or_column rs = List.map push_no_or rs\n\nlet rec simplify_first_usefulness_col = function\n | [] -> []\n | row :: rows ->\n match row.active with\n | [] -> assert false (* the rows are non-empty! *)\n | p :: ps ->\n let add_column p ps k =\n (p, { row with active = ps }) :: k in\n simplify_head_pat ~add_column p ps\n (simplify_first_usefulness_col rows)\n\n(* Back to normal matrices *)\nlet make_vector r = List.rev r.no_ors\n\nlet make_matrix rs = List.map make_vector rs\n\n\n(* Standard union on answers *)\nlet union_res r1 r2 = match r1, r2 with\n| (Unused,_)\n| (_, Unused) -> Unused\n| Used,_ -> r2\n| _, Used -> r1\n| Upartial u1, Upartial u2 -> Upartial (u1@u2)\n\n(* propose or pats for expansion *)\nlet extract_elements qs =\n let rec do_rec seen = function\n | [] -> []\n | q::rem ->\n {no_ors= List.rev_append seen rem @ qs.no_ors ;\n ors=[] ;\n active = [q]}::\n do_rec (q::seen) rem in\n do_rec [] qs.ors\n\n(* idem for matrices *)\nlet transpose rs = match rs with\n| [] -> assert false\n| r::rem ->\n let i = List.map (fun x -> [x]) r in\n List.fold_left\n (List.map2 (fun r x -> x::r))\n i rem\n\nlet extract_columns pss qs = match pss with\n| [] -> List.map (fun _ -> []) qs.ors\n| _ ->\n let rows = List.map extract_elements pss in\n transpose rows\n\n(* Core function\n The idea is to first look for or patterns (recursive case), then\n check or-patterns argument usefulness (terminal case)\n*)\n\nlet rec every_satisfiables pss qs = match qs.active with\n| [] ->\n (* qs is now partitionned, check usefulness *)\n begin match qs.ors with\n | [] -> (* no or-patterns *)\n if satisfiable (make_matrix pss) (make_vector qs) then\n Used\n else\n Unused\n | _ -> (* n or-patterns -> 2n expansions *)\n List.fold_right2\n (fun pss qs r -> match r with\n | Unused -> Unused\n | _ ->\n match qs.active with\n | [q] ->\n let q1,q2 = or_args q in\n let r_loc = every_both pss qs q1 q2 in\n union_res r r_loc\n | _ -> assert false)\n (extract_columns pss qs) (extract_elements qs)\n Used\n end\n| q::rem ->\n begin match Patterns.General.(view q |> strip_vars).pat_desc with\n | `Any ->\n if is_var_column pss then\n (* forget about ``all-variable'' columns now *)\n every_satisfiables (remove_column pss) (remove qs)\n else\n (* otherwise this is direct food for satisfiable *)\n every_satisfiables (push_no_or_column pss) (push_no_or qs)\n | `Or (q1,q2,_) ->\n if\n q1.pat_loc.Location.loc_ghost &&\n q2.pat_loc.Location.loc_ghost\n then\n (* syntactically generated or-pats should not be expanded *)\n every_satisfiables (push_no_or_column pss) (push_no_or qs)\n else\n (* this is a real or-pattern *)\n every_satisfiables (push_or_column pss) (push_or qs)\n | `Variant (l,_,r) when is_absent l r -> (* Ah Jacques... *)\n Unused\n | #Patterns.Simple.view as view ->\n let q = { q with pat_desc = view } in\n (* standard case, filter matrix *)\n let pss = simplify_first_usefulness_col pss in\n let hq, args = Patterns.Head.deconstruct q in\n (* The handling of incoherent matrices is kept in line with\n [satisfiable] *)\n if not (all_coherent (hq :: first_column pss)) then\n Unused\n else begin\n let q0 = discr_pat q pss in\n every_satisfiables\n (build_specialized_submatrix q0 pss\n ~extend_row:(fun ps r -> { r with active = ps @ r.active }))\n {qs with active=simple_match_args q0 hq args @ rem}\n end\n end\n\n(*\n This function ``every_both'' performs the usefulness check\n of or-pat q1|q2.\n The trick is to call every_satisfied twice with\n current active columns restricted to q1 and q2,\n That way,\n - others orpats in qs.ors will not get expanded.\n - all matching work performed on qs.no_ors is not performed again.\n *)\nand every_both pss qs q1 q2 =\n let qs1 = {qs with active=[q1]}\n and qs2 = {qs with active=[q2]} in\n let r1 = every_satisfiables pss qs1\n and r2 = every_satisfiables (if compat q1 q2 then qs1::pss else pss) qs2 in\n match r1 with\n | Unused ->\n begin match r2 with\n | Unused -> Unused\n | Used -> Upartial [q1]\n | Upartial u2 -> Upartial (q1::u2)\n end\n | Used ->\n begin match r2 with\n | Unused -> Upartial [q2]\n | _ -> r2\n end\n | Upartial u1 ->\n begin match r2 with\n | Unused -> Upartial (u1@[q2])\n | Used -> r1\n | Upartial u2 -> Upartial (u1 @ u2)\n end\n\n\n\n\n(* le_pat p q means, forall V, V matches q implies V matches p *)\nlet rec le_pat p q =\n match (p.pat_desc, q.pat_desc) with\n | (Tpat_var _|Tpat_any),_ -> true\n | Tpat_alias(p,_,_), _ -> le_pat p q\n | _, Tpat_alias(q,_,_) -> le_pat p q\n | Tpat_constant(c1), Tpat_constant(c2) -> const_compare c1 c2 = 0\n | Tpat_construct(_,c1,ps,_), Tpat_construct(_,c2,qs,_) ->\n Types.equal_tag c1.cstr_tag c2.cstr_tag && le_pats ps qs\n | Tpat_variant(l1,Some p1,_), Tpat_variant(l2,Some p2,_) ->\n (l1 = l2 && le_pat p1 p2)\n | Tpat_variant(l1,None,_r1), Tpat_variant(l2,None,_) ->\n l1 = l2\n | Tpat_variant(_,_,_), Tpat_variant(_,_,_) -> false\n | Tpat_tuple(ps), Tpat_tuple(qs) -> le_pats ps qs\n | Tpat_lazy p, Tpat_lazy q -> le_pat p q\n | Tpat_record (l1,_), Tpat_record (l2,_) ->\n let ps,qs = records_args l1 l2 in\n le_pats ps qs\n | Tpat_array(ps), Tpat_array(qs) ->\n List.length ps = List.length qs && le_pats ps qs\n(* In all other cases, enumeration is performed *)\n | _,_ -> not (satisfiable [[p]] [q])\n\nand le_pats ps qs =\n match ps,qs with\n p::ps, q::qs -> le_pat p q && le_pats ps qs\n | _, _ -> true\n\nlet get_mins le ps =\n let rec select_rec r = function\n [] -> r\n | p::ps ->\n if List.exists (fun p0 -> le p0 p) ps\n then select_rec r ps\n else select_rec (p::r) ps in\n select_rec [] (select_rec [] ps)\n\n(*\n lub p q is a pattern that matches all values matched by p and q\n may raise Empty, when p and q are not compatible\n*)\n\nlet rec lub p q = match p.pat_desc,q.pat_desc with\n| Tpat_alias (p,_,_),_ -> lub p q\n| _,Tpat_alias (q,_,_) -> lub p q\n| (Tpat_any|Tpat_var _),_ -> q\n| _,(Tpat_any|Tpat_var _) -> p\n| Tpat_or (p1,p2,_),_ -> orlub p1 p2 q\n| _,Tpat_or (q1,q2,_) -> orlub q1 q2 p (* Thanks god, lub is commutative *)\n| Tpat_constant c1, Tpat_constant c2 when const_compare c1 c2 = 0 -> p\n| Tpat_tuple ps, Tpat_tuple qs ->\n let rs = lubs ps qs in\n make_pat (Tpat_tuple rs) p.pat_type p.pat_env\n| Tpat_lazy p, Tpat_lazy q ->\n let r = lub p q in\n make_pat (Tpat_lazy r) p.pat_type p.pat_env\n| Tpat_construct (lid,c1,ps1,_), Tpat_construct (_,c2,ps2,_)\n when Types.equal_tag c1.cstr_tag c2.cstr_tag ->\n let rs = lubs ps1 ps2 in\n make_pat (Tpat_construct (lid, c1, rs, None))\n p.pat_type p.pat_env\n| Tpat_variant(l1,Some p1,row), Tpat_variant(l2,Some p2,_)\n when l1=l2 ->\n let r=lub p1 p2 in\n make_pat (Tpat_variant (l1,Some r,row)) p.pat_type p.pat_env\n| Tpat_variant (l1,None,_row), Tpat_variant(l2,None,_)\n when l1 = l2 -> p\n| Tpat_record (l1,closed),Tpat_record (l2,_) ->\n let rs = record_lubs l1 l2 in\n make_pat (Tpat_record (rs, closed)) p.pat_type p.pat_env\n| Tpat_array ps, Tpat_array qs\n when List.length ps = List.length qs ->\n let rs = lubs ps qs in\n make_pat (Tpat_array rs) p.pat_type p.pat_env\n| _,_ ->\n raise Empty\n\nand orlub p1 p2 q =\n try\n let r1 = lub p1 q in\n try\n {q with pat_desc=(Tpat_or (r1,lub p2 q,None))}\n with\n | Empty -> r1\nwith\n| Empty -> lub p2 q\n\nand record_lubs l1 l2 =\n let rec lub_rec l1 l2 = match l1,l2 with\n | [],_ -> l2\n | _,[] -> l1\n | (lid1, lbl1,p1)::rem1, (lid2, lbl2,p2)::rem2 ->\n if lbl1.lbl_pos < lbl2.lbl_pos then\n (lid1, lbl1,p1)::lub_rec rem1 l2\n else if lbl2.lbl_pos < lbl1.lbl_pos then\n (lid2, lbl2,p2)::lub_rec l1 rem2\n else\n (lid1, lbl1,lub p1 p2)::lub_rec rem1 rem2 in\n lub_rec l1 l2\n\nand lubs ps qs = match ps,qs with\n| p::ps, q::qs -> lub p q :: lubs ps qs\n| _,_ -> []\n\n\n(******************************)\n(* Exported variant closing *)\n(******************************)\n\n(* Apply pressure to variants *)\n\nlet pressure_variants tdefs patl =\n ignore (pressure_variants\n (Some tdefs)\n (List.map (fun p -> [p; omega]) patl))\n\nlet pressure_variants_in_computation_pattern tdefs patl =\n let add_row pss p_opt =\n match p_opt with\n | None -> pss\n | Some p -> p :: pss\n in\n let val_pss, exn_pss =\n List.fold_right (fun pat (vpss, epss)->\n let (vp, ep) = split_pattern pat in\n add_row vpss vp, add_row epss ep\n ) patl ([], [])\n in\n pressure_variants tdefs val_pss;\n pressure_variants tdefs exn_pss\n\n(*****************************)\n(* Utilities for diagnostics *)\n(*****************************)\n\n(*\n Build up a working pattern matrix by forgetting\n about guarded patterns\n*)\n\nlet rec initial_matrix = function\n [] -> []\n | {c_guard=Some _} :: rem -> initial_matrix rem\n | {c_guard=None; c_lhs=p} :: rem -> [p] :: initial_matrix rem\n\n(*\n Build up a working pattern matrix by keeping\n only the patterns which are guarded\n*)\nlet rec initial_only_guarded = function\n | [] -> []\n | { c_guard = None; _} :: rem ->\n initial_only_guarded rem\n | { c_lhs = pat; _ } :: rem ->\n [pat] :: initial_only_guarded rem\n\n\n(************************)\n(* Exhaustiveness check *)\n(************************)\n\n(* conversion from Typedtree.pattern to Parsetree.pattern list *)\nmodule Conv = struct\n open Parsetree\n let mkpat desc = Ast_helper.Pat.mk desc\n\n let name_counter = ref 0\n let fresh name =\n let current = !name_counter in\n name_counter := !name_counter + 1;\n \"#$\" ^ name ^ Int.to_string current\n\n let conv typed =\n let constrs = Hashtbl.create 7 in\n let labels = Hashtbl.create 7 in\n let rec loop pat =\n match pat.pat_desc with\n Tpat_or (pa,pb,_) ->\n mkpat (Ppat_or (loop pa, loop pb))\n | Tpat_var (_, ({txt=\"*extension*\"} as nm)) -> (* PR#7330 *)\n mkpat (Ppat_var nm)\n | Tpat_any\n | Tpat_var _ ->\n mkpat Ppat_any\n | Tpat_constant c ->\n mkpat (Ppat_constant (Untypeast.constant c))\n | Tpat_alias (p,_,_) -> loop p\n | Tpat_tuple lst ->\n mkpat (Ppat_tuple (List.map loop lst))\n | Tpat_construct (cstr_lid, cstr, lst, _) ->\n let id = fresh cstr.cstr_name in\n let lid = { cstr_lid with txt = Longident.Lident id } in\n Hashtbl.add constrs id cstr;\n let arg =\n match List.map loop lst with\n | [] -> None\n | [p] -> Some ([], p)\n | lst -> Some ([], mkpat (Ppat_tuple lst))\n in\n mkpat (Ppat_construct(lid, arg))\n | Tpat_variant(label,p_opt,_row_desc) ->\n let arg = Option.map loop p_opt in\n mkpat (Ppat_variant(label, arg))\n | Tpat_record (subpatterns, _closed_flag) ->\n let fields =\n List.map\n (fun (_, lbl, p) ->\n let id = fresh lbl.lbl_name in\n Hashtbl.add labels id lbl;\n (mknoloc (Longident.Lident id), loop p))\n subpatterns\n in\n mkpat (Ppat_record (fields, Open))\n | Tpat_array lst ->\n mkpat (Ppat_array (List.map loop lst))\n | Tpat_lazy p ->\n mkpat (Ppat_lazy (loop p))\n in\n let ps = loop typed in\n (ps, constrs, labels)\nend\n\n\n(* Whether the counter-example contains an extension pattern *)\nlet contains_extension pat =\n exists_pattern\n (function\n | {pat_desc=Tpat_var (_, {txt=\"*extension*\"})} -> true\n | _ -> false)\n pat\n\n(* Build a pattern from its expected type *)\ntype pat_explosion = PE_single | PE_gadt_cases\ntype ppat_of_type =\n | PT_empty\n | PT_any\n | PT_pattern of\n pat_explosion *\n Parsetree.pattern *\n (string, constructor_description) Hashtbl.t *\n (string, label_description) Hashtbl.t\n\nlet ppat_of_type env ty =\n match pats_of_type env ty with\n | [] -> PT_empty\n | [{pat_desc = Tpat_any}] -> PT_any\n | [pat] ->\n let (ppat, constrs, labels) = Conv.conv pat in\n PT_pattern (PE_single, ppat, constrs, labels)\n | pats ->\n let (ppat, constrs, labels) = Conv.conv (orify_many pats) in\n PT_pattern (PE_gadt_cases, ppat, constrs, labels)\n\nlet typecheck ~pred p =\n let (pattern,constrs,labels) = Conv.conv p in\n pred constrs labels pattern\n\nlet do_check_partial ~pred loc casel pss = match pss with\n| [] ->\n (*\n This can occur\n - For empty matches generated by ocamlp4 (no warning)\n - when all patterns have guards (then, casel <> [])\n (specific warning)\n Then match MUST be considered non-exhaustive,\n otherwise compilation of PM is broken.\n *)\n begin match casel with\n | [] -> ()\n | _ ->\n if Warnings.is_active Warnings.All_clauses_guarded then\n Location.prerr_warning loc Warnings.All_clauses_guarded\n end ;\n Partial\n| ps::_ ->\n let counter_examples =\n exhaust None pss (List.length ps)\n |> Seq.filter_map (typecheck ~pred) in\n match counter_examples () with\n | Seq.Nil -> Total\n | Seq.Cons (v, _rest) ->\n if Warnings.is_active (Warnings.Partial_match \"\") then begin\n let errmsg =\n try\n let buf = Buffer.create 16 in\n let fmt = Format.formatter_of_buffer buf in\n Printpat.top_pretty fmt v;\n if do_match (initial_only_guarded casel) [v] then\n Buffer.add_string buf\n \"\\n(However, some guarded clause may match this value.)\";\n if contains_extension v then\n Buffer.add_string buf\n \"\\nMatching over values of extensible variant types \\\n (the *extension* above)\\n\\\n must include a wild card pattern in order to be exhaustive.\"\n ;\n Buffer.contents buf\n with _ ->\n \"\"\n in\n Location.prerr_warning loc (Warnings.Partial_match errmsg)\n end;\n Partial\n\n(*****************)\n(* Fragile check *)\n(*****************)\n\n(* Collect all data types in a pattern *)\n\nlet rec add_path path = function\n | [] -> [path]\n | x::rem as paths ->\n if Path.same path x then paths\n else x::add_path path rem\n\nlet extendable_path path =\n not\n (Path.same path Predef.path_bool ||\n Path.same path Predef.path_list ||\n Path.same path Predef.path_unit ||\n Path.same path Predef.path_option)\n\nlet rec collect_paths_from_pat r p = match p.pat_desc with\n| Tpat_construct(_, {cstr_tag=(Cstr_constant _|Cstr_block _|Cstr_unboxed)},\n ps, _) ->\n let path = get_constructor_type_path p.pat_type p.pat_env in\n List.fold_left\n collect_paths_from_pat\n (if extendable_path path then add_path path r else r)\n ps\n| Tpat_any|Tpat_var _|Tpat_constant _| Tpat_variant (_,None,_) -> r\n| Tpat_tuple ps | Tpat_array ps\n| Tpat_construct (_, {cstr_tag=Cstr_extension _}, ps, _)->\n List.fold_left collect_paths_from_pat r ps\n| Tpat_record (lps,_) ->\n List.fold_left\n (fun r (_, _, p) -> collect_paths_from_pat r p)\n r lps\n| Tpat_variant (_, Some p, _) | Tpat_alias (p,_,_) -> collect_paths_from_pat r p\n| Tpat_or (p1,p2,_) ->\n collect_paths_from_pat (collect_paths_from_pat r p1) p2\n| Tpat_lazy p\n ->\n collect_paths_from_pat r p\n\n\n(*\n Actual fragile check\n 1. Collect data types in the patterns of the match.\n 2. One exhaustivity check per datatype, considering that\n the type is extended.\n*)\n\nlet do_check_fragile loc casel pss =\n let exts =\n List.fold_left\n (fun r c -> collect_paths_from_pat r c.c_lhs)\n [] casel in\n match exts with\n | [] -> ()\n | _ -> match pss with\n | [] -> ()\n | ps::_ ->\n List.iter\n (fun ext ->\n let witnesses = exhaust (Some ext) pss (List.length ps) in\n match witnesses () with\n | Seq.Nil ->\n Location.prerr_warning\n loc\n (Warnings.Fragile_match (Path.name ext))\n | Seq.Cons _ -> ())\n exts\n\n(********************************)\n(* Exported unused clause check *)\n(********************************)\n\nlet check_unused pred casel =\n if Warnings.is_active Warnings.Redundant_case\n || List.exists (fun c -> c.c_rhs.exp_desc = Texp_unreachable) casel then\n let rec do_rec pref = function\n | [] -> ()\n | {c_lhs=q; c_guard; c_rhs} :: rem ->\n let qs = [q] in\n begin try\n let pss =\n (* prev was accumulated in reverse order;\n restore source order to get ordered counter-examples *)\n List.rev pref\n |> List.filter (compats qs)\n |> get_mins le_pats in\n (* First look for redundant or partially redundant patterns *)\n let r = every_satisfiables (make_rows pss) (make_row qs) in\n let refute = (c_rhs.exp_desc = Texp_unreachable) in\n (* Do not warn for unused [pat -> .] *)\n if r = Unused && refute then () else\n let r =\n (* Do not refine if either:\n - we already know the clause is unused\n - the clause under consideration is not a refutation clause\n and either:\n + there are no other lines\n + we do not care whether the types prevent this clause to\n be reached.\n If the clause under consideration *is* a refutation clause\n then we do need to check more carefully whether it can be\n refuted or not. *)\n let skip =\n r = Unused || (not refute && pref = []) ||\n not(refute || Warnings.is_active Warnings.Unreachable_case) in\n if skip then r else\n (* Then look for empty patterns *)\n let sfs = list_satisfying_vectors pss qs in\n if sfs = [] then Unused else\n let sfs =\n List.map (function [u] -> u | _ -> assert false) sfs in\n let u = orify_many sfs in\n (*Format.eprintf \"%a@.\" pretty_val u;*)\n let (pattern,constrs,labels) = Conv.conv u in\n let pattern = {pattern with Parsetree.ppat_loc = q.pat_loc} in\n match pred refute constrs labels pattern with\n None when not refute ->\n Location.prerr_warning q.pat_loc Warnings.Unreachable_case;\n Used\n | _ -> r\n in\n match r with\n | Unused ->\n Location.prerr_warning\n q.pat_loc Warnings.Redundant_case\n | Upartial ps ->\n List.iter\n (fun p ->\n Location.prerr_warning\n p.pat_loc Warnings.Redundant_subpat)\n ps\n | Used -> ()\n with Empty | Not_found -> assert false\n end ;\n\n if c_guard <> None then\n do_rec pref rem\n else\n do_rec ([q]::pref) rem in\n\n do_rec [] casel\n\n(*********************************)\n(* Exported irrefutability tests *)\n(*********************************)\n\nlet irrefutable pat = le_pat pat omega\n\nlet inactive ~partial pat =\n match partial with\n | Partial -> false\n | Total -> begin\n let rec loop pat =\n match pat.pat_desc with\n | Tpat_lazy _ | Tpat_array _ ->\n false\n | Tpat_any | Tpat_var _ | Tpat_variant (_, None, _) ->\n true\n | Tpat_constant c -> begin\n match c with\n | Const_string _ -> Config.safe_string\n | Const_int _ | Const_char _ | Const_float _\n | Const_int32 _ | Const_int64 _ | Const_nativeint _ -> true\n end\n | Tpat_tuple ps | Tpat_construct (_, _, ps, _) ->\n List.for_all (fun p -> loop p) ps\n | Tpat_alias (p,_,_) | Tpat_variant (_, Some p, _) ->\n loop p\n | Tpat_record (ldps,_) ->\n List.for_all\n (fun (_, lbl, p) -> lbl.lbl_mut = Immutable && loop p)\n ldps\n | Tpat_or (p,q,_) ->\n loop p && loop q\n in\n loop pat\n end\n\n\n\n\n\n\n\n(*********************************)\n(* Exported exhaustiveness check *)\n(*********************************)\n\n(*\n Fragile check is performed when required and\n on exhaustive matches only.\n*)\n\nlet check_partial pred loc casel =\n let pss = initial_matrix casel in\n let pss = get_mins le_pats pss in\n let total = do_check_partial ~pred loc casel pss in\n if\n total = Total && Warnings.is_active (Warnings.Fragile_match \"\")\n then begin\n do_check_fragile loc casel pss\n end ;\n total\n\n(*************************************)\n(* Ambiguous variable in or-patterns *)\n(*************************************)\n\n(* Specification: ambiguous variables in or-patterns.\n\n The semantics of or-patterns in OCaml is specified with\n a left-to-right bias: a value [v] matches the pattern [p | q] if it\n matches [p] or [q], but if it matches both, the environment\n captured by the match is the environment captured by [p], never the\n one captured by [q].\n\n While this property is generally well-understood, one specific case\n where users expect a different semantics is when a pattern is\n followed by a when-guard: [| p when g -> e]. Consider for example:\n\n | ((Const x, _) | (_, Const x)) when is_neutral x -> branch\n\n The semantics is clear: match the scrutinee against the pattern, if\n it matches, test the guard, and if the guard passes, take the\n branch.\n\n However, consider the input [(Const a, Const b)], where [a] fails\n the test [is_neutral f], while [b] passes the test [is_neutral\n b]. With the left-to-right semantics, the clause above is *not*\n taken by its input: matching [(Const a, Const b)] against the\n or-pattern succeeds in the left branch, it returns the environment\n [x -> a], and then the guard [is_neutral a] is tested and fails,\n the branch is not taken. Most users, however, intuitively expect\n that any pair that has one side passing the test will take the\n branch. They assume it is equivalent to the following:\n\n | (Const x, _) when is_neutral x -> branch\n | (_, Const x) when is_neutral x -> branch\n\n while it is not.\n\n The code below is dedicated to finding these confusing cases: the\n cases where a guard uses \"ambiguous\" variables, that are bound to\n different parts of the scrutinees by different sides of\n a or-pattern. In other words, it finds the cases where the\n specified left-to-right semantics is not equivalent to\n a non-deterministic semantics (any branch can be taken) relatively\n to a specific guard.\n*)\n\nlet pattern_vars p = Ident.Set.of_list (Typedtree.pat_bound_idents p)\n\n(* Row for ambiguous variable search,\n row is the traditional pattern row,\n varsets contain a list of head variable sets (varsets)\n\n A given varset contains all the variables that appeared at the head\n of a pattern in the row at some point during traversal: they would\n all be bound to the same value at matching time. On the contrary,\n two variables of different varsets appeared at different places in\n the pattern and may be bound to distinct sub-parts of the matched\n value.\n\n All rows of a (sub)matrix have rows of the same length,\n but also varsets of the same length.\n\n Varsets are populated when simplifying the first column\n -- the variables of the head pattern are collected in a new varset.\n For example,\n { row = x :: r1; varsets = s1 }\n { row = (Some _) as y :: r2; varsets = s2 }\n { row = (None as x) as y :: r3; varsets = s3 }\n { row = (Some x | (None as x)) :: r4 with varsets = s4 }\n becomes\n (_, { row = r1; varsets = {x} :: s1 })\n (Some _, { row = r2; varsets = {y} :: s2 })\n (None, { row = r3; varsets = {x, y} :: s3 })\n (Some x, { row = r4; varsets = {} :: s4 })\n (None, { row = r4; varsets = {x} :: s4 })\n*)\ntype amb_row = { row : pattern list ; varsets : Ident.Set.t list; }\n\nlet simplify_head_amb_pat head_bound_variables varsets ~add_column p ps k =\n let rec simpl head_bound_variables varsets p ps k =\n match (Patterns.General.view p).pat_desc with\n | `Alias (p,x,_) ->\n simpl (Ident.Set.add x head_bound_variables) varsets p ps k\n | `Var (x, _) ->\n simpl (Ident.Set.add x head_bound_variables) varsets Patterns.omega ps k\n | `Or (p1,p2,_) ->\n simpl head_bound_variables varsets p1 ps\n (simpl head_bound_variables varsets p2 ps k)\n | #Patterns.Simple.view as view ->\n add_column (Patterns.Head.deconstruct { p with pat_desc = view })\n { row = ps; varsets = head_bound_variables :: varsets; } k\n in simpl head_bound_variables varsets p ps k\n\n(*\n To accurately report ambiguous variables, one must consider\n that previous clauses have already matched some values.\n Consider for example:\n\n | (Foo x, Foo y) -> ...\n | ((Foo x, _) | (_, Foo x)) when bar x -> ...\n\n The second line taken in isolation uses an unstable variable,\n but the discriminating values, of the shape [(Foo v1, Foo v2)],\n would all be filtered by the line above.\n\n To track this information, the matrices we analyze contain both\n *positive* rows, that describe the rows currently being analyzed\n (of type Varsets.row, so that their varsets are tracked) and\n *negative rows*, that describe the cases already matched against.\n\n The values matched by a signed matrix are the values matched by\n some of the positive rows but none of the negative rows. In\n particular, a variable is stable if, for any value not matched by\n any of the negative rows, the environment captured by any of the\n matching positive rows is identical.\n*)\ntype ('a, 'b) signed = Positive of 'a | Negative of 'b\n\nlet rec simplify_first_amb_col = function\n | [] -> []\n | (Negative [] | Positive { row = []; _ }) :: _ -> assert false\n | Negative (n :: ns) :: rem ->\n let add_column n ns k = (n, Negative ns) :: k in\n simplify_head_pat\n ~add_column n ns (simplify_first_amb_col rem)\n | Positive { row = p::ps; varsets; }::rem ->\n let add_column p ps k = (p, Positive ps) :: k in\n simplify_head_amb_pat\n Ident.Set.empty varsets\n ~add_column p ps (simplify_first_amb_col rem)\n\n(* Compute stable bindings *)\n\ntype stable_vars =\n | All\n | Vars of Ident.Set.t\n\nlet stable_inter sv1 sv2 = match sv1, sv2 with\n | All, sv | sv, All -> sv\n | Vars s1, Vars s2 -> Vars (Ident.Set.inter s1 s2)\n\nlet reduce f = function\n| [] -> invalid_arg \"reduce\"\n| x::xs -> List.fold_left f x xs\n\nlet rec matrix_stable_vars m = match m with\n | [] -> All\n | ((Positive {row = []; _} | Negative []) :: _) as empty_rows ->\n let exception Negative_empty_row in\n (* if at least one empty row is negative, the matrix matches no value *)\n let get_varsets = function\n | Negative n ->\n (* All rows have the same number of columns;\n if the first row is empty, they all are. *)\n assert (n = []);\n raise Negative_empty_row\n | Positive p ->\n assert (p.row = []);\n p.varsets in\n begin match List.map get_varsets empty_rows with\n | exception Negative_empty_row -> All\n | rows_varsets ->\n let stables_in_varsets =\n reduce (List.map2 Ident.Set.inter) rows_varsets in\n (* The stable variables are those stable at any position *)\n Vars\n (List.fold_left Ident.Set.union Ident.Set.empty stables_in_varsets)\n end\n | m ->\n let is_negative = function\n | Negative _ -> true\n | Positive _ -> false in\n if List.for_all is_negative m then\n (* optimization: quit early if there are no positive rows.\n This may happen often when the initial matrix has many\n negative cases and few positive cases (a small guarded\n clause after a long list of clauses) *)\n All\n else begin\n let m = simplify_first_amb_col m in\n if not (all_coherent (first_column m)) then\n All\n else begin\n (* If the column is ill-typed but deemed coherent, we might\n spuriously warn about some variables being unstable.\n As sad as that might be, the warning can be silenced by\n splitting the or-pattern... *)\n let submatrices =\n let extend_row columns = function\n | Negative r -> Negative (columns @ r)\n | Positive r -> Positive { r with row = columns @ r.row } in\n let q0 = discr_pat Patterns.Simple.omega m in\n let { default; constrs } =\n build_specialized_submatrices ~extend_row q0 m in\n let non_default = List.map snd constrs in\n if full_match false constrs\n then non_default\n else default :: non_default in\n (* A stable variable must be stable in each submatrix. *)\n let submat_stable = List.map matrix_stable_vars submatrices in\n List.fold_left stable_inter All submat_stable\n end\n end\n\nlet pattern_stable_vars ns p =\n matrix_stable_vars\n (List.fold_left (fun m n -> Negative n :: m)\n [Positive {varsets = []; row = [p]}] ns)\n\n(* All identifier paths that appear in an expression that occurs\n as a clause right hand side or guard.\n\n The function is rather complex due to the compilation of\n unpack patterns by introducing code in rhs expressions\n and **guards**.\n\n For pattern (module M:S) -> e the code is\n let module M_mod = unpack M .. in e\n\n Hence M is \"free\" in e iff M_mod is free in e.\n\n Not doing so will yield excessive warning in\n (module (M:S) } ...) when true -> ....\n as M is always present in\n let module M_mod = unpack M .. in true\n*)\n\nlet all_rhs_idents exp =\n let ids = ref Ident.Set.empty in\n(* Very hackish, detect unpack pattern compilation\n and perform \"indirect check for them\" *)\n let is_unpack exp =\n List.exists\n (fun attr -> attr.Parsetree.attr_name.txt = \"#modulepat\")\n exp.exp_attributes in\n let open Tast_iterator in\n let expr_iter iter exp =\n (match exp.exp_desc with\n | Texp_ident (path, _lid, _descr) ->\n List.iter (fun id -> ids := Ident.Set.add id !ids) (Path.heads path)\n (* Use default iterator methods for rest of match.*)\n | _ -> Tast_iterator.default_iterator.expr iter exp);\n\n if is_unpack exp then begin match exp.exp_desc with\n | Texp_letmodule\n (id_mod,_,_,\n {mod_desc=\n Tmod_unpack ({exp_desc=Texp_ident (Path.Pident id_exp,_,_)},_)},\n _) ->\n assert (Ident.Set.mem id_exp !ids) ;\n begin match id_mod with\n | Some id_mod when not (Ident.Set.mem id_mod !ids) ->\n ids := Ident.Set.remove id_exp !ids\n | _ -> ()\n end\n | _ -> assert false\n end\n in\n let iterator = {Tast_iterator.default_iterator with expr = expr_iter} in\n iterator.expr iterator exp;\n !ids\n\nlet check_ambiguous_bindings =\n let open Warnings in\n let warn0 = Ambiguous_var_in_pattern_guard [] in\n fun cases ->\n if is_active warn0 then\n let check_case ns case = match case with\n | { c_lhs = p; c_guard=None ; _} -> [p]::ns\n | { c_lhs=p; c_guard=Some g; _} ->\n let all =\n Ident.Set.inter (pattern_vars p) (all_rhs_idents g) in\n if not (Ident.Set.is_empty all) then begin\n match pattern_stable_vars ns p with\n | All -> ()\n | Vars stable ->\n let ambiguous = Ident.Set.diff all stable in\n if not (Ident.Set.is_empty ambiguous) then begin\n let pps =\n Ident.Set.elements ambiguous |> List.map Ident.name in\n let warn = Ambiguous_var_in_pattern_guard pps in\n Location.prerr_warning p.pat_loc warn\n end\n end;\n ns\n in\n ignore (List.fold_left check_case [] cases)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1998 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(* Auxiliaries for type-based optimizations, e.g. array kinds *)\n\nopen Path\nopen Types\nopen Asttypes\nopen Typedtree\nopen Lambda\n\nlet scrape_ty env ty =\n match get_desc ty with\n | Tconstr _ ->\n let ty = Ctype.expand_head_opt env (Ctype.correct_levels ty) in\n begin match get_desc ty with\n | Tconstr (p, _, _) ->\n begin match Env.find_type p env with\n | {type_kind = ( Type_variant (_, Variant_unboxed)\n | Type_record (_, Record_unboxed _) ); _} -> begin\n match Typedecl_unboxed.get_unboxed_type_representation env ty with\n | None -> ty\n | Some ty2 -> ty2\n end\n | _ -> ty\n | exception Not_found -> ty\n end\n | _ ->\n ty\n end\n | _ -> ty\n\nlet scrape env ty =\n get_desc (scrape_ty env ty)\n\nlet scrape_poly env ty =\n let ty = scrape_ty env ty in\n match get_desc ty with\n | Tpoly (ty, _) -> get_desc ty\n | d -> d\n\nlet is_function_type env ty =\n match scrape env ty with\n | Tarrow (_, lhs, rhs, _) -> Some (lhs, rhs)\n | _ -> None\n\nlet is_base_type env ty base_ty_path =\n match scrape env ty with\n | Tconstr(p, _, _) -> Path.same p base_ty_path\n | _ -> false\n\nlet is_immediate = function\n | Type_immediacy.Unknown -> false\n | Type_immediacy.Always -> true\n | Type_immediacy.Always_on_64bits ->\n (* In bytecode, we don't know at compile time whether we are\n targeting 32 or 64 bits. *)\n !Clflags.native_code && Sys.word_size = 64\n\nlet maybe_pointer_type env ty =\n let ty = scrape_ty env ty in\n if is_immediate (Ctype.immediacy env ty) then Immediate\n else Pointer\n\nlet maybe_pointer exp = maybe_pointer_type exp.exp_env exp.exp_type\n\ntype classification =\n | Int\n | Float\n | Lazy\n | Addr (* anything except a float or a lazy *)\n | Any\n\nlet classify env ty =\n let ty = scrape_ty env ty in\n if maybe_pointer_type env ty = Immediate then Int\n else match get_desc ty with\n | Tvar _ | Tunivar _ ->\n Any\n | Tconstr (p, _args, _abbrev) ->\n if Path.same p Predef.path_float then Float\n else if Path.same p Predef.path_lazy_t then Lazy\n else if Path.same p Predef.path_string\n || Path.same p Predef.path_bytes\n || Path.same p Predef.path_array\n || Path.same p Predef.path_nativeint\n || Path.same p Predef.path_int32\n || Path.same p Predef.path_int64 then Addr\n else begin\n try\n match (Env.find_type p env).type_kind with\n | Type_abstract ->\n Any\n | Type_record _ | Type_variant _ | Type_open ->\n Addr\n with Not_found ->\n (* This can happen due to e.g. missing -I options,\n causing some .cmi files to be unavailable.\n Maybe we should emit a warning. *)\n Any\n end\n | Tarrow _ | Ttuple _ | Tpackage _ | Tobject _ | Tnil | Tvariant _ ->\n Addr\n | Tlink _ | Tsubst _ | Tpoly _ | Tfield _ ->\n assert false\n\nlet array_type_kind env ty =\n match scrape_poly env ty with\n | Tconstr(p, [elt_ty], _) when Path.same p Predef.path_array ->\n begin match classify env elt_ty with\n | Any -> if Config.flat_float_array then Pgenarray else Paddrarray\n | Float -> if Config.flat_float_array then Pfloatarray else Paddrarray\n | Addr | Lazy -> Paddrarray\n | Int -> Pintarray\n end\n | Tconstr(p, [], _) when Path.same p Predef.path_floatarray ->\n Pfloatarray\n | _ ->\n (* This can happen with e.g. Obj.field *)\n Pgenarray\n\nlet array_kind exp = array_type_kind exp.exp_env exp.exp_type\n\nlet array_pattern_kind pat = array_type_kind pat.pat_env pat.pat_type\n\nlet bigarray_decode_type env ty tbl dfl =\n match scrape env ty with\n | Tconstr(Pdot(Pident mod_id, type_name), [], _)\n when Ident.name mod_id = \"Stdlib__Bigarray\" ->\n begin try List.assoc type_name tbl with Not_found -> dfl end\n | _ ->\n dfl\n\nlet kind_table =\n [\"float32_elt\", Pbigarray_float32;\n \"float64_elt\", Pbigarray_float64;\n \"int8_signed_elt\", Pbigarray_sint8;\n \"int8_unsigned_elt\", Pbigarray_uint8;\n \"int16_signed_elt\", Pbigarray_sint16;\n \"int16_unsigned_elt\", Pbigarray_uint16;\n \"int32_elt\", Pbigarray_int32;\n \"int64_elt\", Pbigarray_int64;\n \"int_elt\", Pbigarray_caml_int;\n \"nativeint_elt\", Pbigarray_native_int;\n \"complex32_elt\", Pbigarray_complex32;\n \"complex64_elt\", Pbigarray_complex64]\n\nlet layout_table =\n [\"c_layout\", Pbigarray_c_layout;\n \"fortran_layout\", Pbigarray_fortran_layout]\n\nlet bigarray_type_kind_and_layout env typ =\n match scrape env typ with\n | Tconstr(_p, [_caml_type; elt_type; layout_type], _abbrev) ->\n (bigarray_decode_type env elt_type kind_table Pbigarray_unknown,\n bigarray_decode_type env layout_type layout_table\n Pbigarray_unknown_layout)\n | _ ->\n (Pbigarray_unknown, Pbigarray_unknown_layout)\n\nlet value_kind env ty =\n let ty = scrape_ty env ty in\n if is_immediate (Ctype.immediacy env ty) then Pintval\n else begin\n match get_desc ty with\n | Tconstr(p, _, _) when Path.same p Predef.path_float ->\n Pfloatval\n | Tconstr(p, _, _) when Path.same p Predef.path_int32 ->\n Pboxedintval Pint32\n | Tconstr(p, _, _) when Path.same p Predef.path_int64 ->\n Pboxedintval Pint64\n | Tconstr(p, _, _) when Path.same p Predef.path_nativeint ->\n Pboxedintval Pnativeint\n | _ ->\n Pgenval\n end\n\nlet function_return_value_kind env ty =\n match is_function_type env ty with\n | Some (_lhs, rhs) -> value_kind env rhs\n | None -> Pgenval\n\n(** Whether a forward block is needed for a lazy thunk on a value, i.e.\n if the value can be represented as a float/forward/lazy *)\nlet lazy_val_requires_forward env ty =\n match classify env ty with\n | Any | Lazy -> true\n | Float -> Config.flat_float_array\n | Addr | Int -> false\n\n(** The compilation of the expression [lazy e] depends on the form of e:\n constants, floats and identifiers are optimized. The optimization must be\n taken into account when determining whether a recursive binding is safe. *)\nlet classify_lazy_argument : Typedtree.expression ->\n [`Constant_or_function\n |`Float_that_cannot_be_shortcut\n |`Identifier of [`Forward_value|`Other]\n |`Other] =\n fun e -> match e.exp_desc with\n | Texp_constant\n ( Const_int _ | Const_char _ | Const_string _\n | Const_int32 _ | Const_int64 _ | Const_nativeint _ )\n | Texp_function _\n | Texp_construct (_, {cstr_arity = 0}, _) ->\n `Constant_or_function\n | Texp_constant(Const_float _) ->\n if Config.flat_float_array\n then `Float_that_cannot_be_shortcut\n else `Constant_or_function\n | Texp_ident _ when lazy_val_requires_forward e.exp_env e.exp_type ->\n `Identifier `Forward_value\n | Texp_ident _ ->\n `Identifier `Other\n | _ ->\n `Other\n\nlet value_kind_union k1 k2 =\n if k1 = k2 then k1\n else Pgenval\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy and Jerome Vouillon, 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(* Printing functions *)\n\nopen Misc\nopen Ctype\nopen Format\nopen Longident\nopen Path\nopen Asttypes\nopen Types\nopen Btype\nopen Outcometree\n\nmodule String = Misc.Stdlib.String\n\n(* Print a long identifier *)\n\nlet rec longident ppf = function\n | Lident s -> pp_print_string ppf s\n | Ldot(p, s) -> fprintf ppf \"%a.%s\" longident p s\n | Lapply(p1, p2) -> fprintf ppf \"%a(%a)\" longident p1 longident p2\n\nlet () = Env.print_longident := longident\n\n(* Print an identifier avoiding name collisions *)\n\nmodule Out_name = struct\n let create x = { printed_name = x }\n let print x = x.printed_name\n let set out_name x = out_name.printed_name <- x\nend\n\n(** Some identifiers may require hiding when printing *)\ntype bound_ident = { hide:bool; ident:Ident.t }\n\n(* printing environment for path shortening and naming *)\nlet printing_env = ref Env.empty\n\n(* When printing, it is important to only observe the\n current printing environment, without reading any new\n cmi present on the file system *)\nlet in_printing_env f = Env.without_cmis f !printing_env\n\nlet human_unique n id = Printf.sprintf \"%s/%d\" (Ident.name id) n\n\ntype namespace =\n | Type\n | Module\n | Module_type\n | Class\n | Class_type\n | Other (** Other bypasses the unique name identifier mechanism *)\n\nmodule Namespace = struct\n\n let id = function\n | Type -> 0\n | Module -> 1\n | Module_type -> 2\n | Class -> 3\n | Class_type -> 4\n | Other -> 5\n\n let size = 1 + id Other\n\n let show =\n function\n | Type -> \"type\"\n | Module -> \"module\"\n | Module_type -> \"module type\"\n | Class -> \"class\"\n | Class_type -> \"class type\"\n | Other -> \"\"\n\n let pp ppf x = Format.pp_print_string ppf (show x)\n\n (** The two functions below should never access the filesystem,\n and thus use {!in_printing_env} rather than directly\n accessing the printing environment *)\n let lookup =\n let to_lookup f lid = fst @@ in_printing_env (f (Lident lid)) in\n function\n | Type -> to_lookup Env.find_type_by_name\n | Module -> to_lookup Env.find_module_by_name\n | Module_type -> to_lookup Env.find_modtype_by_name\n | Class -> to_lookup Env.find_class_by_name\n | Class_type -> to_lookup Env.find_cltype_by_name\n | Other -> fun _ -> raise Not_found\n\n let location namespace id =\n let path = Path.Pident id in\n try Some (\n match namespace with\n | Type -> (in_printing_env @@ Env.find_type path).type_loc\n | Module -> (in_printing_env @@ Env.find_module path).md_loc\n | Module_type -> (in_printing_env @@ Env.find_modtype path).mtd_loc\n | Class -> (in_printing_env @@ Env.find_class path).cty_loc\n | Class_type -> (in_printing_env @@ Env.find_cltype path).clty_loc\n | Other -> Location.none\n ) with Not_found -> None\n\n let best_class_namespace = function\n | Papply _ | Pdot _ -> Module\n | Pident c ->\n match location Class c with\n | Some _ -> Class\n | None -> Class_type\n\nend\n\n(** {2 Conflicts printing}\n Conflicts arise when multiple items are attributed the same name,\n the following module stores the global conflict references and\n provides the printing functions for explaining the source of\n the conflicts.\n*)\nmodule Conflicts = struct\n module M = String.Map\n type explanation =\n { kind: namespace; name:string; root_name:string; location:Location.t}\n let explanations = ref M.empty\n let collect_explanation namespace n id =\n let name = human_unique n id in\n let root_name = Ident.name id in\n if not (M.mem name !explanations) then\n match Namespace.location namespace id with\n | None -> ()\n | Some location ->\n let explanation = { kind = namespace; location; name; root_name } in\n explanations := M.add name explanation !explanations\n\n let pp_explanation ppf r=\n Format.fprintf ppf \"@[%a:@,Definition of %s %s@]\"\n Location.print_loc r.location (Namespace.show r.kind) r.name\n\n let print_located_explanations ppf l =\n Format.fprintf ppf \"@[%a@]\" (Format.pp_print_list pp_explanation) l\n\n let reset () = explanations := M.empty\n let list_explanations () =\n let c = !explanations in\n reset ();\n c |> M.bindings |> List.map snd |> List.sort Stdlib.compare\n\n\n let print_toplevel_hint ppf l =\n let conj ppf () = Format.fprintf ppf \" and@ \" in\n let pp_namespace_plural ppf n = Format.fprintf ppf \"%as\" Namespace.pp n in\n let root_names = List.map (fun r -> r.kind, r.root_name) l in\n let unique_root_names = List.sort_uniq Stdlib.compare root_names in\n let submsgs = Array.make Namespace.size [] in\n let () = List.iter (fun (n,_ as x) ->\n submsgs.(Namespace.id n) <- x :: submsgs.(Namespace.id n)\n ) unique_root_names in\n let pp_submsg ppf names =\n match names with\n | [] -> ()\n | [namespace, a] ->\n Format.fprintf ppf\n \"@ \\\n @[<2>Hint: The %a %s has been defined multiple times@ \\\n in@ this@ toplevel@ session.@ \\\n Some toplevel values still refer to@ old@ versions@ of@ this@ %a.\\\n @ Did you try to redefine them?@]\"\n Namespace.pp namespace a Namespace.pp namespace\n | (namespace, _) :: _ :: _ ->\n Format.fprintf ppf\n \"@ \\\n @[<2>Hint: The %a %a have been defined multiple times@ \\\n in@ this@ toplevel@ session.@ \\\n Some toplevel values still refer to@ old@ versions@ of@ those@ %a.\\\n @ Did you try to redefine them?@]\"\n pp_namespace_plural namespace\n Format.(pp_print_list ~pp_sep:conj pp_print_string) (List.map snd names)\n pp_namespace_plural namespace in\n Array.iter (pp_submsg ppf) submsgs\n\n let print_explanations ppf =\n let ltop, l =\n (* isolate toplevel locations, since they are too imprecise *)\n let from_toplevel a =\n a.location.Location.loc_start.Lexing.pos_fname = \"//toplevel//\" in\n List.partition from_toplevel (list_explanations ())\n in\n begin match l with\n | [] -> ()\n | l -> Format.fprintf ppf \"@,%a\" print_located_explanations l\n end;\n (* if there are name collisions in a toplevel session,\n display at least one generic hint by namespace *)\n print_toplevel_hint ppf ltop\n\n let exists () = M.cardinal !explanations >0\nend\n\nmodule Naming_context = struct\n\nmodule M = String.Map\nmodule S = String.Set\n\nlet enabled = ref true\nlet enable b = enabled := b\n\n(** Name mapping *)\ntype mapping =\n | Need_unique_name of int Ident.Map.t\n (** The same name has already been attributed to multiple types.\n The [map] argument contains the specific binding time attributed to each\n types.\n *)\n | Uniquely_associated_to of Ident.t * out_name\n (** For now, the name [Ident.name id] has been attributed to [id],\n [out_name] is used to expand this name if a conflict arises\n at a later point\n *)\n | Associated_to_pervasives of out_name\n (** [Associated_to_pervasives out_name] is used when the item\n [Stdlib.$name] has been associated to the name [$name].\n Upon a conflict, this name will be expanded to [\"Stdlib.\" ^ name ] *)\n\nlet hid_start = 0\n\nlet add_hid_id id map =\n let new_id = 1 + Ident.Map.fold (fun _ -> Int.max) map hid_start in\n new_id, Ident.Map.add id new_id map\n\nlet find_hid id map =\n try Ident.Map.find id map, map with\n Not_found -> add_hid_id id map\n\nlet pervasives name = \"Stdlib.\" ^ name\n\nlet map = Array.make Namespace.size M.empty\nlet get namespace = map.(Namespace.id namespace)\nlet set namespace x = map.(Namespace.id namespace) <- x\n\n(* Names used in recursive definitions are not considered when determining\n if a name is already attributed in the current environment.\n This is a complementary version of hidden_rec_items used by short-path. *)\nlet protected = ref S.empty\n\n(* When dealing with functor arguments, identity becomes fuzzy because the same\n syntactic argument may be represented by different identifiers during the\n error processing, we are thus disabling disambiguation on the argument name\n*)\nlet fuzzy = ref S.empty\nlet with_arg id f =\n protect_refs [ R(fuzzy, S.add (Ident.name id) !fuzzy) ] f\nlet fuzzy_id namespace id = namespace = Module && S.mem (Ident.name id) !fuzzy\n\nlet with_hidden ids f =\n let update m id = S.add (Ident.name id.ident) m in\n protect_refs [ R(protected, List.fold_left update !protected ids)] f\n\nlet pervasives_name namespace name =\n if not !enabled then Out_name.create name else\n match M.find name (get namespace) with\n | Associated_to_pervasives r -> r\n | Need_unique_name _ -> Out_name.create (pervasives name)\n | Uniquely_associated_to (id',r) ->\n let hid, map = add_hid_id id' Ident.Map.empty in\n Out_name.set r (human_unique hid id');\n Conflicts.collect_explanation namespace hid id';\n set namespace @@ M.add name (Need_unique_name map) (get namespace);\n Out_name.create (pervasives name)\n | exception Not_found ->\n let r = Out_name.create name in\n set namespace @@ M.add name (Associated_to_pervasives r) (get namespace);\n r\n\n(** Lookup for preexisting named item within the current {!printing_env} *)\nlet env_ident namespace name =\n if S.mem name !protected then None else\n match Namespace.lookup namespace name with\n | Pident id -> Some id\n | _ -> None\n | exception Not_found -> None\n\n(** Associate a name to the identifier [id] within [namespace] *)\nlet ident_name_simple namespace id =\n if not !enabled || fuzzy_id namespace id then\n Out_name.create (Ident.name id)\n else\n let name = Ident.name id in\n match M.find name (get namespace) with\n | Uniquely_associated_to (id',r) when Ident.same id id' ->\n r\n | Need_unique_name map ->\n let hid, m = find_hid id map in\n Conflicts.collect_explanation namespace hid id;\n set namespace @@ M.add name (Need_unique_name m) (get namespace);\n Out_name.create (human_unique hid id)\n | Uniquely_associated_to (id',r) ->\n let hid', m = find_hid id' Ident.Map.empty in\n let hid, m = find_hid id m in\n Out_name.set r (human_unique hid' id');\n List.iter (fun (id,hid) -> Conflicts.collect_explanation namespace hid id)\n [id, hid; id', hid' ];\n set namespace @@ M.add name (Need_unique_name m) (get namespace);\n Out_name.create (human_unique hid id)\n | Associated_to_pervasives r ->\n Out_name.set r (\"Stdlib.\" ^ Out_name.print r);\n let hid, m = find_hid id Ident.Map.empty in\n set namespace @@ M.add name (Need_unique_name m) (get namespace);\n Out_name.create (human_unique hid id)\n | exception Not_found ->\n let r = Out_name.create name in\n set namespace\n @@ M.add name (Uniquely_associated_to (id,r) ) (get namespace);\n r\n\n(** Same as {!ident_name_simple} but lookup to existing named identifiers\n in the current {!printing_env} *)\nlet ident_name namespace id =\n begin match env_ident namespace (Ident.name id) with\n | Some id' -> ignore (ident_name_simple namespace id')\n | None -> ()\n end;\n ident_name_simple namespace id\n\nlet reset () =\n Array.iteri ( fun i _ -> map.(i) <- M.empty ) map\n\nlet with_ctx f =\n let old = Array.copy map in\n try_finally f\n ~always:(fun () -> Array.blit old 0 map 0 (Array.length map))\n\nend\nlet ident_name = Naming_context.ident_name\nlet reset_naming_context = Naming_context.reset\n\nlet ident ppf id = pp_print_string ppf\n (Out_name.print (Naming_context.ident_name_simple Other id))\n\n(* Print a path *)\n\nlet ident_stdlib = Ident.create_persistent \"Stdlib\"\n\nlet non_shadowed_pervasive = function\n | Pdot(Pident id, s) as path ->\n Ident.same id ident_stdlib &&\n (match in_printing_env (Env.find_type_by_name (Lident s)) with\n | (path', _) -> Path.same path path'\n | exception Not_found -> true)\n | _ -> false\n\nlet find_double_underscore s =\n let len = String.length s in\n let rec loop i =\n if i + 1 >= len then\n None\n else if s.[i] = '_' && s.[i + 1] = '_' then\n Some i\n else\n loop (i + 1)\n in\n loop 0\n\nlet rec module_path_is_an_alias_of env path ~alias_of =\n match Env.find_module path env with\n | { md_type = Mty_alias path'; _ } ->\n Path.same path' alias_of ||\n module_path_is_an_alias_of env path' ~alias_of\n | _ -> false\n | exception Not_found -> false\n\n(* Simple heuristic to print Foo__bar.* as Foo.Bar.* when Foo.Bar is an alias\n for Foo__bar. This pattern is used by the stdlib. *)\nlet rec rewrite_double_underscore_paths env p =\n match p with\n | Pdot (p, s) ->\n Pdot (rewrite_double_underscore_paths env p, s)\n | Papply (a, b) ->\n Papply (rewrite_double_underscore_paths env a,\n rewrite_double_underscore_paths env b)\n | Pident id ->\n let name = Ident.name id in\n match find_double_underscore name with\n | None -> p\n | Some i ->\n let better_lid =\n Ldot\n (Lident (String.sub name 0 i),\n String.capitalize_ascii\n (String.sub name (i + 2) (String.length name - i - 2)))\n in\n match Env.find_module_by_name better_lid env with\n | exception Not_found -> p\n | p', _ ->\n if module_path_is_an_alias_of env p' ~alias_of:p then\n p'\n else\n p\n\nlet rewrite_double_underscore_paths env p =\n if env == Env.empty then\n p\n else\n rewrite_double_underscore_paths env p\n\nlet rec tree_of_path namespace = function\n | Pident id ->\n Oide_ident (ident_name namespace id)\n | Pdot(_, s) as path when non_shadowed_pervasive path ->\n Oide_ident (Naming_context.pervasives_name namespace s)\n | Pdot(Pident t, s)\n when namespace=Type && not (Path.is_uident (Ident.name t)) ->\n (* [t.A]: inline record of the constructor [A] from type [t] *)\n Oide_dot (Oide_ident (ident_name Type t), s)\n | Pdot(p, s) ->\n Oide_dot (tree_of_path Module p, s)\n | Papply(p1, p2) ->\n Oide_apply (tree_of_path Module p1, tree_of_path Module p2)\n\nlet tree_of_path namespace p =\n tree_of_path namespace (rewrite_double_underscore_paths !printing_env p)\n\nlet path ppf p =\n !Oprint.out_ident ppf (tree_of_path Other p)\n\nlet string_of_path p =\n Format.asprintf \"%a\" path p\n\nlet strings_of_paths namespace p =\n reset_naming_context ();\n let trees = List.map (tree_of_path namespace) p in\n List.map (Format.asprintf \"%a\" !Oprint.out_ident) trees\n\nlet () = Env.print_path := path\n\n(* Print a recursive annotation *)\n\nlet tree_of_rec = function\n | Trec_not -> Orec_not\n | Trec_first -> Orec_first\n | Trec_next -> Orec_next\n\n(* Print a raw type expression, with sharing *)\n\nlet raw_list pr ppf = function\n [] -> fprintf ppf \"[]\"\n | a :: l ->\n fprintf ppf \"@[<1>[%a%t]@]\" pr a\n (fun ppf -> List.iter (fun x -> fprintf ppf \";@,%a\" pr x) l)\n\nlet kind_vars = ref []\nlet kind_count = ref 0\n\nlet string_of_field_kind v =\n match field_kind_repr v with\n | Fpublic -> \"Fpublic\"\n | Fabsent -> \"Fabsent\"\n | Fprivate -> \"Fprivate\"\n\nlet rec safe_repr v t =\n match Transient_expr.coerce t with\n {desc = Tlink t} when not (List.memq t v) ->\n safe_repr (t::v) t\n | t' -> t'\n\nlet rec list_of_memo = function\n Mnil -> []\n | Mcons (_priv, p, _t1, _t2, rem) -> p :: list_of_memo rem\n | Mlink rem -> list_of_memo !rem\n\nlet print_name ppf = function\n None -> fprintf ppf \"None\"\n | Some name -> fprintf ppf \"\\\"%s\\\"\" name\n\nlet string_of_label = function\n Nolabel -> \"\"\n | Labelled s -> s\n | Optional s -> \"?\"^s\n\nlet visited = ref []\nlet rec raw_type ppf ty =\n let ty = safe_repr [] ty in\n if List.memq ty !visited then fprintf ppf \"{id=%d}\" ty.id else begin\n visited := ty :: !visited;\n fprintf ppf \"@[<1>{id=%d;level=%d;scope=%d;desc=@,%a}@]\" ty.id ty.level\n ty.scope raw_type_desc ty.desc\n end\nand raw_type_list tl = raw_list raw_type tl\nand raw_type_desc ppf = function\n Tvar name -> fprintf ppf \"Tvar %a\" print_name name\n | Tarrow(l,t1,t2,c) ->\n fprintf ppf \"@[Tarrow(\\\"%s\\\",@,%a,@,%a,@,%s)@]\"\n (string_of_label l) raw_type t1 raw_type t2\n (if is_commu_ok c then \"Cok\" else \"Cunknown\")\n | Ttuple tl ->\n fprintf ppf \"@[<1>Ttuple@,%a@]\" raw_type_list tl\n | Tconstr (p, tl, abbrev) ->\n fprintf ppf \"@[Tconstr(@,%a,@,%a,@,%a)@]\" path p\n raw_type_list tl\n (raw_list path) (list_of_memo !abbrev)\n | Tobject (t, nm) ->\n fprintf ppf \"@[Tobject(@,%a,@,@[<1>ref%t@])@]\" raw_type t\n (fun ppf ->\n match !nm with None -> fprintf ppf \" None\"\n | Some(p,tl) ->\n fprintf ppf \"(Some(@,%a,@,%a))\" path p raw_type_list tl)\n | Tfield (f, k, t1, t2) ->\n fprintf ppf \"@[Tfield(@,%s,@,%s,@,%a,@;<0 -1>%a)@]\" f\n (string_of_field_kind k)\n raw_type t1 raw_type t2\n | Tnil -> fprintf ppf \"Tnil\"\n | Tlink t -> fprintf ppf \"@[<1>Tlink@,%a@]\" raw_type t\n | Tsubst (t, None) -> fprintf ppf \"@[<1>Tsubst@,(%a,None)@]\" raw_type t\n | Tsubst (t, Some t') ->\n fprintf ppf \"@[<1>Tsubst@,(%a,@ Some%a)@]\" raw_type t raw_type t'\n | Tunivar name -> fprintf ppf \"Tunivar %a\" print_name name\n | Tpoly (t, tl) ->\n fprintf ppf \"@[Tpoly(@,%a,@,%a)@]\"\n raw_type t\n raw_type_list tl\n | Tvariant row ->\n let Row {fields; more; name; fixed; closed} = row_repr row in\n fprintf ppf\n \"@[{@[%s@,%a;@]@ @[%s@,%a;@]@ %s%B;@ %s%a;@ @[<1>%s%t@]}@]\"\n \"row_fields=\"\n (raw_list (fun ppf (l, f) ->\n fprintf ppf \"@[%s,@ %a@]\" l raw_field f))\n fields\n \"row_more=\" raw_type more\n \"row_closed=\" closed\n \"row_fixed=\" raw_row_fixed fixed\n \"row_name=\"\n (fun ppf ->\n match name with None -> fprintf ppf \"None\"\n | Some(p,tl) ->\n fprintf ppf \"Some(@,%a,@,%a)\" path p raw_type_list tl)\n | Tpackage (p, fl) ->\n fprintf ppf \"@[Tpackage(@,%a@,%a)@]\" path p\n raw_type_list (List.map snd fl)\nand raw_row_fixed ppf = function\n| None -> fprintf ppf \"None\"\n| Some Types.Fixed_private -> fprintf ppf \"Some Fixed_private\"\n| Some Types.Rigid -> fprintf ppf \"Some Rigid\"\n| Some Types.Univar t -> fprintf ppf \"Some(Univar(%a))\" raw_type t\n| Some Types.Reified p -> fprintf ppf \"Some(Reified(%a))\" path p\n\nand raw_field ppf rf =\n match_row_field\n ~absent:(fun _ -> fprintf ppf \"RFabsent\")\n ~present:(function\n | None ->\n fprintf ppf \"RFpresent None\"\n | Some t ->\n fprintf ppf \"@[<1>RFpresent(Some@,%a)@]\" raw_type t)\n ~either:(fun c tl m e ->\n fprintf ppf \"@[RFeither(%B,@,%a,@,%B,@,@[<1>ref%t@])@]\" c\n raw_type_list tl m\n (fun ppf ->\n match e with None -> fprintf ppf \" RFnone\"\n | Some f -> fprintf ppf \"@,@[<1>(%a)@]\" raw_field f))\n rf\n\nlet raw_type_expr ppf t =\n visited := []; kind_vars := []; kind_count := 0;\n raw_type ppf t;\n visited := []; kind_vars := []\n\nlet () = Btype.print_raw := raw_type_expr\n\n(* Normalize paths *)\n\ntype param_subst = Id | Nth of int | Map of int list\n\nlet is_nth = function\n Nth _ -> true\n | _ -> false\n\nlet compose l1 = function\n | Id -> Map l1\n | Map l2 -> Map (List.map (List.nth l1) l2)\n | Nth n -> Nth (List.nth l1 n)\n\nlet apply_subst s1 tyl =\n if tyl = [] then []\n (* cf. PR#7543: Typemod.type_package doesn't respect type constructor arity *)\n else\n match s1 with\n Nth n1 -> [List.nth tyl n1]\n | Map l1 -> List.map (List.nth tyl) l1\n | Id -> tyl\n\ntype best_path = Paths of Path.t list | Best of Path.t\n\n(** Short-paths cache: the five mutable variables below implement a one-slot\n cache for short-paths\n *)\nlet printing_old = ref Env.empty\nlet printing_pers = ref String.Set.empty\n(** {!printing_old} and {!printing_pers} are the keys of the one-slot cache *)\n\nlet printing_depth = ref 0\nlet printing_cont = ref ([] : Env.iter_cont list)\nlet printing_map = ref Path.Map.empty\n(**\n - {!printing_map} is the main value stored in the cache.\n Note that it is evaluated lazily and its value is updated during printing.\n - {!printing_dep} is the current exploration depth of the environment,\n it is used to determine whenever the {!printing_map} should be evaluated\n further before completing a request.\n - {!printing_cont} is the list of continuations needed to evaluate\n the {!printing_map} one level further (see also {!Env.run_iter_cont})\n*)\n\nlet rec index l x =\n match l with\n [] -> raise Not_found\n | a :: l -> if eq_type x a then 0 else 1 + index l x\n\nlet rec uniq = function\n [] -> true\n | a :: l -> not (List.memq (a : int) l) && uniq l\n\nlet rec normalize_type_path ?(cache=false) env p =\n try\n let (params, ty, _) = Env.find_type_expansion p env in\n match get_desc ty with\n Tconstr (p1, tyl, _) ->\n if List.length params = List.length tyl\n && List.for_all2 eq_type params tyl\n then normalize_type_path ~cache env p1\n else if cache || List.length params <= List.length tyl\n || not (uniq (List.map get_id tyl)) then (p, Id)\n else\n let l1 = List.map (index params) tyl in\n let (p2, s2) = normalize_type_path ~cache env p1 in\n (p2, compose l1 s2)\n | _ ->\n (p, Nth (index params ty))\n with\n Not_found ->\n (Env.normalize_type_path None env p, Id)\n\nlet penalty s =\n if s <> \"\" && s.[0] = '_' then\n 10\n else\n match find_double_underscore s with\n | None -> 1\n | Some _ -> 10\n\nlet rec path_size = function\n Pident id ->\n penalty (Ident.name id), -Ident.scope id\n | Pdot (p, _) ->\n let (l, b) = path_size p in (1+l, b)\n | Papply (p1, p2) ->\n let (l, b) = path_size p1 in\n (l + fst (path_size p2), b)\n\nlet same_printing_env env =\n let used_pers = Env.used_persistent () in\n Env.same_types !printing_old env && String.Set.equal !printing_pers used_pers\n\nlet set_printing_env env =\n printing_env := env;\n if !Clflags.real_paths ||\n !printing_env == Env.empty ||\n same_printing_env env then\n ()\n else begin\n (* printf \"Reset printing_map@.\"; *)\n printing_old := env;\n printing_pers := Env.used_persistent ();\n printing_map := Path.Map.empty;\n printing_depth := 0;\n (* printf \"Recompute printing_map.@.\"; *)\n let cont =\n Env.iter_types\n (fun p (p', _decl) ->\n let (p1, s1) = normalize_type_path env p' ~cache:true in\n (* Format.eprintf \"%a -> %a = %a@.\" path p path p' path p1 *)\n if s1 = Id then\n try\n let r = Path.Map.find p1 !printing_map in\n match !r with\n Paths l -> r := Paths (p :: l)\n | Best p' -> r := Paths [p; p'] (* assert false *)\n with Not_found ->\n printing_map := Path.Map.add p1 (ref (Paths [p])) !printing_map)\n env in\n printing_cont := [cont];\n end\n\nlet wrap_printing_env env f =\n set_printing_env env; reset_naming_context ();\n try_finally f ~always:(fun () -> set_printing_env Env.empty)\n\nlet wrap_printing_env ~error env f =\n if error then Env.without_cmis (wrap_printing_env env) f\n else wrap_printing_env env f\n\nlet rec lid_of_path = function\n Path.Pident id ->\n Longident.Lident (Ident.name id)\n | Path.Pdot (p1, s) ->\n Longident.Ldot (lid_of_path p1, s)\n | Path.Papply (p1, p2) ->\n Longident.Lapply (lid_of_path p1, lid_of_path p2)\n\nlet is_unambiguous path env =\n let l = Env.find_shadowed_types path env in\n List.exists (Path.same path) l || (* concrete paths are ok *)\n match l with\n [] -> true\n | p :: rem ->\n (* allow also coherent paths: *)\n let normalize p = fst (normalize_type_path ~cache:true env p) in\n let p' = normalize p in\n List.for_all (fun p -> Path.same (normalize p) p') rem ||\n (* also allow repeatedly defining and opening (for toplevel) *)\n let id = lid_of_path p in\n List.for_all (fun p -> lid_of_path p = id) rem &&\n Path.same p (fst (Env.find_type_by_name id env))\n\nlet rec get_best_path r =\n match !r with\n Best p' -> p'\n | Paths [] -> raise Not_found\n | Paths l ->\n r := Paths [];\n List.iter\n (fun p ->\n (* Format.eprintf \"evaluating %a@.\" path p; *)\n match !r with\n Best p' when path_size p >= path_size p' -> ()\n | _ -> if is_unambiguous p !printing_env then r := Best p)\n (* else Format.eprintf \"%a ignored as ambiguous@.\" path p *)\n l;\n get_best_path r\n\nlet best_type_path p =\n if !printing_env == Env.empty\n then (p, Id)\n else if !Clflags.real_paths\n then (p, Id)\n else\n let (p', s) = normalize_type_path !printing_env p in\n let get_path () = get_best_path (Path.Map.find p' !printing_map) in\n while !printing_cont <> [] &&\n try fst (path_size (get_path ())) > !printing_depth with Not_found -> true\n do\n printing_cont := List.map snd (Env.run_iter_cont !printing_cont);\n incr printing_depth;\n done;\n let p'' = try get_path () with Not_found -> p' in\n (* Format.eprintf \"%a = %a -> %a@.\" path p path p' path p''; *)\n (p'', s)\n\n(* Print a type expression *)\n\nlet proxy ty = Transient_expr.repr (proxy ty)\n\n(* When printing a type scheme, we print weak names. When printing a plain\n type, we do not. This type controls that behavior *)\ntype type_or_scheme = Type | Type_scheme\n\nlet is_non_gen mode ty =\n match mode with\n | Type_scheme -> is_Tvar ty && get_level ty <> generic_level\n | Type -> false\n\nlet nameable_row row =\n row_name row <> None &&\n List.for_all\n (fun (_, f) ->\n match row_field_repr f with\n | Reither(c, l, _) ->\n row_closed row && if c then l = [] else List.length l = 1\n | _ -> true)\n (row_fields row)\n\n(* This specialized version of [Btype.iter_type_expr] normalizes and\n short-circuits the traversal of the [type_expr], so that it covers only the\n subterms that would be printed by the type printer. *)\nlet printer_iter_type_expr f ty =\n match get_desc ty with\n | Tconstr(p, tyl, _) ->\n let (_p', s) = best_type_path p in\n List.iter f (apply_subst s tyl)\n | Tvariant row -> begin\n match row_name row with\n | Some(_p, tyl) when nameable_row row ->\n List.iter f tyl\n | _ ->\n iter_row f row\n end\n | Tobject (fi, nm) -> begin\n match !nm with\n | None ->\n let fields, _ = flatten_fields fi in\n List.iter\n (fun (_, kind, ty) ->\n if field_kind_repr kind = Fpublic then\n f ty)\n fields\n | Some (_, l) ->\n List.iter f (List.tl l)\n end\n | Tfield(_, kind, ty1, ty2) ->\n if field_kind_repr kind = Fpublic then\n f ty1;\n f ty2\n | _ ->\n Btype.iter_type_expr f ty\n\nmodule Names : sig\n val reset_names : unit -> unit\n\n val add_named_vars : type_expr -> unit\n val add_subst : (type_expr * type_expr) list -> unit\n\n val new_name : unit -> string\n val new_weak_name : type_expr -> unit -> string\n\n val name_of_type : (unit -> string) -> transient_expr -> string\n val check_name_of_type : transient_expr -> unit\n\n val remove_names : transient_expr list -> unit\n\n val with_local_names : (unit -> 'a) -> 'a\n\n (* Refresh the weak variable map in the toplevel; for [print_items], which is\n itself for the toplevel *)\n val refresh_weak : unit -> unit\nend = struct\n (* We map from types to names, but not directly; we also store a substitution,\n which maps from types to types. The lookup process is\n \"type -> apply substitution -> find name\". The substitution is presumed to\n be acyclic. *)\n let names = ref ([] : (transient_expr * string) list)\n let name_subst = ref ([] : (transient_expr * transient_expr) list)\n let name_counter = ref 0\n let named_vars = ref ([] : string list)\n let visited_for_named_vars = ref ([] : transient_expr list)\n\n let weak_counter = ref 1\n let weak_var_map = ref TypeMap.empty\n let named_weak_vars = ref String.Set.empty\n\n let reset_names () =\n names := [];\n name_subst := [];\n name_counter := 0;\n named_vars := [];\n visited_for_named_vars := []\n\n let add_named_var tty =\n match tty.desc with\n Tvar (Some name) | Tunivar (Some name) ->\n if List.mem name !named_vars then () else\n named_vars := name :: !named_vars\n | _ -> ()\n\n let rec add_named_vars ty =\n let tty = Transient_expr.repr ty in\n let px = proxy ty in\n if not (List.memq px !visited_for_named_vars) then begin\n visited_for_named_vars := px :: !visited_for_named_vars;\n match tty.desc with\n | Tvar _ | Tunivar _ ->\n add_named_var tty\n | _ ->\n printer_iter_type_expr add_named_vars ty\n end\n\n let rec substitute ty =\n match List.assq ty !name_subst with\n | ty' -> substitute ty'\n | exception Not_found -> ty\n\n let add_subst subst =\n name_subst :=\n List.map (fun (t1,t2) -> Transient_expr.repr t1, Transient_expr.repr t2)\n subst\n @ !name_subst\n\n let name_is_already_used name =\n List.mem name !named_vars\n || List.exists (fun (_, name') -> name = name') !names\n || String.Set.mem name !named_weak_vars\n\n let rec new_name () =\n let name =\n if !name_counter < 26\n then String.make 1 (Char.chr(97 + !name_counter))\n else String.make 1 (Char.chr(97 + !name_counter mod 26)) ^\n Int.to_string(!name_counter / 26) in\n incr name_counter;\n if name_is_already_used name then new_name () else name\n\n let rec new_weak_name ty () =\n let name = \"weak\" ^ Int.to_string !weak_counter in\n incr weak_counter;\n if name_is_already_used name then new_weak_name ty ()\n else begin\n named_weak_vars := String.Set.add name !named_weak_vars;\n weak_var_map := TypeMap.add ty name !weak_var_map;\n name\n end\n\n let name_of_type name_generator t =\n (* We've already been through repr at this stage, so t is our representative\n of the union-find class. *)\n let t = substitute t in\n try List.assq t !names with Not_found ->\n try TransientTypeMap.find t !weak_var_map with Not_found ->\n let name =\n match t.desc with\n Tvar (Some name) | Tunivar (Some name) ->\n (* Some part of the type we've already printed has assigned another\n * unification variable to that name. We want to keep the name, so\n * try adding a number until we find a name that's not taken. *)\n let current_name = ref name in\n let i = ref 0 in\n while List.exists\n (fun (_, name') -> !current_name = name')\n !names\n do\n current_name := name ^ (Int.to_string !i);\n i := !i + 1;\n done;\n !current_name\n | _ ->\n (* No name available, create a new one *)\n name_generator ()\n in\n (* Exception for type declarations *)\n if name <> \"_\" then names := (t, name) :: !names;\n name\n\n let check_name_of_type t = ignore(name_of_type new_name t)\n\n let remove_names tyl =\n let tyl = List.map substitute tyl in\n names := List.filter (fun (ty,_) -> not (List.memq ty tyl)) !names\n\n let with_local_names f =\n let old_names = !names in\n let old_subst = !name_subst in\n names := [];\n name_subst := [];\n try_finally\n ~always:(fun () ->\n names := old_names;\n name_subst := old_subst)\n f\n\n let refresh_weak () =\n let refresh t name (m,s) =\n if is_non_gen Type_scheme t then\n begin\n TypeMap.add t name m,\n String.Set.add name s\n end\n else m, s in\n let m, s =\n TypeMap.fold refresh !weak_var_map (TypeMap.empty ,String.Set.empty) in\n named_weak_vars := s;\n weak_var_map := m\nend\n\nlet reserve_names ty =\n normalize_type ty;\n Names.add_named_vars ty\n\nlet visited_objects = ref ([] : transient_expr list)\nlet aliased = ref ([] : transient_expr list)\nlet delayed = ref ([] : transient_expr list)\nlet printed_aliases = ref ([] : transient_expr list)\n\n(* [printed_aliases] is a subset of [aliased] that records only those aliased\n types that have actually been printed; this allows us to avoid naming loops\n that the user will never see. *)\n\nlet add_delayed t =\n if not (List.memq t !delayed) then delayed := t :: !delayed\n\nlet is_aliased_proxy px = List.memq px !aliased\n\nlet add_alias_proxy px =\n if not (is_aliased_proxy px) then\n aliased := px :: !aliased\n\nlet add_alias ty = add_alias_proxy (proxy ty)\n\nlet add_printed_alias_proxy px =\n Names.check_name_of_type px;\n printed_aliases := px :: !printed_aliases\n\nlet add_printed_alias ty = add_printed_alias_proxy (proxy ty)\n\nlet aliasable ty =\n match get_desc ty with\n Tvar _ | Tunivar _ | Tpoly _ -> false\n | Tconstr (p, _, _) ->\n not (is_nth (snd (best_type_path p)))\n | _ -> true\n\nlet should_visit_object ty =\n match get_desc ty with\n | Tvariant row -> not (static_row row)\n | Tobject _ -> opened_object ty\n | _ -> false\n\nlet rec mark_loops_rec visited ty =\n let px = proxy ty in\n if List.memq px visited && aliasable ty then add_alias_proxy px else\n let tty = Transient_expr.repr ty in\n let visited = px :: visited in\n match tty.desc with\n | Tvariant _ | Tobject _ ->\n if List.memq px !visited_objects then add_alias_proxy px else begin\n if should_visit_object ty then\n visited_objects := px :: !visited_objects;\n printer_iter_type_expr (mark_loops_rec visited) ty\n end\n | Tpoly(ty, tyl) ->\n List.iter add_alias tyl;\n mark_loops_rec visited ty\n | _ ->\n printer_iter_type_expr (mark_loops_rec visited) ty\n\nlet mark_loops ty =\n mark_loops_rec [] ty;;\n\nlet prepare_type ty =\n reserve_names ty;\n mark_loops ty;;\n\nlet reset_loop_marks () =\n visited_objects := []; aliased := []; delayed := []; printed_aliases := []\n\nlet reset_except_context () =\n Names.reset_names (); reset_loop_marks ()\n\nlet reset () =\n reset_naming_context (); Conflicts.reset ();\n reset_except_context ()\n\nlet prepare_for_printing tyl =\n reset_except_context (); List.iter prepare_type tyl\n\n(* Disabled in classic mode when printing an unification error *)\nlet print_labels = ref true\n\nlet rec tree_of_typexp mode ty =\n let px = proxy ty in\n if List.memq px !printed_aliases && not (List.memq px !delayed) then\n let mark = is_non_gen mode ty in\n let name = Names.name_of_type\n (if mark then Names.new_weak_name ty else Names.new_name)\n px\n in\n Otyp_var (mark, name) else\n\n let pr_typ () =\n let tty = Transient_expr.repr ty in\n match tty.desc with\n | Tvar _ ->\n let non_gen = is_non_gen mode ty in\n let name_gen =\n if non_gen then Names.new_weak_name ty else Names.new_name\n in\n Otyp_var (non_gen, Names.name_of_type name_gen tty)\n | Tarrow(l, ty1, ty2, _) ->\n let lab =\n if !print_labels || is_optional l then string_of_label l else \"\"\n in\n let t1 =\n if is_optional l then\n match get_desc ty1 with\n | Tconstr(path, [ty], _)\n when Path.same path Predef.path_option ->\n tree_of_typexp mode ty\n | _ -> Otyp_stuff \"\"\n else tree_of_typexp mode ty1 in\n Otyp_arrow (lab, t1, tree_of_typexp mode ty2)\n | Ttuple tyl ->\n Otyp_tuple (tree_of_typlist mode tyl)\n | Tconstr(p, tyl, _abbrev) ->\n let p', s = best_type_path p in\n let tyl' = apply_subst s tyl in\n if is_nth s && not (tyl'=[])\n then tree_of_typexp mode (List.hd tyl')\n else Otyp_constr (tree_of_path Type p', tree_of_typlist mode tyl')\n | Tvariant row ->\n let Row {fields; name; closed} = row_repr row in\n let fields =\n if closed then\n List.filter (fun (_, f) -> row_field_repr f <> Rabsent)\n fields\n else fields in\n let present =\n List.filter\n (fun (_, f) ->\n match row_field_repr f with\n | Rpresent _ -> true\n | _ -> false)\n fields in\n let all_present = List.length present = List.length fields in\n begin match name with\n | Some(p, tyl) when nameable_row row ->\n let (p', s) = best_type_path p in\n let id = tree_of_path Type p' in\n let args = tree_of_typlist mode (apply_subst s tyl) in\n let out_variant =\n if is_nth s then List.hd args else Otyp_constr (id, args) in\n if closed && all_present then\n out_variant\n else\n let non_gen = is_non_gen mode (Transient_expr.type_expr px) in\n let tags =\n if all_present then None else Some (List.map fst present) in\n Otyp_variant (non_gen, Ovar_typ out_variant, closed, tags)\n | _ ->\n let non_gen =\n not (closed && all_present) &&\n is_non_gen mode (Transient_expr.type_expr px) in\n let fields = List.map (tree_of_row_field mode) fields in\n let tags =\n if all_present then None else Some (List.map fst present) in\n Otyp_variant (non_gen, Ovar_fields fields, closed, tags)\n end\n | Tobject (fi, nm) ->\n tree_of_typobject mode fi !nm\n | Tnil | Tfield _ ->\n tree_of_typobject mode ty None\n | Tsubst _ ->\n (* This case should only happen when debugging the compiler *)\n Otyp_stuff \"\"\n | Tlink _ ->\n fatal_error \"Printtyp.tree_of_typexp\"\n | Tpoly (ty, []) ->\n tree_of_typexp mode ty\n | Tpoly (ty, tyl) ->\n (*let print_names () =\n List.iter (fun (_, name) -> prerr_string (name ^ \" \")) !names;\n prerr_string \"; \" in *)\n if tyl = [] then tree_of_typexp mode ty else begin\n let tyl = List.map Transient_expr.repr tyl in\n let old_delayed = !delayed in\n (* Make the names delayed, so that the real type is\n printed once when used as proxy *)\n List.iter add_delayed tyl;\n let tl = List.map (Names.name_of_type Names.new_name) tyl in\n let tr = Otyp_poly (tl, tree_of_typexp mode ty) in\n (* Forget names when we leave scope *)\n Names.remove_names tyl;\n delayed := old_delayed; tr\n end\n | Tunivar _ ->\n Otyp_var (false, Names.name_of_type Names.new_name tty)\n | Tpackage (p, fl) ->\n let fl =\n List.map\n (fun (li, ty) -> (\n String.concat \".\" (Longident.flatten li),\n tree_of_typexp mode ty\n )) fl in\n Otyp_module (tree_of_path Module_type p, fl)\n in\n if List.memq px !delayed then delayed := List.filter ((!=) px) !delayed;\n if is_aliased_proxy px && aliasable ty then begin\n add_printed_alias_proxy px;\n Otyp_alias (pr_typ (), Names.name_of_type Names.new_name px) end\n else pr_typ ()\n\nand tree_of_row_field mode (l, f) =\n match row_field_repr f with\n | Rpresent None | Reither(true, [], _) -> (l, false, [])\n | Rpresent(Some ty) -> (l, false, [tree_of_typexp mode ty])\n | Reither(c, tyl, _) ->\n if c (* contradiction: constant constructor with an argument *)\n then (l, true, tree_of_typlist mode tyl)\n else (l, false, tree_of_typlist mode tyl)\n | Rabsent -> (l, false, [] (* actually, an error *))\n\nand tree_of_typlist mode tyl =\n List.map (tree_of_typexp mode) tyl\n\nand tree_of_typobject mode fi nm =\n begin match nm with\n | None ->\n let pr_fields fi =\n let (fields, rest) = flatten_fields fi in\n let present_fields =\n List.fold_right\n (fun (n, k, t) l ->\n match field_kind_repr k with\n | Fpublic -> (n, t) :: l\n | _ -> l)\n fields [] in\n let sorted_fields =\n List.sort\n (fun (n, _) (n', _) -> String.compare n n') present_fields in\n tree_of_typfields mode rest sorted_fields in\n let (fields, rest) = pr_fields fi in\n Otyp_object (fields, rest)\n | Some (p, ty :: tyl) ->\n let non_gen = is_non_gen mode ty in\n let args = tree_of_typlist mode tyl in\n let (p', s) = best_type_path p in\n assert (s = Id);\n Otyp_class (non_gen, tree_of_path Type p', args)\n | _ ->\n fatal_error \"Printtyp.tree_of_typobject\"\n end\n\nand tree_of_typfields mode rest = function\n | [] ->\n let rest =\n match get_desc rest with\n | Tvar _ | Tunivar _ -> Some (is_non_gen mode rest)\n | Tconstr _ -> Some false\n | Tnil -> None\n | _ -> fatal_error \"typfields (1)\"\n in\n ([], rest)\n | (s, t) :: l ->\n let field = (s, tree_of_typexp mode t) in\n let (fields, rest) = tree_of_typfields mode rest l in\n (field :: fields, rest)\n\nlet typexp mode ppf ty =\n !Oprint.out_type ppf (tree_of_typexp mode ty)\n\nlet prepared_type_expr ppf ty = typexp Type ppf ty\n\nlet type_expr ppf ty =\n (* [type_expr] is used directly by error message printers,\n we mark eventual loops ourself to avoid any misuse and stack overflow *)\n prepare_for_printing [ty];\n prepared_type_expr ppf ty\n\n(* \"Half-prepared\" type expression: [ty] should have had its names reserved, but\n should not have had its loops marked. *)\nlet type_expr_with_reserved_names ppf ty =\n reset_loop_marks ();\n mark_loops ty;\n prepared_type_expr ppf ty\n\nlet shared_type_scheme ppf ty =\n prepare_type ty;\n typexp Type_scheme ppf ty\n\nlet type_scheme ppf ty =\n prepare_for_printing [ty];\n typexp Type_scheme ppf ty\n\nlet type_path ppf p =\n let (p', s) = best_type_path p in\n let p = if (s = Id) then p' else p in\n let t = tree_of_path Type p in\n !Oprint.out_ident ppf t\n\nlet tree_of_type_scheme ty =\n prepare_for_printing [ty];\n tree_of_typexp Type_scheme ty\n\n(* Print one type declaration *)\n\nlet tree_of_constraints params =\n List.fold_right\n (fun ty list ->\n let ty' = unalias ty in\n if proxy ty != proxy ty' then\n let tr = tree_of_typexp Type_scheme ty in\n (tr, tree_of_typexp Type_scheme ty') :: list\n else list)\n params []\n\nlet filter_params tyl =\n let params =\n List.fold_left\n (fun tyl ty ->\n if List.exists (eq_type ty) tyl\n then newty2 ~level:generic_level (Ttuple [ty]) :: tyl\n else ty :: tyl)\n (* Two parameters might be identical due to a constraint but we need to\n print them differently in order to make the output syntactically valid.\n We use [Ttuple [ty]] because it is printed as [ty]. *)\n (* Replacing fold_left by fold_right does not work! *)\n [] tyl\n in List.rev params\n\nlet prepare_type_constructor_arguments = function\n | Cstr_tuple l -> List.iter prepare_type l\n | Cstr_record l -> List.iter (fun l -> prepare_type l.ld_type) l\n\nlet rec tree_of_type_decl id decl =\n\n reset_except_context();\n\n let params = filter_params decl.type_params in\n\n begin match decl.type_manifest with\n | Some ty ->\n let vars = free_variables ty in\n List.iter\n (fun ty ->\n if get_desc ty = Tvar (Some \"_\") && List.exists (eq_type ty) vars\n then set_type_desc ty (Tvar None))\n params\n | None -> ()\n end;\n\n List.iter add_alias params;\n List.iter prepare_type params;\n List.iter add_printed_alias params;\n let ty_manifest =\n match decl.type_manifest with\n | None -> None\n | Some ty ->\n let ty =\n (* Special hack to hide variant name *)\n match get_desc ty with\n Tvariant row ->\n begin match row_name row with\n Some (Pident id', _) when Ident.same id id' ->\n newgenty (Tvariant (set_row_name row None))\n | _ -> ty\n end\n | _ -> ty\n in\n prepare_type ty;\n Some ty\n in\n begin match decl.type_kind with\n | Type_abstract -> ()\n | Type_variant (cstrs, _rep) ->\n List.iter\n (fun c ->\n prepare_type_constructor_arguments c.cd_args;\n Option.iter prepare_type c.cd_res)\n cstrs\n | Type_record(l, _rep) ->\n List.iter (fun l -> prepare_type l.ld_type) l\n | Type_open -> ()\n end;\n\n let type_param =\n function\n | Otyp_var (_, id) -> id\n | _ -> \"?\"\n in\n let type_defined decl =\n let abstr =\n match decl.type_kind with\n Type_abstract ->\n decl.type_manifest = None || decl.type_private = Private\n | Type_record _ ->\n decl.type_private = Private\n | Type_variant (tll, _rep) ->\n decl.type_private = Private ||\n List.exists (fun cd -> cd.cd_res <> None) tll\n | Type_open ->\n decl.type_manifest = None\n in\n let vari =\n List.map2\n (fun ty v ->\n let is_var = is_Tvar ty in\n if abstr || not is_var then\n let inj =\n decl.type_kind = Type_abstract && Variance.mem Inj v &&\n match decl.type_manifest with\n | None -> true\n | Some ty -> (* only abstract or private row types *)\n decl.type_private = Private &&\n Btype.is_constr_row ~allow_ident:true (Btype.row_of_type ty)\n and (co, cn) = Variance.get_upper v in\n (if not cn then Covariant else\n if not co then Contravariant else NoVariance),\n (if inj then Injective else NoInjectivity)\n else (NoVariance, NoInjectivity))\n decl.type_params decl.type_variance\n in\n (Ident.name id,\n List.map2 (fun ty cocn -> type_param (tree_of_typexp Type ty), cocn)\n params vari)\n in\n let tree_of_manifest ty1 =\n match ty_manifest with\n | None -> ty1\n | Some ty -> Otyp_manifest (tree_of_typexp Type ty, ty1)\n in\n let (name, args) = type_defined decl in\n let constraints = tree_of_constraints params in\n let ty, priv, unboxed =\n match decl.type_kind with\n | Type_abstract ->\n begin match ty_manifest with\n | None -> (Otyp_abstract, Public, false)\n | Some ty ->\n tree_of_typexp Type ty, decl.type_private, false\n end\n | Type_variant (cstrs, rep) ->\n tree_of_manifest (Otyp_sum (List.map tree_of_constructor cstrs)),\n decl.type_private,\n (rep = Variant_unboxed)\n | Type_record(lbls, rep) ->\n tree_of_manifest (Otyp_record (List.map tree_of_label lbls)),\n decl.type_private,\n (match rep with Record_unboxed _ -> true | _ -> false)\n | Type_open ->\n tree_of_manifest Otyp_open,\n decl.type_private,\n false\n in\n { otype_name = name;\n otype_params = args;\n otype_type = ty;\n otype_private = priv;\n otype_immediate = Type_immediacy.of_attributes decl.type_attributes;\n otype_unboxed = unboxed;\n otype_cstrs = constraints }\n\nand tree_of_constructor_arguments = function\n | Cstr_tuple l -> tree_of_typlist Type l\n | Cstr_record l -> [ Otyp_record (List.map tree_of_label l) ]\n\nand tree_of_constructor cd =\n let name = Ident.name cd.cd_id in\n let arg () = tree_of_constructor_arguments cd.cd_args in\n match cd.cd_res with\n | None -> {\n ocstr_name = name;\n ocstr_args = arg ();\n ocstr_return_type = None;\n }\n | Some res ->\n Names.with_local_names (fun () ->\n let ret = tree_of_typexp Type res in\n let args = arg () in\n {\n ocstr_name = name;\n ocstr_args = args;\n ocstr_return_type = Some ret;\n })\n\nand tree_of_label l =\n (Ident.name l.ld_id, l.ld_mutable = Mutable, tree_of_typexp Type l.ld_type)\n\nlet constructor ppf c =\n reset_except_context ();\n !Oprint.out_constr ppf (tree_of_constructor c)\n\nlet label ppf l =\n reset_except_context ();\n !Oprint.out_label ppf (tree_of_label l)\n\nlet tree_of_type_declaration id decl rs =\n Osig_type (tree_of_type_decl id decl, tree_of_rec rs)\n\nlet type_declaration id ppf decl =\n !Oprint.out_sig_item ppf (tree_of_type_declaration id decl Trec_first)\n\nlet constructor_arguments ppf a =\n let tys = tree_of_constructor_arguments a in\n !Oprint.out_type ppf (Otyp_tuple tys)\n\n(* Print an extension declaration *)\n\nlet extension_constructor_args_and_ret_type_subtree ext_args ext_ret_type =\n match ext_ret_type with\n | None -> (tree_of_constructor_arguments ext_args, None)\n | Some res ->\n Names.with_local_names (fun () ->\n let ret = tree_of_typexp Type res in\n let args = tree_of_constructor_arguments ext_args in\n (args, Some ret))\n\nlet tree_of_extension_constructor id ext es =\n reset_except_context ();\n let ty_name = Path.name ext.ext_type_path in\n let ty_params = filter_params ext.ext_type_params in\n List.iter add_alias ty_params;\n List.iter prepare_type ty_params;\n List.iter add_printed_alias ty_params;\n prepare_type_constructor_arguments ext.ext_args;\n Option.iter prepare_type ext.ext_ret_type;\n let type_param =\n function\n | Otyp_var (_, id) -> id\n | _ -> \"?\"\n in\n let ty_params =\n List.map (fun ty -> type_param (tree_of_typexp Type ty)) ty_params\n in\n let name = Ident.name id in\n let args, ret =\n extension_constructor_args_and_ret_type_subtree\n ext.ext_args\n ext.ext_ret_type\n in\n let ext =\n { oext_name = name;\n oext_type_name = ty_name;\n oext_type_params = ty_params;\n oext_args = args;\n oext_ret_type = ret;\n oext_private = ext.ext_private }\n in\n let es =\n match es with\n Text_first -> Oext_first\n | Text_next -> Oext_next\n | Text_exception -> Oext_exception\n in\n Osig_typext (ext, es)\n\nlet extension_constructor id ppf ext =\n !Oprint.out_sig_item ppf (tree_of_extension_constructor id ext Text_first)\n\nlet extension_only_constructor id ppf ext =\n reset_except_context ();\n let name = Ident.name id in\n let args, ret =\n extension_constructor_args_and_ret_type_subtree\n ext.ext_args\n ext.ext_ret_type\n in\n Format.fprintf ppf \"@[%a@]\"\n !Oprint.out_constr {\n ocstr_name = name;\n ocstr_args = args;\n ocstr_return_type = ret;\n }\n\n(* Print a value declaration *)\n\nlet tree_of_value_description id decl =\n (* Format.eprintf \"@[%a@]@.\" raw_type_expr decl.val_type; *)\n let id = Ident.name id in\n let ty = tree_of_type_scheme decl.val_type in\n let vd =\n { oval_name = id;\n oval_type = ty;\n oval_prims = [];\n oval_attributes = [] }\n in\n let vd =\n match decl.val_kind with\n | Val_prim p -> Primitive.print p vd\n | _ -> vd\n in\n Osig_value vd\n\nlet value_description id ppf decl =\n !Oprint.out_sig_item ppf (tree_of_value_description id decl)\n\n(* Print a class type *)\n\nlet method_type priv ty =\n match priv, get_desc ty with\n | Mpublic, Tpoly(ty, tyl) -> (ty, tyl)\n | _ , _ -> (ty, [])\n\nlet prepare_method _lab (priv, _virt, ty) =\n let ty, _ = method_type priv ty in\n prepare_type ty\n\nlet tree_of_method mode (lab, priv, virt, ty) =\n let (ty, tyl) = method_type priv ty in\n let tty = tree_of_typexp mode ty in\n Names.remove_names (List.map Transient_expr.repr tyl);\n let priv = priv <> Mpublic in\n let virt = virt = Virtual in\n Ocsg_method (lab, priv, virt, tty)\n\nlet rec prepare_class_type params = function\n | Cty_constr (_p, tyl, cty) ->\n let row = Btype.self_type_row cty in\n if List.memq (proxy row) !visited_objects\n || not (List.for_all is_Tvar params)\n || List.exists (deep_occur row) tyl\n then prepare_class_type params cty\n else List.iter prepare_type tyl\n | Cty_signature sign ->\n (* Self may have a name *)\n let px = proxy sign.csig_self_row in\n if List.memq px !visited_objects then add_alias_proxy px\n else visited_objects := px :: !visited_objects;\n Vars.iter (fun _ (_, _, ty) -> prepare_type ty) sign.csig_vars;\n Meths.iter prepare_method sign.csig_meths\n | Cty_arrow (_, ty, cty) ->\n prepare_type ty;\n prepare_class_type params cty\n\nlet rec tree_of_class_type mode params =\n function\n | Cty_constr (p', tyl, cty) ->\n let row = Btype.self_type_row cty in\n if List.memq (proxy row) !visited_objects\n || not (List.for_all is_Tvar params)\n then\n tree_of_class_type mode params cty\n else\n let namespace = Namespace.best_class_namespace p' in\n Octy_constr (tree_of_path namespace p', tree_of_typlist Type_scheme tyl)\n | Cty_signature sign ->\n let px = proxy sign.csig_self_row in\n let self_ty =\n if is_aliased_proxy px then\n Some\n (Otyp_var (false, Names.name_of_type Names.new_name px))\n else None\n in\n let csil = [] in\n let csil =\n List.fold_left\n (fun csil (ty1, ty2) -> Ocsg_constraint (ty1, ty2) :: csil)\n csil (tree_of_constraints params)\n in\n let all_vars =\n Vars.fold (fun l (m, v, t) all -> (l, m, v, t) :: all) sign.csig_vars []\n in\n (* Consequence of PR#3607: order of Map.fold has changed! *)\n let all_vars = List.rev all_vars in\n let csil =\n List.fold_left\n (fun csil (l, m, v, t) ->\n Ocsg_value (l, m = Mutable, v = Virtual, tree_of_typexp mode t)\n :: csil)\n csil all_vars\n in\n let all_meths =\n Meths.fold\n (fun l (p, v, t) all -> (l, p, v, t) :: all)\n sign.csig_meths []\n in\n let all_meths = List.rev all_meths in\n let csil =\n List.fold_left\n (fun csil meth -> tree_of_method mode meth :: csil)\n csil all_meths\n in\n Octy_signature (self_ty, List.rev csil)\n | Cty_arrow (l, ty, cty) ->\n let lab =\n if !print_labels || is_optional l then string_of_label l else \"\"\n in\n let tr =\n if is_optional l then\n match get_desc ty with\n | Tconstr(path, [ty], _) when Path.same path Predef.path_option ->\n tree_of_typexp mode ty\n | _ -> Otyp_stuff \"\"\n else tree_of_typexp mode ty in\n Octy_arrow (lab, tr, tree_of_class_type mode params cty)\n\nlet class_type ppf cty =\n reset ();\n prepare_class_type [] cty;\n !Oprint.out_class_type ppf (tree_of_class_type Type [] cty)\n\nlet tree_of_class_param param variance =\n (match tree_of_typexp Type_scheme param with\n Otyp_var (_, s) -> s\n | _ -> \"?\"),\n if is_Tvar param then Asttypes.(NoVariance, NoInjectivity)\n else variance\n\nlet class_variance =\n let open Variance in let open Asttypes in\n List.map (fun v ->\n (if not (mem May_pos v) then Contravariant else\n if not (mem May_neg v) then Covariant else NoVariance),\n NoInjectivity)\n\nlet tree_of_class_declaration id cl rs =\n let params = filter_params cl.cty_params in\n\n reset_except_context ();\n List.iter add_alias params;\n prepare_class_type params cl.cty_type;\n let px = proxy (Btype.self_type_row cl.cty_type) in\n List.iter prepare_type params;\n\n List.iter add_printed_alias params;\n if is_aliased_proxy px then add_printed_alias_proxy px;\n\n let vir_flag = cl.cty_new = None in\n Osig_class\n (vir_flag, Ident.name id,\n List.map2 tree_of_class_param params (class_variance cl.cty_variance),\n tree_of_class_type Type_scheme params cl.cty_type,\n tree_of_rec rs)\n\nlet class_declaration id ppf cl =\n !Oprint.out_sig_item ppf (tree_of_class_declaration id cl Trec_first)\n\nlet tree_of_cltype_declaration id cl rs =\n let params = cl.clty_params in\n\n reset_except_context ();\n List.iter add_alias params;\n prepare_class_type params cl.clty_type;\n let px = proxy (Btype.self_type_row cl.clty_type) in\n List.iter prepare_type params;\n\n List.iter add_printed_alias params;\n if is_aliased_proxy px then add_printed_alias_proxy px;\n\n let sign = Btype.signature_of_class_type cl.clty_type in\n let has_virtual_vars =\n Vars.fold (fun _ (_,vr,_) b -> vr = Virtual || b)\n sign.csig_vars false\n in\n let has_virtual_meths =\n Meths.fold (fun _ (_,vr,_) b -> vr = Virtual || b)\n sign.csig_meths false\n in\n Osig_class_type\n (has_virtual_vars || has_virtual_meths, Ident.name id,\n List.map2 tree_of_class_param params (class_variance cl.clty_variance),\n tree_of_class_type Type_scheme params cl.clty_type,\n tree_of_rec rs)\n\nlet cltype_declaration id ppf cl =\n !Oprint.out_sig_item ppf (tree_of_cltype_declaration id cl Trec_first)\n\n(* Print a module type *)\n\nlet wrap_env fenv ftree arg =\n (* We save the current value of the short-path cache *)\n (* From keys *)\n let env = !printing_env in\n let old_pers = !printing_pers in\n (* to data *)\n let old_map = !printing_map in\n let old_depth = !printing_depth in\n let old_cont = !printing_cont in\n set_printing_env (fenv env);\n let tree = ftree arg in\n if !Clflags.real_paths\n || same_printing_env env then ()\n (* our cached key is still live in the cache, and we want to keep all\n progress made on the computation of the [printing_map] *)\n else begin\n (* we restore the snapshotted cache before calling set_printing_env *)\n printing_old := env;\n printing_pers := old_pers;\n printing_depth := old_depth;\n printing_cont := old_cont;\n printing_map := old_map\n end;\n set_printing_env env;\n tree\n\nlet dummy =\n {\n type_params = [];\n type_arity = 0;\n type_kind = Type_abstract;\n type_private = Public;\n type_manifest = None;\n type_variance = [];\n type_separability = [];\n type_is_newtype = false;\n type_expansion_scope = Btype.lowest_level;\n type_loc = Location.none;\n type_attributes = [];\n type_immediate = Unknown;\n type_unboxed_default = false;\n type_uid = Uid.internal_not_actually_unique;\n }\n\n(** we hide items being defined from short-path to avoid shortening\n [type t = Path.To.t] into [type t = t].\n*)\n\nlet ident_sigitem = function\n | Types.Sig_type(ident,_,_,_) -> {hide=true;ident}\n | Types.Sig_class(ident,_,_,_)\n | Types.Sig_class_type (ident,_,_,_)\n | Types.Sig_module(ident,_, _,_,_)\n | Types.Sig_value (ident,_,_)\n | Types.Sig_modtype (ident,_,_)\n | Types.Sig_typext (ident,_,_,_) -> {hide=false; ident }\n\nlet hide ids env =\n let hide_id id env =\n (* Global idents cannot be renamed *)\n if id.hide && not (Ident.global id.ident) then\n Env.add_type ~check:false (Ident.rename id.ident) dummy env\n else env\n in\n List.fold_right hide_id ids env\n\nlet with_hidden_items ids f =\n let with_hidden_in_printing_env ids f =\n wrap_env (hide ids) (Naming_context.with_hidden ids) f\n in\n if not !Clflags.real_paths then\n with_hidden_in_printing_env ids f\n else\n Naming_context.with_hidden ids f\n\n\nlet add_sigitem env x =\n Env.add_signature (Signature_group.flatten x) env\n\nlet rec tree_of_modtype ?(ellipsis=false) = function\n | Mty_ident p ->\n Omty_ident (tree_of_path Module_type p)\n | Mty_signature sg ->\n Omty_signature (if ellipsis then [Osig_ellipsis]\n else tree_of_signature sg)\n | Mty_functor(param, ty_res) ->\n let param, env =\n tree_of_functor_parameter param\n in\n let res = wrap_env env (tree_of_modtype ~ellipsis) ty_res in\n Omty_functor (param, res)\n | Mty_alias p ->\n Omty_alias (tree_of_path Module p)\n\nand tree_of_functor_parameter = function\n | Unit ->\n None, fun k -> k\n | Named (param, ty_arg) ->\n let name, env =\n match param with\n | None -> None, fun env -> env\n | Some id ->\n Some (Ident.name id),\n Env.add_module ~arg:true id Mp_present ty_arg\n in\n Some (name, tree_of_modtype ~ellipsis:false ty_arg), env\n\nand tree_of_signature sg =\n wrap_env (fun env -> env)(fun sg ->\n let tree_groups = tree_of_signature_rec !printing_env sg in\n List.concat_map (fun (_env,l) -> List.map snd l) tree_groups\n ) sg\n\nand tree_of_signature_rec env' sg =\n let structured = List.of_seq (Signature_group.seq sg) in\n let collect_trees_of_rec_group group =\n let env = !printing_env in\n let env', group_trees =\n Naming_context.with_ctx\n (fun () -> trees_of_recursive_sigitem_group env group)\n in\n set_printing_env env';\n (env, group_trees) in\n set_printing_env env';\n List.map collect_trees_of_rec_group structured\n\nand trees_of_recursive_sigitem_group env\n (syntactic_group: Signature_group.rec_group) =\n let display (x:Signature_group.sig_item) = x.src, tree_of_sigitem x.src in\n let env = Env.add_signature syntactic_group.pre_ghosts env in\n match syntactic_group.group with\n | Not_rec x -> add_sigitem env x, [display x]\n | Rec_group items ->\n let ids = List.map (fun x -> ident_sigitem x.Signature_group.src) items in\n List.fold_left add_sigitem env items,\n with_hidden_items ids (fun () -> List.map display items)\n\nand tree_of_sigitem = function\n | Sig_value(id, decl, _) ->\n tree_of_value_description id decl\n | Sig_type(id, decl, rs, _) ->\n tree_of_type_declaration id decl rs\n | Sig_typext(id, ext, es, _) ->\n tree_of_extension_constructor id ext es\n | Sig_module(id, _, md, rs, _) ->\n let ellipsis =\n List.exists (function\n | Parsetree.{attr_name = {txt=\"...\"}; attr_payload = PStr []} -> true\n | _ -> false)\n md.md_attributes in\n tree_of_module id md.md_type rs ~ellipsis\n | Sig_modtype(id, decl, _) ->\n tree_of_modtype_declaration id decl\n | Sig_class(id, decl, rs, _) ->\n tree_of_class_declaration id decl rs\n | Sig_class_type(id, decl, rs, _) ->\n tree_of_cltype_declaration id decl rs\n\nand tree_of_modtype_declaration id decl =\n let mty =\n match decl.mtd_type with\n | None -> Omty_abstract\n | Some mty -> tree_of_modtype mty\n in\n Osig_modtype (Ident.name id, mty)\n\nand tree_of_module id ?ellipsis mty rs =\n Osig_module (Ident.name id, tree_of_modtype ?ellipsis mty, tree_of_rec rs)\n\nlet rec functor_parameters ~sep custom_printer = function\n | [] -> ignore\n | [id,param] ->\n Format.dprintf \"%t%t\"\n (custom_printer param)\n (functor_param ~sep ~custom_printer id [])\n | (id,param) :: q ->\n Format.dprintf \"%t%a%t\"\n (custom_printer param)\n sep ()\n (functor_param ~sep ~custom_printer id q)\nand functor_param ~sep ~custom_printer id q =\n match id with\n | None -> functor_parameters ~sep custom_printer q\n | Some id ->\n Naming_context.with_arg id\n (fun () -> functor_parameters ~sep custom_printer q)\n\n\n\nlet modtype ppf mty = !Oprint.out_module_type ppf (tree_of_modtype mty)\nlet modtype_declaration id ppf decl =\n !Oprint.out_sig_item ppf (tree_of_modtype_declaration id decl)\n\n(* For the toplevel: merge with tree_of_signature? *)\n\nlet print_items showval env x =\n Names.refresh_weak();\n reset_naming_context ();\n Conflicts.reset ();\n let extend_val env (sigitem,outcome) = outcome, showval env sigitem in\n let post_process (env,l) = List.map (extend_val env) l in\n List.concat_map post_process @@ tree_of_signature_rec env x\n\n(* Print a signature body (used by -i when compiling a .ml) *)\n\nlet print_signature ppf tree =\n fprintf ppf \"@[%a@]\" !Oprint.out_signature tree\n\nlet signature ppf sg =\n fprintf ppf \"%a\" print_signature (tree_of_signature sg)\n\n(* Print a signature body (used by -i when compiling a .ml) *)\nlet printed_signature sourcefile ppf sg =\n (* we are tracking any collision event for warning 63 *)\n Conflicts.reset ();\n reset_naming_context ();\n let t = tree_of_signature sg in\n if Warnings.(is_active @@ Erroneous_printed_signature \"\")\n && Conflicts.exists ()\n then begin\n let conflicts = Format.asprintf \"%t\" Conflicts.print_explanations in\n Location.prerr_warning (Location.in_file sourcefile)\n (Warnings.Erroneous_printed_signature conflicts);\n Warnings.check_fatal ()\n end;\n fprintf ppf \"%a\" print_signature t\n\n(* Trace-specific printing *)\n\n(* A configuration type that controls which trace we print. This could be\n exposed, but we instead expose three separate\n [report_{unification,equality,moregen}_error] functions. This also lets us\n give the unification case an extra optional argument without adding it to the\n equality and moregen cases. *)\ntype 'variety trace_format =\n | Unification : Errortrace.unification trace_format\n | Equality : Errortrace.comparison trace_format\n | Moregen : Errortrace.comparison trace_format\n\nlet incompatibility_phrase (type variety) : variety trace_format -> string =\n function\n | Unification -> \"is not compatible with type\"\n | Equality -> \"is not equal to type\"\n | Moregen -> \"is not compatible with type\"\n\n(* Print a unification error *)\n\nlet same_path t t' =\n eq_type t t' ||\n match get_desc t, get_desc t' with\n Tconstr(p,tl,_), Tconstr(p',tl',_) ->\n let (p1, s1) = best_type_path p and (p2, s2) = best_type_path p' in\n begin match s1, s2 with\n Nth n1, Nth n2 when n1 = n2 -> true\n | (Id | Map _), (Id | Map _) when Path.same p1 p2 ->\n let tl = apply_subst s1 tl and tl' = apply_subst s2 tl' in\n List.length tl = List.length tl' &&\n List.for_all2 eq_type tl tl'\n | _ -> false\n end\n | _ ->\n false\n\ntype 'a diff = Same of 'a | Diff of 'a * 'a\n\nlet trees_of_type_expansion mode Errortrace.{ty = t; expanded = t'} =\n reset_loop_marks ();\n mark_loops t;\n if same_path t t'\n then begin add_delayed (proxy t); Same (tree_of_typexp mode t) end\n else begin\n mark_loops t';\n let t' = if proxy t == proxy t' then unalias t' else t' in\n (* beware order matter due to side effect,\n e.g. when printing object types *)\n let first = tree_of_typexp mode t in\n let second = tree_of_typexp mode t' in\n if first = second then Same first\n else Diff(first,second)\n end\n\nlet type_expansion ppf = function\n | Same t -> !Oprint.out_type ppf t\n | Diff(t,t') ->\n fprintf ppf \"@[<2>%a@ =@ %a@]\" !Oprint.out_type t !Oprint.out_type t'\n\nlet trees_of_trace mode =\n List.map (Errortrace.map_diff (trees_of_type_expansion mode))\n\nlet trees_of_type_path_expansion (tp,tp') =\n if Path.same tp tp' then Same(tree_of_path Type tp) else\n Diff(tree_of_path Type tp, tree_of_path Type tp')\n\nlet type_path_expansion ppf = function\n | Same p -> !Oprint.out_ident ppf p\n | Diff(p,p') ->\n fprintf ppf \"@[<2>%a@ =@ %a@]\"\n !Oprint.out_ident p\n !Oprint.out_ident p'\n\nlet rec trace fst txt ppf = function\n | {Errortrace.got; expected} :: rem ->\n if not fst then fprintf ppf \"@,\";\n fprintf ppf \"@[Type@;<1 2>%a@ %s@;<1 2>%a@] %a\"\n type_expansion got txt type_expansion expected\n (trace false txt) rem\n | _ -> ()\n\ntype printing_status =\n | Discard\n | Keep\n | Optional_refinement\n (** An [Optional_refinement] printing status is attributed to trace\n elements that are focusing on a new subpart of a structural type.\n Since the whole type should have been printed earlier in the trace,\n we only print those elements if they are the last printed element\n of a trace, and there is no explicit explanation for the\n type error.\n *)\n\nlet diff_printing_status Errortrace.{ got = {ty = t1; expanded = t1'};\n expected = {ty = t2; expanded = t2'} } =\n if is_constr_row ~allow_ident:true t1'\n || is_constr_row ~allow_ident:true t2'\n then Discard\n else if same_path t1 t1' && same_path t2 t2' then Optional_refinement\n else Keep\n\nlet printing_status = function\n | Errortrace.Diff d -> diff_printing_status d\n | Errortrace.Escape {kind = Constraint} -> Keep\n | _ -> Keep\n\n(** Flatten the trace and remove elements that are always discarded\n during printing *)\n\n(* Takes [printing_status] to change behavior for [Subtype] *)\nlet prepare_any_trace printing_status tr =\n let clean_trace x l = match printing_status x with\n | Keep -> x :: l\n | Optional_refinement when l = [] -> [x]\n | Optional_refinement | Discard -> l\n in\n match tr with\n | [] -> []\n | elt :: rem -> elt :: List.fold_right clean_trace rem []\n\nlet prepare_trace f tr =\n prepare_any_trace printing_status (Errortrace.map f tr)\n\n(** Keep elements that are not [Diff _ ] and take the decision\n for the last element, require a prepared trace *)\nlet rec filter_trace\n (trace_format : 'variety trace_format)\n keep_last\n : ('a, 'variety) Errortrace.t -> _ = function\n | [] -> []\n | [Errortrace.Diff d as elt]\n when printing_status elt = Optional_refinement ->\n if keep_last then [d] else []\n | Errortrace.Diff d :: rem -> d :: filter_trace trace_format keep_last rem\n | _ :: rem -> filter_trace trace_format keep_last rem\n\nlet type_path_list =\n Format.pp_print_list ~pp_sep:(fun ppf () -> Format.pp_print_break ppf 2 0)\n type_path_expansion\n\n(* Hide variant name and var, to force printing the expanded type *)\nlet hide_variant_name t =\n match get_desc t with\n | Tvariant row ->\n let Row {fields; more; name; fixed; closed} = row_repr row in\n if name = None then t else\n newty2 ~level:(get_level t)\n (Tvariant\n (create_row ~fields ~fixed ~closed ~name:None\n ~more:(newvar2 (get_level more))))\n | _ -> t\n\nlet prepare_expansion Errortrace.{ty; expanded} =\n let expanded = hide_variant_name expanded in\n reserve_names ty;\n if not (same_path ty expanded) then reserve_names expanded;\n Errortrace.{ty; expanded}\n\nlet may_prepare_expansion compact (Errortrace.{ty; expanded} as ty_exp) =\n match get_desc expanded with\n Tvariant _ | Tobject _ when compact ->\n reserve_names ty; Errortrace.{ty; expanded = ty}\n | _ -> prepare_expansion ty_exp\n\nlet print_path p = Format.dprintf \"%a\" !Oprint.out_ident (tree_of_path Type p)\n\nlet print_tag ppf = fprintf ppf \"`%s\"\n\nlet print_tags =\n let comma ppf () = Format.fprintf ppf \",@ \" in\n Format.pp_print_list ~pp_sep:comma print_tag\n\nlet is_unit env ty =\n match get_desc (Ctype.expand_head env ty) with\n | Tconstr (p, _, _) -> Path.same p Predef.path_unit\n | _ -> false\n\nlet unifiable env ty1 ty2 =\n let snap = Btype.snapshot () in\n let res =\n try Ctype.unify env ty1 ty2; true\n with Unify _ -> false\n in\n Btype.backtrack snap;\n res\n\nlet explanation_diff env t3 t4 : (Format.formatter -> unit) option =\n match get_desc t3, get_desc t4 with\n | Tarrow (_, ty1, ty2, _), _\n when is_unit env ty1 && unifiable env ty2 t4 ->\n Some (fun ppf ->\n fprintf ppf\n \"@,@[Hint: Did you forget to provide `()' as argument?@]\")\n | _, Tarrow (_, ty1, ty2, _)\n when is_unit env ty1 && unifiable env t3 ty2 ->\n Some (fun ppf ->\n fprintf ppf\n \"@,@[Hint: Did you forget to wrap the expression using \\\n `fun () ->'?@]\")\n | _ ->\n None\n\nlet explain_fixed_row_case ppf = function\n | Errortrace.Cannot_be_closed ->\n fprintf ppf \"it cannot be closed\"\n | Errortrace.Cannot_add_tags tags ->\n fprintf ppf \"it may not allow the tag(s) %a\" print_tags tags\n\nlet explain_fixed_row pos expl = match expl with\n | Fixed_private ->\n dprintf \"The %a variant type is private\" Errortrace.print_pos pos\n | Univar x ->\n reserve_names x;\n dprintf \"The %a variant type is bound to the universal type variable %a\"\n Errortrace.print_pos pos type_expr_with_reserved_names x\n | Reified p ->\n dprintf \"The %a variant type is bound to %t\"\n Errortrace.print_pos pos (print_path p)\n | Rigid -> ignore\n\nlet explain_variant (type variety) : variety Errortrace.variant -> _ = function\n (* Common *)\n | Errortrace.Incompatible_types_for s ->\n Some(dprintf \"@,Types for tag `%s are incompatible\" s)\n (* Unification *)\n | Errortrace.No_intersection ->\n Some(dprintf \"@,These two variant types have no intersection\")\n | Errortrace.No_tags(pos,fields) -> Some(\n dprintf\n \"@,@[The %a variant type does not allow tag(s)@ @[%a@]@]\"\n Errortrace.print_pos pos\n print_tags (List.map fst fields)\n )\n | Errortrace.Fixed_row (pos,\n k,\n (Univar _ | Reified _ | Fixed_private as e)) ->\n Some (\n dprintf \"@,@[%t,@ %a@]\" (explain_fixed_row pos e)\n explain_fixed_row_case k\n )\n | Errortrace.Fixed_row (_,_, Rigid) ->\n (* this case never happens *)\n None\n (* Equality & Moregen *)\n | Errortrace.Presence_not_guaranteed_for (pos, s) -> Some(\n dprintf\n \"@,@[The tag `%s is guaranteed to be present in the %a variant type,\\\n @ but not in the %a@]\"\n s\n Errortrace.print_pos (Errortrace.swap_position pos)\n Errortrace.print_pos pos\n )\n | Errortrace.Openness pos ->\n Some(dprintf \"@,The %a variant type is open and the %a is not\"\n Errortrace.print_pos pos\n Errortrace.print_pos (Errortrace.swap_position pos))\n\nlet explain_escape pre = function\n | Errortrace.Univ u ->\n reserve_names u;\n Some(\n dprintf \"%t@,The universal variable %a would escape its scope\"\n pre type_expr_with_reserved_names u)\n | Errortrace.Constructor p -> Some(\n dprintf\n \"%t@,@[The type constructor@;<1 2>%a@ would escape its scope@]\"\n pre path p\n )\n | Errortrace.Module_type p -> Some(\n dprintf\n \"%t@,@[The module type@;<1 2>%a@ would escape its scope@]\"\n pre path p\n )\n | Errortrace.Equation Errortrace.{ty = _; expanded = t} ->\n reserve_names t;\n Some(\n dprintf \"%t @,@[This instance of %a is ambiguous:@ %s@]\"\n pre type_expr_with_reserved_names t\n \"it would escape the scope of its equation\"\n )\n | Errortrace.Self ->\n Some (dprintf \"%t@,Self type cannot escape its class\" pre)\n | Errortrace.Constraint ->\n None\n\nlet explain_object (type variety) : variety Errortrace.obj -> _ = function\n | Errortrace.Missing_field (pos,f) -> Some(\n dprintf \"@,@[The %a object type has no method %s@]\"\n Errortrace.print_pos pos f\n )\n | Errortrace.Abstract_row pos -> Some(\n dprintf\n \"@,@[The %a object type has an abstract row, it cannot be closed@]\"\n Errortrace.print_pos pos\n )\n | Errortrace.Self_cannot_be_closed ->\n Some (dprintf \"@,Self type cannot be unified with a closed object type\")\n\nlet explanation (type variety) intro prev env\n : (Errortrace.expanded_type, variety) Errortrace.elt -> _ = function\n | Errortrace.Diff {got; expected} ->\n explanation_diff env got.expanded expected.expanded\n | Errortrace.Escape {kind; context} ->\n let pre =\n match context, kind, prev with\n | Some ctx, _, _ ->\n reserve_names ctx;\n dprintf \"@[%t@;<1 2>%a@]\" intro type_expr_with_reserved_names ctx\n | None, Univ _, Some(Errortrace.Incompatible_fields {name; diff}) ->\n reserve_names diff.got;\n reserve_names diff.expected;\n dprintf \"@,@[The method %s has type@ %a,@ \\\n but the expected method type was@ %a@]\"\n name\n type_expr_with_reserved_names diff.got\n type_expr_with_reserved_names diff.expected\n | _ -> ignore\n in\n explain_escape pre kind\n | Errortrace.Incompatible_fields { name; _ } ->\n Some(dprintf \"@,Types for method %s are incompatible\" name)\n | Errortrace.Variant v ->\n explain_variant v\n | Errortrace.Obj o ->\n explain_object o\n | Errortrace.Rec_occur(x,y) ->\n reserve_names x;\n reserve_names y;\n begin match get_desc x with\n | Tvar _ | Tunivar _ ->\n Some(fun ppf ->\n reset_loop_marks ();\n mark_loops x;\n mark_loops y;\n dprintf \"@,@[The type variable %a occurs inside@ %a@]\"\n prepared_type_expr x prepared_type_expr y\n ppf)\n | _ ->\n (* We had a delayed unification of the type variable with\n a non-variable after the occur check. *)\n Some ignore\n (* There is no need to search further for an explanation, but\n we don't want to print a message of the form:\n {[ The type int occurs inside int list -> 'a |}\n *)\n end\n\nlet mismatch intro env trace =\n Errortrace.explain trace (fun ~prev h -> explanation intro prev env h)\n\nlet explain mis ppf =\n match mis with\n | None -> ()\n | Some explain -> explain ppf\n\nlet warn_on_missing_def env ppf t =\n match get_desc t with\n | Tconstr (p,_,_) ->\n begin\n try\n ignore(Env.find_type p env : Types.type_declaration)\n with Not_found ->\n fprintf ppf\n \"@,@[%a is abstract because no corresponding cmi file was found \\\n in path.@]\" path p\n end\n | _ -> ()\n\nlet prepare_expansion_head empty_tr = function\n | Errortrace.Diff d ->\n Some (Errortrace.map_diff (may_prepare_expansion empty_tr) d)\n | _ -> None\n\nlet head_error_printer mode txt_got txt_but = function\n | None -> ignore\n | Some d ->\n let d = Errortrace.map_diff (trees_of_type_expansion mode) d in\n dprintf \"%t@;<1 2>%a@ %t@;<1 2>%a\"\n txt_got type_expansion d.Errortrace.got\n txt_but type_expansion d.Errortrace.expected\n\nlet warn_on_missing_defs env ppf = function\n | None -> ()\n | Some Errortrace.{got = {ty=te1; expanded=_};\n expected = {ty=te2; expanded=_} } ->\n warn_on_missing_def env ppf te1;\n warn_on_missing_def env ppf te2\n\n(* [subst] comes out of equality, and is [[]] otherwise *)\nlet error trace_format mode subst env tr txt1 ppf txt2 ty_expect_explanation =\n reset ();\n (* We want to substitute in the opposite order from [Eqtype] *)\n Names.add_subst (List.map (fun (ty1,ty2) -> ty2,ty1) subst);\n let tr =\n prepare_trace\n (fun ty_exp ->\n Errortrace.{ty_exp with expanded = hide_variant_name ty_exp.expanded})\n tr\n in\n let mis = mismatch txt1 env tr in\n match tr with\n | [] -> assert false\n | elt :: tr ->\n try\n print_labels := not !Clflags.classic;\n let tr = filter_trace trace_format (mis = None) tr in\n let head = prepare_expansion_head (tr=[]) elt in\n let tr = List.map (Errortrace.map_diff prepare_expansion) tr in\n let head_error = head_error_printer mode txt1 txt2 head in\n let tr = trees_of_trace mode tr in\n fprintf ppf\n \"@[\\\n @[%t%t@]%a%t\\\n @]\"\n head_error\n ty_expect_explanation\n (trace false (incompatibility_phrase trace_format)) tr\n (explain mis);\n if env <> Env.empty\n then warn_on_missing_defs env ppf head;\n Conflicts.print_explanations ppf;\n print_labels := true\n with exn ->\n print_labels := true;\n raise exn\n\nlet report_error trace_format ppf mode env tr\n ?(subst = [])\n ?(type_expected_explanation = fun _ -> ())\n txt1 txt2 =\n wrap_printing_env ~error:true env (fun () ->\n error trace_format mode subst env tr txt1 ppf txt2\n type_expected_explanation)\n\nlet report_unification_error\n ppf env ({trace} : Errortrace.unification_error) =\n report_error Unification ppf Type env\n ?subst:None trace\n\nlet report_equality_error\n ppf mode env ({subst; trace} : Errortrace.equality_error) =\n report_error Equality ppf mode env\n ~subst ?type_expected_explanation:None trace\n\nlet report_moregen_error\n ppf mode env ({trace} : Errortrace.moregen_error) =\n report_error Moregen ppf mode env\n ?subst:None ?type_expected_explanation:None trace\n\nlet report_comparison_error ppf mode env = function\n | Errortrace.Equality_error error -> report_equality_error ppf mode env error\n | Errortrace.Moregen_error error -> report_moregen_error ppf mode env error\n\nmodule Subtype = struct\n (* There's a frustrating amount of code duplication between this module and\n the outside code, particularly in [prepare_trace] and [filter_trace].\n Unfortunately, [Subtype] is *just* similar enough to have code duplication,\n while being *just* different enough (it's only [Diff]) for the abstraction\n to be nonobvious. Someday, perhaps... *)\n\n let printing_status = function\n | Errortrace.Subtype.Diff d -> diff_printing_status d\n\n let prepare_unification_trace = prepare_trace\n\n let prepare_trace f tr =\n prepare_any_trace printing_status (Errortrace.Subtype.map f tr)\n\n let trace filter_trace get_diff fst keep_last txt ppf tr =\n print_labels := not !Clflags.classic;\n try match tr with\n | elt :: tr' ->\n let diffed_elt = get_diff elt in\n let tr =\n trees_of_trace Type\n @@ List.map (Errortrace.map_diff prepare_expansion)\n @@ filter_trace keep_last tr' in\n let tr =\n match fst, diffed_elt with\n | true, Some elt -> elt :: tr\n | _, _ -> tr\n in\n trace fst txt ppf tr;\n print_labels := true\n | _ -> ()\n with exn ->\n print_labels := true;\n raise exn\n\n let filter_unification_trace = filter_trace Unification\n\n let rec filter_subtype_trace keep_last = function\n | [] -> []\n | [Errortrace.Subtype.Diff d as elt]\n when printing_status elt = Optional_refinement ->\n if keep_last then [d] else []\n | Errortrace.Subtype.Diff d :: rem ->\n d :: filter_subtype_trace keep_last rem\n\n let unification_get_diff = function\n | Errortrace.Diff diff ->\n Some (Errortrace.map_diff (trees_of_type_expansion Type) diff)\n | _ -> None\n\n let subtype_get_diff = function\n | Errortrace.Subtype.Diff diff ->\n Some (Errortrace.map_diff (trees_of_type_expansion Type) diff)\n\n let report_error\n ppf\n env\n (Errortrace.Subtype.{trace = tr_sub; unification_trace = tr_unif})\n txt1 =\n wrap_printing_env ~error:true env (fun () ->\n reset ();\n let tr_sub = prepare_trace prepare_expansion tr_sub in\n let tr_unif = prepare_unification_trace prepare_expansion tr_unif in\n let keep_first = match tr_unif with\n | [Obj _ | Variant _ | Escape _ ] | [] -> true\n | _ -> false in\n fprintf ppf \"@[%a\"\n (trace filter_subtype_trace subtype_get_diff true keep_first txt1)\n tr_sub;\n if tr_unif = [] then fprintf ppf \"@]\" else\n let mis = mismatch (dprintf \"Within this type\") env tr_unif in\n fprintf ppf \"%a%t%t@]\"\n (trace filter_unification_trace unification_get_diff false\n (mis = None) \"is not compatible with type\") tr_unif\n (explain mis)\n Conflicts.print_explanations\n )\nend\n\nlet report_ambiguous_type_error ppf env tp0 tpl txt1 txt2 txt3 =\n wrap_printing_env ~error:true env (fun () ->\n reset ();\n let tp0 = trees_of_type_path_expansion tp0 in\n match tpl with\n [] -> assert false\n | [tp] ->\n fprintf ppf\n \"@[%t@;<1 2>%a@ \\\n %t@;<1 2>%a\\\n @]\"\n txt1 type_path_expansion (trees_of_type_path_expansion tp)\n txt3 type_path_expansion tp0\n | _ ->\n fprintf ppf\n \"@[%t@;<1 2>@[%a@]\\\n @ %t@;<1 2>%a\\\n @]\"\n txt2 type_path_list (List.map trees_of_type_path_expansion tpl)\n txt3 type_path_expansion tp0)\n\n(* Adapt functions to exposed interface *)\nlet tree_of_path = tree_of_path Other\nlet tree_of_modtype = tree_of_modtype ~ellipsis:false\nlet type_expansion mode ppf ty_exp =\n type_expansion ppf (trees_of_type_expansion mode ty_exp)\nlet tree_of_type_declaration ident td rs =\n with_hidden_items [{hide=true; ident}]\n (fun () -> tree_of_type_declaration ident td rs)\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(* Typechecking for the core language *)\n\nopen Misc\nopen Asttypes\nopen Parsetree\nopen Types\nopen Typedtree\nopen Btype\nopen Ctype\n\ntype type_forcing_context =\n | If_conditional\n | If_no_else_branch\n | While_loop_conditional\n | While_loop_body\n | For_loop_start_index\n | For_loop_stop_index\n | For_loop_body\n | Assert_condition\n | Sequence_left_hand_side\n | When_guard\n\ntype type_expected = {\n ty: type_expr;\n explanation: type_forcing_context option;\n}\n\ntype to_unpack = {\n tu_name: string Location.loc;\n tu_loc: Location.t;\n tu_uid: Uid.t\n}\n\nmodule Datatype_kind = struct\n type t = Record | Variant\n\n let type_name = function\n | Record -> \"record\"\n | Variant -> \"variant\"\n\n let label_name = function\n | Record -> \"field\"\n | Variant -> \"constructor\"\nend\n\ntype wrong_name = {\n type_path: Path.t;\n kind: Datatype_kind.t;\n name: string loc;\n valid_names: string list;\n}\n\ntype wrong_kind_context =\n | Pattern\n | Expression of type_forcing_context option\n\ntype wrong_kind_sort =\n | Constructor\n | Record\n | Boolean\n | List\n | Unit\n\nlet wrong_kind_sort_of_constructor (lid : Longident.t) =\n match lid with\n | Lident \"true\" | Lident \"false\" | Ldot(_, \"true\") | Ldot(_, \"false\") ->\n Boolean\n | Lident \"[]\" | Lident \"::\" | Ldot(_, \"[]\") | Ldot(_, \"::\") -> List\n | Lident \"()\" | Ldot(_, \"()\") -> Unit\n | _ -> Constructor\n\ntype existential_restriction =\n | At_toplevel (** no existential types at the toplevel *)\n | In_group (** nor with let ... and ... *)\n | In_rec (** or recursive definition *)\n | With_attributes (** or let[@any_attribute] = ... *)\n | In_class_args (** or in class arguments *)\n | In_class_def (** or in [class c = let ... in ...] *)\n | In_self_pattern (** or in self pattern *)\n\ntype error =\n | Constructor_arity_mismatch of Longident.t * int * int\n | Label_mismatch of Longident.t * Errortrace.unification_error\n | Pattern_type_clash :\n Errortrace.unification_error * _ pattern_desc option -> error\n | Or_pattern_type_clash of Ident.t * Errortrace.unification_error\n | Multiply_bound_variable of string\n | Orpat_vars of Ident.t * Ident.t list\n | Expr_type_clash of\n Errortrace.unification_error * type_forcing_context option\n * expression_desc option\n | Apply_non_function of type_expr\n | Apply_wrong_label of arg_label * type_expr * bool\n | Label_multiply_defined of string\n | Label_missing of Ident.t list\n | Label_not_mutable of Longident.t\n | Wrong_name of string * type_expected * wrong_name\n | Name_type_mismatch of\n Datatype_kind.t * Longident.t * (Path.t * Path.t) * (Path.t * Path.t) list\n | Invalid_format of string\n | Not_an_object of type_expr * type_forcing_context option\n | Undefined_method of type_expr * string * string list option\n | Undefined_self_method of string * string list\n | Virtual_class of Longident.t\n | Private_type of type_expr\n | Private_label of Longident.t * type_expr\n | Private_constructor of constructor_description * type_expr\n | Unbound_instance_variable of string * string list\n | Instance_variable_not_mutable of string\n | Not_subtype of Errortrace.Subtype.error\n | Outside_class\n | Value_multiply_overridden of string\n | Coercion_failure of\n Errortrace.expanded_type * Errortrace.unification_error * bool\n | Not_a_function of type_expr * type_forcing_context option\n | Too_many_arguments of type_expr * type_forcing_context option\n | Abstract_wrong_label of\n { got : arg_label\n ; expected : arg_label\n ; expected_type : type_expr\n ; explanation : type_forcing_context option\n }\n | Scoping_let_module of string * type_expr\n | Not_a_polymorphic_variant_type of Longident.t\n | Incoherent_label_order\n | Less_general of string * Errortrace.unification_error\n | Modules_not_allowed\n | Cannot_infer_signature\n | Not_a_packed_module of type_expr\n | Unexpected_existential of existential_restriction * string * string list\n | Invalid_interval\n | Invalid_for_loop_index\n | No_value_clauses\n | Exception_pattern_disallowed\n | Mixed_value_and_exception_patterns_under_guard\n | Inlined_record_escape\n | Inlined_record_expected\n | Unrefuted_pattern of pattern\n | Invalid_extension_constructor_payload\n | Not_an_extension_constructor\n | Literal_overflow of string\n | Unknown_literal of string * char\n | Illegal_letrec_pat\n | Illegal_letrec_expr\n | Illegal_class_expr\n | Letop_type_clash of string * Errortrace.unification_error\n | Andop_type_clash of string * Errortrace.unification_error\n | Bindings_type_clash of Errortrace.unification_error\n | Unbound_existential of Ident.t list * type_expr\n | Missing_type_constraint\n | Wrong_expected_kind of wrong_kind_sort * wrong_kind_context * type_expr\n | Expr_not_a_record_type of type_expr\n\nexception Error of Location.t * Env.t * error\nexception Error_forward of Location.error\n\n(* Forward declaration, to be filled in by Typemod.type_module *)\n\nlet type_module =\n ref ((fun _env _md -> assert false) :\n Env.t -> Parsetree.module_expr -> Typedtree.module_expr * Shape.t)\n\n(* Forward declaration, to be filled in by Typemod.type_open *)\n\nlet type_open :\n (?used_slot:bool ref -> override_flag -> Env.t -> Location.t ->\n Longident.t loc -> Path.t * Env.t)\n ref =\n ref (fun ?used_slot:_ _ -> assert false)\n\nlet type_open_decl :\n (?used_slot:bool ref -> Env.t -> Parsetree.open_declaration\n -> open_declaration * Types.signature * Env.t)\n ref =\n ref (fun ?used_slot:_ _ -> assert false)\n\n(* Forward declaration, to be filled in by Typemod.type_package *)\n\nlet type_package =\n ref (fun _ -> assert false)\n\n(* Forward declaration, to be filled in by Typeclass.class_structure *)\nlet type_object =\n ref (fun _env _s -> assert false :\n Env.t -> Location.t -> Parsetree.class_structure ->\n Typedtree.class_structure * string list)\n\n(*\n Saving and outputting type information.\n We keep these function names short, because they have to be\n called each time we create a record of type [Typedtree.expression]\n or [Typedtree.pattern] that will end up in the typed AST.\n*)\nlet re node =\n Cmt_format.add_saved_type (Cmt_format.Partial_expression node);\n node\n;;\nlet rp node =\n Cmt_format.add_saved_type (Cmt_format.Partial_pattern (Value, node));\n node\n;;\nlet rcp node =\n Cmt_format.add_saved_type (Cmt_format.Partial_pattern (Computation, node));\n node\n;;\n\n\n(* Context for inline record arguments; see [type_ident] *)\n\ntype recarg =\n | Allowed\n | Required\n | Rejected\n\n\nlet mk_expected ?explanation ty = { ty; explanation; }\n\nlet case lhs rhs =\n {c_lhs = lhs; c_guard = None; c_rhs = rhs}\n\n(* Typing of constants *)\n\nlet type_constant = function\n Const_int _ -> instance Predef.type_int\n | Const_char _ -> instance Predef.type_char\n | Const_string _ -> instance Predef.type_string\n | Const_float _ -> instance Predef.type_float\n | Const_int32 _ -> instance Predef.type_int32\n | Const_int64 _ -> instance Predef.type_int64\n | Const_nativeint _ -> instance Predef.type_nativeint\n\nlet constant : Parsetree.constant -> (Asttypes.constant, error) result =\n function\n | Pconst_integer (i,None) ->\n begin\n try Ok (Const_int (Misc.Int_literal_converter.int i))\n with Failure _ -> Error (Literal_overflow \"int\")\n end\n | Pconst_integer (i,Some 'l') ->\n begin\n try Ok (Const_int32 (Misc.Int_literal_converter.int32 i))\n with Failure _ -> Error (Literal_overflow \"int32\")\n end\n | Pconst_integer (i,Some 'L') ->\n begin\n try Ok (Const_int64 (Misc.Int_literal_converter.int64 i))\n with Failure _ -> Error (Literal_overflow \"int64\")\n end\n | Pconst_integer (i,Some 'n') ->\n begin\n try Ok (Const_nativeint (Misc.Int_literal_converter.nativeint i))\n with Failure _ -> Error (Literal_overflow \"nativeint\")\n end\n | Pconst_integer (i,Some c) -> Error (Unknown_literal (i, c))\n | Pconst_char c -> Ok (Const_char c)\n | Pconst_string (s,loc,d) -> Ok (Const_string (s,loc,d))\n | Pconst_float (f,None)-> Ok (Const_float f)\n | Pconst_float (f,Some c) -> Error (Unknown_literal (f, c))\n\nlet constant_or_raise env loc cst =\n match constant cst with\n | Ok c -> c\n | Error err -> raise (Error (loc, env, err))\n\n(* Specific version of type_option, using newty rather than newgenty *)\n\nlet type_option ty =\n newty (Tconstr(Predef.path_option,[ty], ref Mnil))\n\nlet mkexp exp_desc exp_type exp_loc exp_env =\n { exp_desc; exp_type; exp_loc; exp_env; exp_extra = []; exp_attributes = [] }\n\nlet option_none env ty loc =\n let lid = Longident.Lident \"None\" in\n let cnone = Env.find_ident_constructor Predef.ident_none env in\n mkexp (Texp_construct(mknoloc lid, cnone, [])) ty loc env\n\nlet option_some env texp =\n let lid = Longident.Lident \"Some\" in\n let csome = Env.find_ident_constructor Predef.ident_some env in\n mkexp ( Texp_construct(mknoloc lid , csome, [texp]) )\n (type_option texp.exp_type) texp.exp_loc texp.exp_env\n\nlet extract_option_type env ty =\n match get_desc (expand_head env ty) with\n Tconstr(path, [ty], _) when Path.same path Predef.path_option -> ty\n | _ -> assert false\n\ntype record_extraction_result =\n | Record_type of Path.t * Path.t * Types.label_declaration list\n | Not_a_record_type\n | Maybe_a_record_type\n\nlet extract_concrete_record env ty =\n match extract_concrete_typedecl env ty with\n | Typedecl(p0, p, {type_kind=Type_record (fields, _)}) ->\n Record_type (p0, p, fields)\n | Has_no_typedecl | Typedecl(_, _, _) -> Not_a_record_type\n | May_have_typedecl -> Maybe_a_record_type\n\ntype variant_extraction_result =\n | Variant_type of Path.t * Path.t * Types.constructor_declaration list\n | Not_a_variant_type\n | Maybe_a_variant_type\n\nlet extract_concrete_variant env ty =\n match extract_concrete_typedecl env ty with\n | Typedecl(p0, p, {type_kind=Type_variant (cstrs, _)}) ->\n Variant_type (p0, p, cstrs)\n | Typedecl(p0, p, {type_kind=Type_open}) ->\n Variant_type (p0, p, [])\n | Has_no_typedecl | Typedecl(_, _, _) -> Not_a_variant_type\n | May_have_typedecl -> Maybe_a_variant_type\n\nlet extract_label_names env ty =\n match extract_concrete_record env ty with\n | Record_type (_, _,fields) -> List.map (fun l -> l.Types.ld_id) fields\n | Not_a_record_type | Maybe_a_record_type -> assert false\n\nlet is_principal ty =\n not !Clflags.principal || get_level ty = generic_level\n\n(* Typing of patterns *)\n\n(* unification inside type_exp and type_expect *)\nlet unify_exp_types loc env ty expected_ty =\n (* Format.eprintf \"@[%a@ %a@]@.\" Printtyp.raw_type_expr exp.exp_type\n Printtyp.raw_type_expr expected_ty; *)\n try\n unify env ty expected_ty\n with\n Unify err ->\n raise(Error(loc, env, Expr_type_clash(err, None, None)))\n | Tags(l1,l2) ->\n raise(Typetexp.Error(loc, env, Typetexp.Variant_tags (l1, l2)))\n\n(* level at which to create the local type declarations *)\nlet gadt_equations_level = ref None\nlet get_gadt_equations_level () =\n match !gadt_equations_level with\n Some y -> y\n | None -> assert false\n\nlet nothing_equated = TypePairs.create 0\n\n(* unification inside type_pat*)\nlet unify_pat_types_return_equated_pairs ?(refine = None) loc env ty ty' =\n try\n match refine with\n | Some allow_recursive ->\n unify_gadt ~equations_level:(get_gadt_equations_level ())\n ~allow_recursive env ty ty'\n | None ->\n unify !env ty ty';\n nothing_equated\n with\n | Unify err ->\n raise(Error(loc, !env, Pattern_type_clash(err, None)))\n | Tags(l1,l2) ->\n raise(Typetexp.Error(loc, !env, Typetexp.Variant_tags (l1, l2)))\n\nlet unify_pat_types ?refine loc env ty ty' =\n ignore (unify_pat_types_return_equated_pairs ?refine loc env ty ty')\n\nlet unify_pat ?refine env pat expected_ty =\n try unify_pat_types ?refine pat.pat_loc env pat.pat_type expected_ty\n with Error (loc, env, Pattern_type_clash(err, None)) ->\n raise(Error(loc, env, Pattern_type_clash(err, Some pat.pat_desc)))\n\n(* unification of a type with a Tconstr with freshly created arguments *)\nlet unify_head_only ~refine loc env ty constr =\n let path = cstr_type_path constr in\n let decl = Env.find_type path !env in\n let ty' = Ctype.newconstr path (Ctype.instance_list decl.type_params) in\n unify_pat_types ~refine loc env ty' ty\n\n(* Creating new conjunctive types is not allowed when typing patterns *)\n(* make all Reither present in open variants *)\nlet finalize_variant pat tag opat r =\n let row =\n match get_desc (expand_head pat.pat_env pat.pat_type) with\n Tvariant row -> r := row; row\n | _ -> assert false\n in\n let f = get_row_field tag row in\n begin match row_field_repr f with\n | Rabsent -> () (* assert false *)\n | Reither (true, [], _) when not (row_closed row) ->\n link_row_field_ext ~inside:f (rf_present None)\n | Reither (false, ty::tl, _) when not (row_closed row) ->\n link_row_field_ext ~inside:f (rf_present (Some ty));\n begin match opat with None -> assert false\n | Some pat ->\n let env = ref pat.pat_env in List.iter (unify_pat env pat) (ty::tl)\n end\n | Reither (c, _l, true) when not (has_fixed_explanation row) ->\n link_row_field_ext ~inside:f (rf_either [] ~no_arg:c ~matched:false)\n | _ -> ()\n end\n (* Force check of well-formedness WHY? *)\n (* unify_pat pat.pat_env pat\n (newty(Tvariant{row_fields=[]; row_more=newvar(); row_closed=false;\n row_bound=(); row_fixed=false; row_name=None})); *)\n\nlet has_variants p =\n exists_general_pattern\n { f = fun (type k) (p : k general_pattern) -> match p.pat_desc with\n | (Tpat_variant _) -> true\n | _ -> false } p\n\nlet finalize_variants p =\n iter_general_pattern\n { f = fun (type k) (p : k general_pattern) -> match p.pat_desc with\n | Tpat_variant(tag, opat, r) ->\n finalize_variant p tag opat r\n | _ -> () } p\n\n(* pattern environment *)\ntype pattern_variable =\n {\n pv_id: Ident.t;\n pv_type: type_expr;\n pv_loc: Location.t;\n pv_as_var: bool;\n pv_attributes: attributes;\n }\n\ntype module_variable =\n string loc * Location.t\n\nlet pattern_variables = ref ([] : pattern_variable list)\nlet pattern_force = ref ([] : (unit -> unit) list)\nlet allow_modules = ref false\nlet module_variables = ref ([] : module_variable list)\nlet reset_pattern allow =\n pattern_variables := [];\n pattern_force := [];\n allow_modules := allow;\n module_variables := [];\n;;\n\nlet maybe_add_pattern_variables_ghost loc_let env pv =\n List.fold_right\n (fun {pv_id; _} env ->\n let name = Ident.name pv_id in\n if Env.bound_value name env then env\n else begin\n Env.enter_unbound_value name\n (Val_unbound_ghost_recursive loc_let) env\n end\n ) pv env\n\nlet enter_variable ?(is_module=false) ?(is_as_variable=false) loc name ty\n attrs =\n if List.exists (fun {pv_id; _} -> Ident.name pv_id = name.txt)\n !pattern_variables\n then raise(Error(loc, Env.empty, Multiply_bound_variable name.txt));\n let id = Ident.create_local name.txt in\n pattern_variables :=\n {pv_id = id;\n pv_type = ty;\n pv_loc = loc;\n pv_as_var = is_as_variable;\n pv_attributes = attrs} :: !pattern_variables;\n if is_module then begin\n (* Note: unpack patterns enter a variable of the same name *)\n if not !allow_modules then\n raise (Error (loc, Env.empty, Modules_not_allowed));\n module_variables := (name, loc) :: !module_variables\n end;\n id\n\nlet sort_pattern_variables vs =\n List.sort\n (fun {pv_id = x; _} {pv_id = y; _} ->\n Stdlib.compare (Ident.name x) (Ident.name y))\n vs\n\nlet enter_orpat_variables loc env p1_vs p2_vs =\n (* unify_vars operate on sorted lists *)\n\n let p1_vs = sort_pattern_variables p1_vs\n and p2_vs = sort_pattern_variables p2_vs in\n\n let rec unify_vars p1_vs p2_vs =\n let vars vs = List.map (fun {pv_id; _} -> pv_id) vs in\n match p1_vs, p2_vs with\n | {pv_id = x1; pv_type = t1; _}::rem1, {pv_id = x2; pv_type = t2; _}::rem2\n when Ident.equal x1 x2 ->\n if x1==x2 then\n unify_vars rem1 rem2\n else begin\n begin try\n unify_var env (newvar ()) t1;\n unify env t1 t2\n with\n | Unify err ->\n raise(Error(loc, env, Or_pattern_type_clash(x1, err)))\n end;\n (x2,x1)::unify_vars rem1 rem2\n end\n | [],[] -> []\n | {pv_id; _}::_, [] | [],{pv_id; _}::_ ->\n raise (Error (loc, env, Orpat_vars (pv_id, [])))\n | {pv_id = x; _}::_, {pv_id = y; _}::_ ->\n let err =\n if Ident.name x < Ident.name y\n then Orpat_vars (x, vars p2_vs)\n else Orpat_vars (y, vars p1_vs) in\n raise (Error (loc, env, err)) in\n unify_vars p1_vs p2_vs\n\nlet rec build_as_type ~refine (env : Env.t ref) p =\n let as_ty = build_as_type_aux ~refine env p in\n (* Cf. #1655 *)\n List.fold_left (fun as_ty (extra, _loc, _attrs) ->\n match extra with\n | Tpat_type _ | Tpat_open _ | Tpat_unpack -> as_ty\n | Tpat_constraint cty ->\n (* [generic_instance] can only be used if the variables of the original\n type ([cty.ctyp_type] here) are not at [generic_level], which they are\n here.\n If we used [generic_instance] we would lose the sharing between\n [instance ty] and [ty]. *)\n begin_def ();\n let ty = instance cty.ctyp_type in\n end_def ();\n generalize_structure ty;\n (* This call to unify can't fail since the pattern is well typed. *)\n unify_pat_types ~refine p.pat_loc env (instance as_ty) (instance ty);\n ty\n ) as_ty p.pat_extra\n\nand build_as_type_aux ~refine (env : Env.t ref) p =\n let build_as_type = build_as_type ~refine in\n match p.pat_desc with\n Tpat_alias(p1,_, _) -> build_as_type env p1\n | Tpat_tuple pl ->\n let tyl = List.map (build_as_type env) pl in\n newty (Ttuple tyl)\n | Tpat_construct(_, cstr, pl, vto) ->\n let keep =\n cstr.cstr_private = Private || cstr.cstr_existentials <> [] ||\n vto <> None (* be lazy and keep the type for node constraints *) in\n if keep then p.pat_type else\n let tyl = List.map (build_as_type env) pl in\n let ty_args, ty_res, _ = instance_constructor cstr in\n List.iter2 (fun (p,ty) -> unify_pat ~refine env {p with pat_type = ty})\n (List.combine pl tyl) ty_args;\n ty_res\n | Tpat_variant(l, p', _) ->\n let ty = Option.map (build_as_type env) p' in\n let fields = [l, rf_present ty] in\n newty (Tvariant (create_row ~fields ~more:(newvar())\n ~name:None ~fixed:None ~closed:false))\n | Tpat_record (lpl,_) ->\n let lbl = snd3 (List.hd lpl) in\n if lbl.lbl_private = Private then p.pat_type else\n let ty = newvar () in\n let ppl = List.map (fun (_, l, p) -> l.lbl_pos, p) lpl in\n let do_label lbl =\n let _, ty_arg, ty_res = instance_label false lbl in\n unify_pat ~refine env {p with pat_type = ty} ty_res;\n let refinable =\n lbl.lbl_mut = Immutable && List.mem_assoc lbl.lbl_pos ppl &&\n match get_desc lbl.lbl_arg with Tpoly _ -> false | _ -> true in\n if refinable then begin\n let arg = List.assoc lbl.lbl_pos ppl in\n unify_pat ~refine env\n {arg with pat_type = build_as_type env arg} ty_arg\n end else begin\n let _, ty_arg', ty_res' = instance_label false lbl in\n unify_pat_types ~refine p.pat_loc env ty_arg ty_arg';\n unify_pat ~refine env p ty_res'\n end in\n Array.iter do_label lbl.lbl_all;\n ty\n | Tpat_or(p1, p2, row) ->\n begin match row with\n None ->\n let ty1 = build_as_type env p1 and ty2 = build_as_type env p2 in\n unify_pat ~refine env {p2 with pat_type = ty2} ty1;\n ty1\n | Some row ->\n let Row {fields; fixed; name} = row_repr row in\n newty (Tvariant (create_row ~fields ~fixed ~name\n ~closed:false ~more:(newvar())))\n end\n | Tpat_any | Tpat_var _ | Tpat_constant _\n | Tpat_array _ | Tpat_lazy _ -> p.pat_type\n\n(* Constraint solving during typing of patterns *)\n\nlet solve_Ppat_poly_constraint ~refine env loc sty expected_ty =\n let cty, ty, force = Typetexp.transl_simple_type_delayed !env sty in\n unify_pat_types ~refine loc env ty (instance expected_ty);\n pattern_force := force :: !pattern_force;\n match get_desc ty with\n | Tpoly (body, tyl) ->\n begin_def ();\n init_def generic_level;\n let _, ty' = instance_poly ~keep_names:true false tyl body in\n end_def ();\n (cty, ty, ty')\n | _ -> assert false\n\nlet solve_Ppat_alias ~refine env pat =\n begin_def ();\n let ty_var = build_as_type ~refine env pat in\n end_def ();\n generalize ty_var;\n ty_var\n\nlet solve_Ppat_tuple (type a) ~refine loc env (args : a list) expected_ty =\n let vars = List.map (fun _ -> newgenvar ()) args in\n let ty = newgenty (Ttuple vars) in\n let expected_ty = generic_instance expected_ty in\n unify_pat_types ~refine loc env ty expected_ty;\n vars\n\nlet solve_constructor_annotation env name_list sty ty_args ty_ex =\n let expansion_scope = get_gadt_equations_level () in\n let ids =\n List.map\n (fun name ->\n let decl = new_local_type ~loc:name.loc () in\n let (id, new_env) =\n Env.enter_type ~scope:expansion_scope name.txt decl !env in\n env := new_env;\n {name with txt = id})\n name_list\n in\n begin_def ();\n let cty, ty, force = Typetexp.transl_simple_type_delayed !env sty in\n end_def ();\n generalize_structure ty;\n pattern_force := force :: !pattern_force;\n let ty_args =\n let ty1 = instance ty and ty2 = instance ty in\n match ty_args with\n [] -> assert false\n | [ty_arg] ->\n unify_pat_types cty.ctyp_loc env ty1 ty_arg;\n [ty2]\n | _ ->\n unify_pat_types cty.ctyp_loc env ty1 (newty (Ttuple ty_args));\n match get_desc (expand_head !env ty2) with\n Ttuple tyl -> tyl\n | _ -> assert false\n in\n if ids <> [] then ignore begin\n let ids = List.map (fun x -> x.txt) ids in\n let rem =\n List.fold_left\n (fun rem tv ->\n match get_desc tv with\n Tconstr(Path.Pident id, [], _) when List.mem id rem ->\n list_remove id rem\n | _ ->\n raise (Error (cty.ctyp_loc, !env,\n Unbound_existential (ids, ty))))\n ids ty_ex\n in\n if rem <> [] then\n raise (Error (cty.ctyp_loc, !env,\n Unbound_existential (ids, ty)))\n end;\n ty_args, Some (ids, cty)\n\nlet solve_Ppat_construct ~refine env loc constr no_existentials\n existential_styp expected_ty =\n (* if constructor is gadt, we must verify that the expected type has the\n correct head *)\n if constr.cstr_generalized then\n unify_head_only ~refine loc env (instance expected_ty) constr;\n begin_def ();\n let expected_ty = instance expected_ty in\n (* PR#7214: do not use gadt unification for toplevel lets *)\n let unify_res ty_res =\n let refine =\n match refine, no_existentials with\n | None, None when constr.cstr_generalized -> Some false\n | _ -> refine\n in\n unify_pat_types_return_equated_pairs ~refine loc env ty_res expected_ty\n in\n let expansion_scope = get_gadt_equations_level () in\n let ty_args, ty_res, equated_types, existential_ctyp =\n match existential_styp with\n None ->\n let ty_args, ty_res, _ =\n instance_constructor ~in_pattern:(env, expansion_scope) constr in\n ty_args, ty_res, unify_res ty_res, None\n | Some (name_list, sty) ->\n let in_pattern =\n if name_list = [] then Some (env, expansion_scope) else None in\n let ty_args, ty_res, ty_ex =\n instance_constructor ?in_pattern constr in\n let equated_types = unify_res ty_res in\n let ty_args, existential_ctyp =\n solve_constructor_annotation env name_list sty ty_args ty_ex in\n ty_args, ty_res, equated_types, existential_ctyp\n in\n if constr.cstr_existentials <> [] then\n lower_variables_only !env expansion_scope ty_res;\n end_def ();\n generalize_structure expected_ty;\n generalize_structure ty_res;\n List.iter generalize_structure ty_args;\n if !Clflags.principal && refine = None then begin\n (* Do not warn for couter examples *)\n let exception Warn_only_once in\n try\n TypePairs.iter\n (fun (t1, t2) ->\n generalize_structure t1;\n generalize_structure t2;\n if not (fully_generic t1 && fully_generic t2) then\n let msg =\n Format.asprintf\n \"typing this pattern requires considering@ %a@ and@ %a@ as \\\n equal.@,\\\n But the knowledge of these types\"\n Printtyp.type_expr t1\n Printtyp.type_expr t2\n in\n Location.prerr_warning loc (Warnings.Not_principal msg);\n raise Warn_only_once)\n equated_types\n with Warn_only_once -> ()\n end;\n (ty_args, existential_ctyp)\n\nlet solve_Ppat_record_field ~refine loc env label label_lid record_ty =\n begin_def ();\n let (_, ty_arg, ty_res) = instance_label false label in\n begin try\n unify_pat_types ~refine loc env ty_res (instance record_ty)\n with Error(_loc, _env, Pattern_type_clash(err, _)) ->\n raise(Error(label_lid.loc, !env,\n Label_mismatch(label_lid.txt, err)))\n end;\n end_def ();\n generalize_structure ty_res;\n generalize_structure ty_arg;\n ty_arg\n\nlet solve_Ppat_array ~refine loc env expected_ty =\n let ty_elt = newgenvar() in\n let expected_ty = generic_instance expected_ty in\n unify_pat_types ~refine\n loc env (Predef.type_array ty_elt) expected_ty;\n ty_elt\n\nlet solve_Ppat_lazy ~refine loc env expected_ty =\n let nv = newgenvar () in\n unify_pat_types ~refine loc env (Predef.type_lazy_t nv)\n (generic_instance expected_ty);\n nv\n\nlet solve_Ppat_constraint ~refine loc env sty expected_ty =\n begin_def();\n let cty, ty, force = Typetexp.transl_simple_type_delayed !env sty in\n end_def();\n pattern_force := force :: !pattern_force;\n generalize_structure ty;\n let ty, expected_ty' = instance ty, ty in\n unify_pat_types ~refine loc env ty (instance expected_ty);\n (cty, ty, expected_ty')\n\nlet solve_Ppat_variant ~refine loc env tag no_arg expected_ty =\n let arg_type = if no_arg then [] else [newgenvar()] in\n let fields = [tag, rf_either ~no_arg arg_type ~matched:true] in\n let make_row more =\n create_row ~fields ~closed:false ~more ~fixed:None ~name:None\n in\n let row = make_row (newgenvar ()) in\n let expected_ty = generic_instance expected_ty in\n (* PR#7404: allow some_private_tag blindly, as it would not unify with\n the abstract row variable *)\n if tag <> Parmatch.some_private_tag then\n unify_pat_types ~refine loc env (newgenty(Tvariant row)) expected_ty;\n (arg_type, make_row (newvar ()), instance expected_ty)\n\n(* Building the or-pattern corresponding to a polymorphic variant type *)\nlet build_or_pat env loc lid =\n let path, decl = Env.lookup_type ~loc:lid.loc lid.txt env in\n let tyl = List.map (fun _ -> newvar()) decl.type_params in\n let row0 =\n let ty = expand_head env (newty(Tconstr(path, tyl, ref Mnil))) in\n match get_desc ty with\n Tvariant row when static_row row -> row\n | _ -> raise(Error(lid.loc, env, Not_a_polymorphic_variant_type lid.txt))\n in\n let pats, fields =\n List.fold_left\n (fun (pats,fields) (l,f) ->\n match row_field_repr f with\n Rpresent None ->\n let f = rf_either [] ~no_arg:true ~matched:true in\n (l,None) :: pats,\n (l, f) :: fields\n | Rpresent (Some ty) ->\n let f = rf_either [ty] ~no_arg:false ~matched:true in\n (l, Some {pat_desc=Tpat_any; pat_loc=Location.none; pat_env=env;\n pat_type=ty; pat_extra=[]; pat_attributes=[]})\n :: pats,\n (l, f) :: fields\n | _ -> pats, fields)\n ([],[]) (row_fields row0) in\n let fields = List.rev fields in\n let name = Some (path, tyl) in\n let make_row more =\n create_row ~fields ~more ~closed:false ~fixed:None ~name in\n let ty = newty (Tvariant (make_row (newvar()))) in\n let gloc = {loc with Location.loc_ghost=true} in\n let row' = ref (make_row (newvar())) in\n let pats =\n List.map\n (fun (l,p) ->\n {pat_desc=Tpat_variant(l,p,row'); pat_loc=gloc;\n pat_env=env; pat_type=ty; pat_extra=[]; pat_attributes=[]})\n pats\n in\n match pats with\n [] ->\n (* empty polymorphic variants: not possible with the concrete language\n but valid at the ast level *)\n raise(Error(lid.loc, env, Not_a_polymorphic_variant_type lid.txt))\n | pat :: pats ->\n let r =\n List.fold_left\n (fun pat pat0 ->\n {pat_desc=Tpat_or(pat0,pat,Some row0); pat_extra=[];\n pat_loc=gloc; pat_env=env; pat_type=ty; pat_attributes=[]})\n pat pats in\n (path, rp { r with pat_loc = loc })\n\nlet split_cases env cases =\n let add_case lst case = function\n | None -> lst\n | Some c_lhs -> { case with c_lhs } :: lst\n in\n List.fold_right (fun ({ c_lhs; c_guard } as case) (vals, exns) ->\n match split_pattern c_lhs with\n | Some _, Some _ when c_guard <> None ->\n raise (Error (c_lhs.pat_loc, env,\n Mixed_value_and_exception_patterns_under_guard))\n | vp, ep -> add_case vals case vp, add_case exns case ep\n ) cases ([], [])\n\n(* Type paths *)\n\nlet rec expand_path env p =\n let decl =\n try Some (Env.find_type p env) with Not_found -> None\n in\n match decl with\n Some {type_manifest = Some ty} ->\n begin match get_desc ty with\n Tconstr(p,_,_) -> expand_path env p\n | _ -> assert false\n end\n | _ ->\n let p' = Env.normalize_type_path None env p in\n if Path.same p p' then p else expand_path env p'\n\nlet compare_type_path env tpath1 tpath2 =\n Path.same (expand_path env tpath1) (expand_path env tpath2)\n\n(* Records *)\nexception Wrong_name_disambiguation of Env.t * wrong_name\n\nlet get_constr_type_path ty =\n match get_desc ty with\n | Tconstr(p, _, _) -> p\n | _ -> assert false\n\nmodule NameChoice(Name : sig\n type t\n type usage\n val kind: Datatype_kind.t\n val get_name: t -> string\n val get_type: t -> type_expr\n val lookup_all_from_type:\n Location.t -> usage -> Path.t -> Env.t -> (t * (unit -> unit)) list\n\n (** Some names (for example the fields of inline records) are not\n in the typing environment -- they behave as structural labels\n rather than nominal labels.*)\n val in_env: t -> bool\nend) = struct\n open Name\n\n let get_type_path d = get_constr_type_path (get_type d)\n\n let lookup_from_type env type_path usage lid =\n let descrs = lookup_all_from_type lid.loc usage type_path env in\n match lid.txt with\n | Longident.Lident name -> begin\n match\n List.find (fun (nd, _) -> get_name nd = name) descrs\n with\n | descr, use ->\n use ();\n descr\n | exception Not_found ->\n let valid_names = List.map (fun (nd, _) -> get_name nd) descrs in\n raise (Wrong_name_disambiguation (env, {\n type_path;\n name = { lid with txt = name };\n kind;\n valid_names;\n }))\n end\n | _ -> raise Not_found\n\n let rec unique eq acc = function\n [] -> List.rev acc\n | x :: rem ->\n if List.exists (eq x) acc then unique eq acc rem\n else unique eq (x :: acc) rem\n\n let ambiguous_types env lbl others =\n let tpath = get_type_path lbl in\n let others =\n List.map (fun (lbl, _) -> get_type_path lbl) others in\n let tpaths = unique (compare_type_path env) [tpath] others in\n match tpaths with\n [_] -> []\n | _ -> let open Printtyp in\n wrap_printing_env ~error:true env (fun () ->\n reset(); strings_of_paths Type tpaths)\n\n let disambiguate_by_type env tpath lbls =\n match lbls with\n | (Error _ : _ result) -> raise Not_found\n | Ok lbls ->\n let check_type (lbl, _) =\n let lbl_tpath = get_type_path lbl in\n compare_type_path env tpath lbl_tpath\n in\n List.find check_type lbls\n\n (* warn if there are several distinct candidates in scope *)\n let warn_if_ambiguous warn lid env lbl rest =\n if Warnings.is_active (Ambiguous_name ([],[],false,\"\")) then begin\n Printtyp.Conflicts.reset ();\n let paths = ambiguous_types env lbl rest in\n let expansion =\n Format.asprintf \"%t\" Printtyp.Conflicts.print_explanations in\n if paths <> [] then\n warn lid.loc\n (Warnings.Ambiguous_name ([Longident.last lid.txt],\n paths, false, expansion))\n end\n\n (* a non-principal type was used for disambiguation *)\n let warn_non_principal warn lid =\n let name = Datatype_kind.label_name kind in\n warn lid.loc\n (Warnings.Not_principal\n (\"this type-based \" ^ name ^ \" disambiguation\"))\n\n (* we selected a name out of the lexical scope *)\n let warn_out_of_scope warn lid env tpath =\n if Warnings.is_active (Name_out_of_scope (\"\",[],false)) then begin\n let path_s =\n Printtyp.wrap_printing_env ~error:true env\n (fun () -> Printtyp.string_of_path tpath) in\n warn lid.loc\n (Warnings.Name_out_of_scope (path_s, [Longident.last lid.txt], false))\n end\n\n (* warn if the selected name is not the last introduced in scope\n -- in these cases the resolution is different from pre-disambiguation OCaml\n (this warning is not enabled by default, it is specifically for people\n wishing to write backward-compatible code).\n *)\n let warn_if_disambiguated_name warn lid lbl scope =\n match scope with\n | Ok ((lab1,_) :: _) when lab1 == lbl -> ()\n | _ ->\n warn lid.loc\n (Warnings.Disambiguated_name (get_name lbl))\n\n let force_error : ('a, _) result -> 'a = function\n | Ok lbls -> lbls\n | Error (loc', env', err) ->\n Env.lookup_error loc' env' err\n\n type candidate = t * (unit -> unit)\n type nonempty_candidate_filter =\n candidate list -> (candidate list, candidate list) result\n (** This type is used for candidate filtering functions.\n Filtering typically proceeds in several passes, filtering\n candidates through increasingly precise conditions.\n\n We assume that the input list is non-empty, and the output is one of\n - [Ok result] for a non-empty list [result] of valid candidates\n - [Error candidates] with there are no valid candidates,\n and [candidates] is a non-empty subset of the input, typically\n the result of the last non-empty filtering step.\n *)\n\n (** [disambiguate] selects a concrete description for [lid] using\n some contextual information:\n - An optional [expected_type].\n - A list of candidates labels in the current lexical scope,\n [candidates_in_scope], that is actually at the type\n [(label_descr list, lookup_error) result] so that the\n lookup error is only raised when necessary.\n - A filtering criterion on candidates in scope [filter_candidates],\n representing extra contextual information that can help\n candidate selection (see [disambiguate_label_by_ids]).\n *)\n let disambiguate\n ?(warn=Location.prerr_warning)\n ?(filter : nonempty_candidate_filter = Result.ok)\n usage lid env\n expected_type\n candidates_in_scope =\n let lbl = match expected_type with\n | None ->\n (* no expected type => no disambiguation *)\n begin match filter (force_error candidates_in_scope) with\n | Ok [] | Error [] -> assert false\n | Error((lbl, _use) :: _rest) -> lbl (* will fail later *)\n | Ok((lbl, use) :: rest) ->\n use ();\n warn_if_ambiguous warn lid env lbl rest;\n lbl\n end\n | Some(tpath0, tpath, principal) ->\n (* If [expected_type] is available, the candidate selected\n will correspond to the type-based resolution.\n There are two reasons to still check the lexical scope:\n - for warning purposes\n - for extension types, the type environment does not contain\n a list of constructors, so using only type-based selection\n would fail.\n *)\n (* note that [disambiguate_by_type] does not\n force [candidates_in_scope]: we just skip this case if there\n are no candidates in scope *)\n begin match disambiguate_by_type env tpath candidates_in_scope with\n | lbl, use ->\n use ();\n if not principal then begin\n (* Check if non-principal type is affecting result *)\n match (candidates_in_scope : _ result) with\n | Error _ -> warn_non_principal warn lid\n | Ok lbls ->\n match filter lbls with\n | Error _ -> warn_non_principal warn lid\n | Ok [] -> assert false\n | Ok ((lbl', _use') :: rest) ->\n let lbl_tpath = get_type_path lbl' in\n (* no principality warning if the non-principal\n type-based selection corresponds to the last\n definition in scope *)\n if not (compare_type_path env tpath lbl_tpath)\n then warn_non_principal warn lid\n else warn_if_ambiguous warn lid env lbl rest;\n end;\n lbl\n | exception Not_found ->\n (* look outside the lexical scope *)\n match lookup_from_type env tpath usage lid with\n | lbl ->\n (* warn only on nominal labels;\n structural labels cannot be qualified anyway *)\n if in_env lbl then warn_out_of_scope warn lid env tpath;\n if not principal then warn_non_principal warn lid;\n lbl\n | exception Not_found ->\n match filter (force_error candidates_in_scope) with\n | Ok lbls | Error lbls ->\n let tp = (tpath0, expand_path env tpath) in\n let tpl =\n List.map\n (fun (lbl, _) ->\n let tp0 = get_type_path lbl in\n let tp = expand_path env tp0 in\n (tp0, tp))\n lbls\n in\n raise (Error (lid.loc, env,\n Name_type_mismatch (kind, lid.txt, tp, tpl)));\n end\n in\n (* warn only on nominal labels *)\n if in_env lbl then\n warn_if_disambiguated_name warn lid lbl candidates_in_scope;\n lbl\nend\n\nlet wrap_disambiguate msg ty f x =\n try f x with\n | Wrong_name_disambiguation (env, wrong_name) ->\n raise (Error (wrong_name.name.loc, env, Wrong_name (msg, ty, wrong_name)))\n\nmodule Label = NameChoice (struct\n type t = label_description\n type usage = Env.label_usage\n let kind = Datatype_kind.Record\n let get_name lbl = lbl.lbl_name\n let get_type lbl = lbl.lbl_res\n let lookup_all_from_type loc usage path env =\n Env.lookup_all_labels_from_type ~loc usage path env\n let in_env lbl =\n match lbl.lbl_repres with\n | Record_regular | Record_float | Record_unboxed false -> true\n | Record_unboxed true | Record_inlined _ | Record_extension _ -> false\nend)\n\n(* In record-construction expressions and patterns, we have many labels\n at once; find a candidate type in the intersection of the candidates\n of each label. In the [closed] expression case, this candidate must\n contain exactly all the labels.\n\n If our successive refinements result in an empty list,\n return [Error] with the last non-empty list of candidates\n for use in error messages.\n*)\nlet disambiguate_label_by_ids closed ids labels : (_, _) result =\n let check_ids (lbl, _) =\n let lbls = Hashtbl.create 8 in\n Array.iter (fun lbl -> Hashtbl.add lbls lbl.lbl_name ()) lbl.lbl_all;\n List.for_all (Hashtbl.mem lbls) ids\n and check_closed (lbl, _) =\n (not closed || List.length ids = Array.length lbl.lbl_all)\n in\n match List.filter check_ids labels with\n | [] -> Error labels\n | labels ->\n match List.filter check_closed labels with\n | [] -> Error labels\n | labels ->\n Ok labels\n\n(* Only issue warnings once per record constructor/pattern *)\nlet disambiguate_lid_a_list loc closed env usage expected_type lid_a_list =\n let ids = List.map (fun (lid, _) -> Longident.last lid.txt) lid_a_list in\n let w_pr = ref false and w_amb = ref []\n and w_scope = ref [] and w_scope_ty = ref \"\" in\n let warn loc msg =\n let open Warnings in\n match msg with\n | Not_principal _ -> w_pr := true\n | Ambiguous_name([s], l, _, ex) -> w_amb := (s, l, ex) :: !w_amb\n | Name_out_of_scope(ty, [s], _) ->\n w_scope := s :: !w_scope; w_scope_ty := ty\n | _ -> Location.prerr_warning loc msg\n in\n let process_label lid =\n let scope = Env.lookup_all_labels ~loc:lid.loc usage lid.txt env in\n let filter : Label.nonempty_candidate_filter =\n disambiguate_label_by_ids closed ids in\n Label.disambiguate ~warn ~filter usage lid env expected_type scope in\n let lbl_a_list =\n List.map (fun (lid,a) -> lid, process_label lid, a) lid_a_list in\n if !w_pr then\n Location.prerr_warning loc\n (Warnings.Not_principal \"this type-based record disambiguation\")\n else begin\n match List.rev !w_amb with\n (_,types,ex)::_ as amb ->\n let paths =\n List.map (fun (_,lbl,_) -> Label.get_type_path lbl) lbl_a_list in\n let path = List.hd paths in\n let fst3 (x,_,_) = x in\n if List.for_all (compare_type_path env path) (List.tl paths) then\n Location.prerr_warning loc\n (Warnings.Ambiguous_name (List.map fst3 amb, types, true, ex))\n else\n List.iter\n (fun (s,l,ex) -> Location.prerr_warning loc\n (Warnings.Ambiguous_name ([s],l,false, ex)))\n amb\n | _ -> ()\n end;\n if !w_scope <> [] then\n Location.prerr_warning loc\n (Warnings.Name_out_of_scope (!w_scope_ty, List.rev !w_scope, true));\n lbl_a_list\n\nlet rec find_record_qual = function\n | [] -> None\n | ({ txt = Longident.Ldot (modname, _) }, _) :: _ -> Some modname\n | _ :: rest -> find_record_qual rest\n\nlet map_fold_cont f xs k =\n List.fold_right (fun x k ys -> f x (fun y -> k (y :: ys)))\n xs (fun ys -> k (List.rev ys)) []\n\nlet type_label_a_list\n ?labels loc closed env usage type_lbl_a expected_type lid_a_list k =\n let lbl_a_list =\n match lid_a_list, labels with\n ({txt=Longident.Lident s}, _)::_, Some labels when Hashtbl.mem labels s ->\n (* Special case for rebuilt syntax trees *)\n List.map\n (function lid, a -> match lid.txt with\n Longident.Lident s -> lid, Hashtbl.find labels s, a\n | _ -> assert false)\n lid_a_list\n | _ ->\n let lid_a_list =\n match find_record_qual lid_a_list with\n None -> lid_a_list\n | Some modname ->\n List.map\n (fun (lid, a as lid_a) ->\n match lid.txt with Longident.Lident s ->\n {lid with txt=Longident.Ldot (modname, s)}, a\n | _ -> lid_a)\n lid_a_list\n in\n disambiguate_lid_a_list loc closed env usage expected_type lid_a_list\n in\n (* Invariant: records are sorted in the typed tree *)\n let lbl_a_list =\n List.sort\n (fun (_,lbl1,_) (_,lbl2,_) -> compare lbl1.lbl_pos lbl2.lbl_pos)\n lbl_a_list\n in\n map_fold_cont type_lbl_a lbl_a_list k\n;;\n\n(* Checks over the labels mentioned in a record pattern:\n no duplicate definitions (error); properly closed (warning) *)\n\nlet check_recordpat_labels loc lbl_pat_list closed =\n match lbl_pat_list with\n | [] -> () (* should not happen *)\n | (_, label1, _) :: _ ->\n let all = label1.lbl_all in\n let defined = Array.make (Array.length all) false in\n let check_defined (_, label, _) =\n if defined.(label.lbl_pos)\n then raise(Error(loc, Env.empty, Label_multiply_defined label.lbl_name))\n else defined.(label.lbl_pos) <- true in\n List.iter check_defined lbl_pat_list;\n if closed = Closed\n && Warnings.is_active (Warnings.Missing_record_field_pattern \"\")\n then begin\n let undefined = ref [] in\n for i = 0 to Array.length all - 1 do\n if not defined.(i) then undefined := all.(i).lbl_name :: !undefined\n done;\n if !undefined <> [] then begin\n let u = String.concat \", \" (List.rev !undefined) in\n Location.prerr_warning loc (Warnings.Missing_record_field_pattern u)\n end\n end\n\n(* Constructors *)\n\nmodule Constructor = NameChoice (struct\n type t = constructor_description\n type usage = Env.constructor_usage\n let kind = Datatype_kind.Variant\n let get_name cstr = cstr.cstr_name\n let get_type cstr = cstr.cstr_res\n let lookup_all_from_type loc usage path env =\n match Env.lookup_all_constructors_from_type ~loc usage path env with\n | _ :: _ as x -> x\n | [] ->\n match (Env.find_type path env).type_kind with\n | Type_open ->\n (* Extension constructors cannot be found by looking at the type\n declaration.\n We scan the whole environment to get an accurate spellchecking\n hint in the subsequent error message *)\n let filter lbl =\n compare_type_path env\n path (get_constr_type_path @@ get_type lbl) in\n let add_valid x acc = if filter x then (x,ignore)::acc else acc in\n Env.fold_constructors add_valid None env []\n | _ -> []\n let in_env _ = true\nend)\n\n(* Typing of patterns *)\n\n(* \"half typed\" cases are produced in [type_cases] when we've just typechecked\n the pattern but haven't type-checked the body yet.\n At this point we might have added some type equalities to the environment,\n but haven't yet added identifiers bound by the pattern. *)\ntype 'case_pattern half_typed_case =\n { typed_pat: 'case_pattern;\n pat_type_for_unif: type_expr;\n untyped_case: Parsetree.case;\n branch_env: Env.t;\n pat_vars: pattern_variable list;\n unpacks: module_variable list;\n contains_gadt: bool; }\n\nlet rec has_literal_pattern p = match p.ppat_desc with\n | Ppat_constant _\n | Ppat_interval _ ->\n true\n | Ppat_any\n | Ppat_variant (_, None)\n | Ppat_construct (_, None)\n | Ppat_type _\n | Ppat_var _\n | Ppat_unpack _\n | Ppat_extension _ ->\n false\n | Ppat_exception p\n | Ppat_variant (_, Some p)\n | Ppat_construct (_, Some (_, p))\n | Ppat_constraint (p, _)\n | Ppat_alias (p, _)\n | Ppat_lazy p\n | Ppat_open (_, p) ->\n has_literal_pattern p\n | Ppat_tuple ps\n | Ppat_array ps ->\n List.exists has_literal_pattern ps\n | Ppat_record (ps, _) ->\n List.exists (fun (_,p) -> has_literal_pattern p) ps\n | Ppat_or (p, q) ->\n has_literal_pattern p || has_literal_pattern q\n\nlet check_scope_escape loc env level ty =\n try Ctype.check_scope_escape env level ty\n with Escape esc ->\n (* We don't expand the type here because if we do, we might expand to the\n type that escaped, leading to confusing error messages. *)\n let trace = Errortrace.[Escape (map_escape trivial_expansion esc)] in\n raise (Error(loc,\n env,\n Pattern_type_clash(Errortrace.unification_error ~trace, None)))\n\ntype pattern_checking_mode =\n | Normal\n (** We are checking user code. *)\n | Counter_example of counter_example_checking_info\n (** In [Counter_example] mode, we are checking a counter-example\n candidate produced by Parmatch. This is a syntactic pattern that\n represents a set of values by using or-patterns (p_1 | ... | p_n)\n to enumerate all alternatives in the counter-example\n search. These or-patterns occur at every choice point, possibly\n deep inside the pattern.\n\n Parmatch does not use type information, so this pattern may\n exhibit two issues:\n - some parts of the pattern may be ill-typed due to GADTs, and\n - some wildcard patterns may not match any values: their type is\n empty.\n\n The aim of [type_pat] in the [Counter_example] mode is to refine\n this syntactic pattern into a well-typed pattern, and ensure\n that it matches at least one concrete value.\n - It filters ill-typed branches of or-patterns.\n (see {!splitting_mode} below)\n - It tries to check that wildcard patterns are non-empty.\n (see {!explosion_fuel})\n *)\n\nand counter_example_checking_info = {\n explosion_fuel: int;\n splitting_mode: splitting_mode;\n constrs: (string, Types.constructor_description) Hashtbl.t;\n labels: (string, Types.label_description) Hashtbl.t;\n }\n(**\n [explosion_fuel] controls the checking of wildcard patterns. We\n eliminate potentially-empty wildcard patterns by exploding them\n into concrete sub-patterns, for example (K1 _ | K2 _) or\n { l1: _; l2: _ }. [explosion_fuel] is the depth limit on wildcard\n explosion. Such depth limit is required to avoid non-termination\n and compilation-time blowups.\n\n [splitting_mode] controls the handling of or-patterns. In\n [Counter_example] mode, we only need to select one branch that\n leads to a well-typed pattern. Checking all branches is expensive,\n we use different search strategies (see {!splitting_mode}) to\n reduce the number of explored alternatives.\n\n [constrs] and [labels] contain metadata produced by [Parmatch] to\n type-check the given syntactic pattern. [Parmatch] produces\n counter-examples by turning typed patterns into\n [Parsetree.pattern]. In this process, constructor and label paths\n are lost, and are replaced by generated strings. [constrs] and\n [labels] map those synthetic names back to the typed descriptions\n of the original names.\n *)\n\n(** Due to GADT constraints, an or-pattern produced within\n a counter-example may have ill-typed branches. Consider for example\n\n {[\n type _ tag = Int : int tag | Bool : bool tag\n ]}\n\n then [Parmatch] will propose the or-pattern [Int | Bool] whenever\n a pattern of type [tag] is required to form a counter-example. For\n example, a function expects a (int tag option) and only [None] is\n handled by the user-written pattern. [Some (Int | Bool)] is not\n well-typed in this context, only the sub-pattern [Some Int] is.\n In this example, the expected type coming from the context\n suffices to know which or-pattern branch must be chosen.\n\n In the general case, choosing a branch can have non-local effects\n on the typability of the term. For example, consider a tuple type\n ['a tag * ...'a...], where the first component is a GADT. All\n constructor choices for this GADT lead to a well-typed branch in\n isolation (['a] is unconstrained), but choosing one of them adds\n a constraint on ['a] that may make the other tuple elements\n ill-typed.\n\n In general, after choosing each possible branch of the or-pattern,\n [type_pat] has to check the rest of the pattern to tell if this\n choice leads to a well-typed term. This may lead to an explosion\n of typing/search work -- the rest of the term may in turn contain\n alternatives.\n\n We use careful strategies to try to limit counterexample-checking\n time; [splitting_mode] represents those strategies.\n*)\nand splitting_mode =\n | Backtrack_or\n (** Always backtrack in or-patterns.\n\n [Backtrack_or] selects a single alternative from an or-pattern\n by using backtracking, trying to choose each branch in turn, and\n to complete it into a valid sub-pattern. We call this\n \"splitting\" the or-pattern.\n\n We use this mode when looking for unused patterns or sub-patterns,\n in particular to check a refutation clause (p -> .).\n *)\n | Refine_or of { inside_nonsplit_or: bool; }\n (** Only backtrack when needed.\n\n [Refine_or] tries another approach for refining or-pattern.\n\n Instead of always splitting each or-pattern, It first attempts to\n find branches that do not introduce new constraints (because they\n do not contain GADT constructors). Those branches are such that,\n if they fail, all other branches will fail.\n\n If we find one such branch, we attempt to complete the subpattern\n (checking what's outside the or-pattern), ignoring other\n branches -- we never consider another branch choice again. If all\n branches are constrained, it falls back to splitting the\n or-pattern.\n\n We use this mode when checking exhaustivity of pattern matching.\n *)\n\n(** This exception is only used internally within [type_pat_aux], in\n counter-example mode, to jump back to the parent or-pattern in the\n [Refine_or] strategy.\n\n Such a parent exists precisely when [inside_nonsplit_or = true];\n it's an invariant that we always setup an exception handler for\n [Need_backtrack] when we set this flag. *)\nexception Need_backtrack\n\n(** This exception is only used internally within [type_pat_aux], in\n counter-example mode. We use it to discard counter-example candidates\n that do not match any value. *)\nexception Empty_branch\n\ntype abort_reason = Adds_constraints | Empty\n\n(** Remember current typing state for backtracking.\n No variable information, as we only backtrack on\n patterns without variables (cf. assert statements). *)\ntype state =\n { snapshot: snapshot;\n levels: Ctype.levels;\n env: Env.t; }\nlet save_state env =\n { snapshot = Btype.snapshot ();\n levels = Ctype.save_levels ();\n env = !env; }\nlet set_state s env =\n Btype.backtrack s.snapshot;\n Ctype.set_levels s.levels;\n env := s.env\n\n(** Find the first alternative in the tree of or-patterns for which\n [f] does not raise an error. If all fail, the last error is\n propagated *)\nlet rec find_valid_alternative f pat =\n match pat.ppat_desc with\n | Ppat_or(p1,p2) ->\n (try find_valid_alternative f p1 with\n | Empty_branch | Error _ -> find_valid_alternative f p2\n )\n | _ -> f pat\n\nlet no_explosion = function\n | Normal -> Normal\n | Counter_example info ->\n Counter_example { info with explosion_fuel = 0 }\n\nlet get_splitting_mode = function\n | Normal -> None\n | Counter_example {splitting_mode} -> Some splitting_mode\n\nlet enter_nonsplit_or mode = match mode with\n | Normal -> Normal\n | Counter_example info ->\n let splitting_mode = match info.splitting_mode with\n | Backtrack_or ->\n (* in Backtrack_or mode, or-patterns are always split *)\n assert false\n | Refine_or _ ->\n Refine_or {inside_nonsplit_or = true}\n in Counter_example { info with splitting_mode }\n\n(** The typedtree has two distinct syntactic categories for patterns,\n \"value\" patterns, matching on values, and \"computation\" patterns\n that match on the effect of a computation -- typically, exception\n patterns (exception p).\n\n On the other hand, the parsetree has an unstructured representation\n where all categories of patterns are mixed together. The\n decomposition according to the value/computation structure has to\n happen during type-checking.\n\n We don't want to duplicate the type-checking logic in two different\n functions, depending on the kind of pattern to be produced. In\n particular, there are both value and computation or-patterns, and\n the type-checking logic for or-patterns is horribly complex; having\n it in two different places would be twice as horirble.\n\n The solution is to pass a GADT tag to [type_pat] to indicate whether\n a value or computation pattern is expected. This way, there is a single\n place where [Ppat_or] nodes are type-checked, the checking logic is shared,\n and only at the end do we inspect the tag to decide to produce a value\n or computation pattern.\n*)\nlet pure\n : type k . k pattern_category -> value general_pattern -> k general_pattern\n = fun category pat ->\n match category with\n | Value -> pat\n | Computation -> as_computation_pattern pat\n\nlet only_impure\n : type k . k pattern_category ->\n computation general_pattern -> k general_pattern\n = fun category pat ->\n match category with\n | Value ->\n (* LATER: this exception could be renamed/generalized *)\n raise (Error (pat.pat_loc, pat.pat_env,\n Exception_pattern_disallowed))\n | Computation -> pat\n\nlet as_comp_pattern\n : type k . k pattern_category ->\n k general_pattern -> computation general_pattern\n = fun category pat ->\n match category with\n | Value -> as_computation_pattern pat\n | Computation -> pat\n\n(* type_pat propagates the expected type.\n Unification may update the typing environment.\n\n In counter-example mode, [Empty_branch] is raised when the counter-example\n does not match any value. *)\nlet rec type_pat\n : type k r . k pattern_category ->\n no_existentials: existential_restriction option ->\n mode: pattern_checking_mode -> env: Env.t ref -> Parsetree.pattern ->\n type_expr -> (k general_pattern -> r) -> r\n = fun category ~no_existentials ~mode\n ~env sp expected_ty k ->\n Builtin_attributes.warning_scope sp.ppat_attributes\n (fun () ->\n type_pat_aux category ~no_existentials ~mode\n ~env sp expected_ty k\n )\n\nand type_pat_aux\n : type k r . k pattern_category -> no_existentials:_ -> mode:_ ->\n env:_ -> _ -> _ -> (k general_pattern -> r) -> r\n = fun category ~no_existentials ~mode\n ~env sp expected_ty k ->\n let type_pat category ?(mode=mode) ?(env=env) =\n type_pat category ~no_existentials ~mode ~env\n in\n let loc = sp.ppat_loc in\n let refine =\n match mode with Normal -> None | Counter_example _ -> Some true in\n let solve_expected (x : pattern) : pattern =\n unify_pat ~refine env x (instance expected_ty);\n x\n in\n let rp x =\n let crp (x : k general_pattern) : k general_pattern =\n match category with\n | Value -> rp x\n | Computation -> rcp x in\n if mode = Normal then crp x else x in\n let rp k x = k (rp x)\n and rvp k x = k (rp (pure category x))\n and rcp k x = k (rp (only_impure category x)) in\n let construction_not_used_in_counterexamples = (mode = Normal) in\n let must_backtrack_on_gadt = match get_splitting_mode mode with\n | None -> false\n | Some Backtrack_or -> false\n | Some (Refine_or {inside_nonsplit_or}) -> inside_nonsplit_or\n in\n match sp.ppat_desc with\n Ppat_any ->\n let k' d = rvp k {\n pat_desc = d;\n pat_loc = loc; pat_extra=[];\n pat_type = instance expected_ty;\n pat_attributes = sp.ppat_attributes;\n pat_env = !env }\n in\n begin match mode with\n | Normal -> k' Tpat_any\n | Counter_example {explosion_fuel; _} when explosion_fuel <= 0 ->\n k' Tpat_any\n | Counter_example ({explosion_fuel; _} as info) ->\n let open Parmatch in\n begin match ppat_of_type !env expected_ty with\n | PT_empty -> raise Empty_branch\n | PT_any -> k' Tpat_any\n | PT_pattern (explosion, sp, constrs, labels) ->\n let explosion_fuel =\n match explosion with\n | PE_single -> explosion_fuel - 1\n | PE_gadt_cases ->\n if must_backtrack_on_gadt then raise Need_backtrack;\n explosion_fuel - 5\n in\n let mode =\n Counter_example { info with explosion_fuel; constrs; labels }\n in\n type_pat category ~mode sp expected_ty k\n end\n end\n | Ppat_var name ->\n let ty = instance expected_ty in\n let id = (* PR#7330 *)\n if name.txt = \"*extension*\" then\n Ident.create_local name.txt\n else\n enter_variable loc name ty sp.ppat_attributes\n in\n rvp k {\n pat_desc = Tpat_var (id, name);\n pat_loc = loc; pat_extra=[];\n pat_type = ty;\n pat_attributes = sp.ppat_attributes;\n pat_env = !env }\n | Ppat_unpack name ->\n assert construction_not_used_in_counterexamples;\n let t = instance expected_ty in\n begin match name.txt with\n | None ->\n rvp k {\n pat_desc = Tpat_any;\n pat_loc = sp.ppat_loc;\n pat_extra=[Tpat_unpack, name.loc, sp.ppat_attributes];\n pat_type = t;\n pat_attributes = [];\n pat_env = !env }\n | Some s ->\n let v = { name with txt = s } in\n let id = enter_variable loc v t ~is_module:true sp.ppat_attributes in\n rvp k {\n pat_desc = Tpat_var (id, v);\n pat_loc = sp.ppat_loc;\n pat_extra=[Tpat_unpack, loc, sp.ppat_attributes];\n pat_type = t;\n pat_attributes = [];\n pat_env = !env }\n end\n | Ppat_constraint(\n {ppat_desc=Ppat_var name; ppat_loc=lloc; ppat_attributes = attrs},\n ({ptyp_desc=Ptyp_poly _} as sty)) ->\n (* explicitly polymorphic type *)\n assert construction_not_used_in_counterexamples;\n let cty, ty, ty' =\n solve_Ppat_poly_constraint ~refine env lloc sty expected_ty in\n let id = enter_variable lloc name ty' attrs in\n rvp k { pat_desc = Tpat_var (id, name);\n pat_loc = lloc;\n pat_extra = [Tpat_constraint cty, loc, sp.ppat_attributes];\n pat_type = ty;\n pat_attributes = [];\n pat_env = !env }\n | Ppat_alias(sq, name) ->\n assert construction_not_used_in_counterexamples;\n type_pat Value sq expected_ty (fun q ->\n let ty_var = solve_Ppat_alias ~refine env q in\n let id =\n enter_variable ~is_as_variable:true loc name ty_var sp.ppat_attributes\n in\n rvp k {\n pat_desc = Tpat_alias(q, id, name);\n pat_loc = loc; pat_extra=[];\n pat_type = q.pat_type;\n pat_attributes = sp.ppat_attributes;\n pat_env = !env })\n | Ppat_constant cst ->\n let cst = constant_or_raise !env loc cst in\n rvp k @@ solve_expected {\n pat_desc = Tpat_constant cst;\n pat_loc = loc; pat_extra=[];\n pat_type = type_constant cst;\n pat_attributes = sp.ppat_attributes;\n pat_env = !env }\n | Ppat_interval (Pconst_char c1, Pconst_char c2) ->\n let open Ast_helper.Pat in\n let gloc = {loc with Location.loc_ghost=true} in\n let rec loop c1 c2 =\n if c1 = c2 then constant ~loc:gloc (Pconst_char c1)\n else\n or_ ~loc:gloc\n (constant ~loc:gloc (Pconst_char c1))\n (loop (Char.chr(Char.code c1 + 1)) c2)\n in\n let p = if c1 <= c2 then loop c1 c2 else loop c2 c1 in\n let p = {p with ppat_loc=loc} in\n type_pat category ~mode:(no_explosion mode) p expected_ty k\n (* TODO: record 'extra' to remember about interval *)\n | Ppat_interval _ ->\n raise (Error (loc, !env, Invalid_interval))\n | Ppat_tuple spl ->\n assert (List.length spl >= 2);\n let expected_tys = solve_Ppat_tuple ~refine loc env spl expected_ty in\n let spl_ann = List.combine spl expected_tys in\n map_fold_cont (fun (p,t) -> type_pat Value p t) spl_ann (fun pl ->\n rvp k {\n pat_desc = Tpat_tuple pl;\n pat_loc = loc; pat_extra=[];\n pat_type = newty (Ttuple(List.map (fun p -> p.pat_type) pl));\n pat_attributes = sp.ppat_attributes;\n pat_env = !env })\n | Ppat_construct(lid, sarg) ->\n let expected_type =\n match extract_concrete_variant !env expected_ty with\n | Variant_type(p0, p, _) ->\n Some (p0, p, is_principal expected_ty)\n | Maybe_a_variant_type -> None\n | Not_a_variant_type ->\n let srt = wrong_kind_sort_of_constructor lid.txt in\n let error = Wrong_expected_kind(srt, Pattern, expected_ty) in\n raise (Error (loc, !env, error))\n in\n let constr =\n match lid.txt, mode with\n | Longident.Lident s, Counter_example {constrs; _} ->\n (* assert: cf. {!counter_example_checking_info} documentation *)\n assert (Hashtbl.mem constrs s);\n Hashtbl.find constrs s\n | _ ->\n let candidates =\n Env.lookup_all_constructors Env.Pattern ~loc:lid.loc lid.txt !env in\n wrap_disambiguate \"This variant pattern is expected to have\"\n (mk_expected expected_ty)\n (Constructor.disambiguate Env.Pattern lid !env expected_type)\n candidates\n in\n if constr.cstr_generalized && must_backtrack_on_gadt then\n raise Need_backtrack;\n begin match no_existentials, constr.cstr_existentials with\n | None, _ | _, [] -> ()\n | Some r, (_ :: _ as exs) ->\n let exs = List.map (Ctype.existential_name constr) exs in\n let name = constr.cstr_name in\n raise (Error (loc, !env, Unexpected_existential (r, name, exs)))\n end;\n let sarg', existential_styp =\n match sarg with\n None -> None, None\n | Some (vl, {ppat_desc = Ppat_constraint (sp, sty)})\n when vl <> [] || constr.cstr_arity > 1 ->\n Some sp, Some (vl, sty)\n | Some ([], sp) ->\n Some sp, None\n | Some (_, sp) ->\n raise (Error (sp.ppat_loc, !env, Missing_type_constraint))\n in\n let sargs =\n match sarg' with\n None -> []\n | Some {ppat_desc = Ppat_tuple spl} when\n constr.cstr_arity > 1 ||\n Builtin_attributes.explicit_arity sp.ppat_attributes\n -> spl\n | Some({ppat_desc = Ppat_any} as sp) when\n constr.cstr_arity = 0 && existential_styp = None\n ->\n Location.prerr_warning sp.ppat_loc\n Warnings.Wildcard_arg_to_constant_constr;\n []\n | Some({ppat_desc = Ppat_any} as sp) when constr.cstr_arity > 1 ->\n replicate_list sp constr.cstr_arity\n | Some sp -> [sp] in\n if Builtin_attributes.warn_on_literal_pattern constr.cstr_attributes then\n begin match List.filter has_literal_pattern sargs with\n | sp :: _ ->\n Location.prerr_warning sp.ppat_loc Warnings.Fragile_literal_pattern\n | _ -> ()\n end;\n if List.length sargs <> constr.cstr_arity then\n raise(Error(loc, !env, Constructor_arity_mismatch(lid.txt,\n constr.cstr_arity, List.length sargs)));\n\n let (ty_args, existential_ctyp) =\n solve_Ppat_construct ~refine env loc constr no_existentials\n existential_styp expected_ty\n in\n\n let rec check_non_escaping p =\n match p.ppat_desc with\n | Ppat_or (p1, p2) ->\n check_non_escaping p1;\n check_non_escaping p2\n | Ppat_alias (p, _) ->\n check_non_escaping p\n | Ppat_constraint _ ->\n raise (Error (p.ppat_loc, !env, Inlined_record_escape))\n | _ ->\n ()\n in\n if constr.cstr_inlined <> None then begin\n List.iter check_non_escaping sargs;\n Option.iter (fun (_, sarg) -> check_non_escaping sarg) sarg\n end;\n\n map_fold_cont\n (fun (p,t) -> type_pat Value p t)\n (List.combine sargs ty_args)\n (fun args ->\n rvp k {\n pat_desc=Tpat_construct(lid, constr, args, existential_ctyp);\n pat_loc = loc; pat_extra=[];\n pat_type = instance expected_ty;\n pat_attributes = sp.ppat_attributes;\n pat_env = !env })\n | Ppat_variant(tag, sarg) ->\n if tag = Parmatch.some_private_tag then\n assert (match mode with Normal -> false | Counter_example _ -> true);\n let constant = (sarg = None) in\n let arg_type, row, pat_type =\n solve_Ppat_variant ~refine loc env tag constant expected_ty in\n let k arg =\n rvp k {\n pat_desc = Tpat_variant(tag, arg, ref row);\n pat_loc = loc; pat_extra = [];\n pat_type = pat_type;\n pat_attributes = sp.ppat_attributes;\n pat_env = !env }\n in begin\n (* PR#6235: propagate type information *)\n match sarg, arg_type with\n Some p, [ty] -> type_pat Value p ty (fun p -> k (Some p))\n | _ -> k None\n end\n | Ppat_record(lid_sp_list, closed) ->\n assert (lid_sp_list <> []);\n let expected_type, record_ty =\n match extract_concrete_record !env expected_ty with\n | Record_type(p0, p, _) ->\n let ty = generic_instance expected_ty in\n Some (p0, p, is_principal expected_ty), ty\n | Maybe_a_record_type -> None, newvar ()\n | Not_a_record_type ->\n let error = Wrong_expected_kind(Record, Pattern, expected_ty) in\n raise (Error (loc, !env, error))\n in\n let type_label_pat (label_lid, label, sarg) k =\n let ty_arg =\n solve_Ppat_record_field ~refine loc env label label_lid record_ty in\n type_pat Value sarg ty_arg (fun arg ->\n k (label_lid, label, arg))\n in\n let make_record_pat lbl_pat_list =\n check_recordpat_labels loc lbl_pat_list closed;\n {\n pat_desc = Tpat_record (lbl_pat_list, closed);\n pat_loc = loc; pat_extra=[];\n pat_type = instance record_ty;\n pat_attributes = sp.ppat_attributes;\n pat_env = !env;\n }\n in\n let k' pat = rvp k @@ solve_expected pat in\n begin match mode with\n | Normal ->\n k' (wrap_disambiguate \"This record pattern is expected to have\"\n (mk_expected expected_ty)\n (type_label_a_list loc false !env Env.Projection\n type_label_pat expected_type lid_sp_list)\n make_record_pat)\n | Counter_example {labels; _} ->\n type_label_a_list ~labels loc false !env Env.Projection\n type_label_pat expected_type lid_sp_list\n (fun lbl_pat_list -> k' (make_record_pat lbl_pat_list))\n end\n | Ppat_array spl ->\n let ty_elt = solve_Ppat_array ~refine loc env expected_ty in\n map_fold_cont (fun p -> type_pat Value p ty_elt) spl (fun pl ->\n rvp k {\n pat_desc = Tpat_array pl;\n pat_loc = loc; pat_extra=[];\n pat_type = instance expected_ty;\n pat_attributes = sp.ppat_attributes;\n pat_env = !env })\n | Ppat_or(sp1, sp2) ->\n begin match mode with\n | Normal ->\n let initial_pattern_variables = !pattern_variables in\n let initial_module_variables = !module_variables in\n let equation_level = !gadt_equations_level in\n let outter_lev = get_current_level () in\n (* introduce a new scope *)\n begin_def ();\n let lev = get_current_level () in\n gadt_equations_level := Some lev;\n let type_pat_rec env sp =\n type_pat category sp expected_ty ~env (fun x -> x) in\n let env1 = ref !env in\n let p1 = type_pat_rec env1 sp1 in\n let p1_variables = !pattern_variables in\n let p1_module_variables = !module_variables in\n pattern_variables := initial_pattern_variables;\n module_variables := initial_module_variables;\n let env2 = ref !env in\n let p2 = type_pat_rec env2 sp2 in\n end_def ();\n gadt_equations_level := equation_level;\n let p2_variables = !pattern_variables in\n (* Make sure no variable with an ambiguous type gets added to the\n environment. *)\n List.iter (fun { pv_type; pv_loc; _ } ->\n check_scope_escape pv_loc !env1 outter_lev pv_type\n ) p1_variables;\n List.iter (fun { pv_type; pv_loc; _ } ->\n check_scope_escape pv_loc !env2 outter_lev pv_type\n ) p2_variables;\n let alpha_env =\n enter_orpat_variables loc !env p1_variables p2_variables in\n let p2 = alpha_pat alpha_env p2 in\n pattern_variables := p1_variables;\n module_variables := p1_module_variables;\n rp k { pat_desc = Tpat_or (p1, p2, None);\n pat_loc = loc; pat_extra = [];\n pat_type = instance expected_ty;\n pat_attributes = sp.ppat_attributes;\n pat_env = !env }\n | Counter_example {splitting_mode; _} ->\n (* We are in counter-example mode, but try to avoid backtracking *)\n let must_split =\n match splitting_mode with\n | Backtrack_or -> true\n | Refine_or _ -> false in\n let state = save_state env in\n let split_or sp =\n let typ pat = type_pat category pat expected_ty k in\n find_valid_alternative (fun pat -> set_state state env; typ pat) sp\n in\n if must_split then split_or sp else\n let type_pat_result env sp : (_, abort_reason) result =\n let mode = enter_nonsplit_or mode in\n match type_pat category ~mode sp expected_ty ~env (fun x -> x) with\n | res -> Ok res\n | exception Need_backtrack -> Error Adds_constraints\n | exception Empty_branch -> Error Empty\n in\n let p1 = type_pat_result (ref !env) sp1 in\n let p2 = type_pat_result (ref !env) sp2 in\n match p1, p2 with\n | Error Empty, Error Empty ->\n raise Empty_branch\n | Error Adds_constraints, Error _\n | Error _, Error Adds_constraints ->\n let inside_nonsplit_or =\n match splitting_mode with\n | Backtrack_or -> false\n | Refine_or {inside_nonsplit_or} -> inside_nonsplit_or in\n if inside_nonsplit_or\n then raise Need_backtrack\n else split_or sp\n | Ok p, Error _\n | Error _, Ok p ->\n rp k p\n | Ok p1, Ok p2 ->\n rp k { pat_desc = Tpat_or (p1, p2, None);\n pat_loc = loc; pat_extra = [];\n pat_type = instance expected_ty;\n pat_attributes = sp.ppat_attributes;\n pat_env = !env }\n end\n | Ppat_lazy sp1 ->\n let nv = solve_Ppat_lazy ~refine loc env expected_ty in\n (* do not explode under lazy: PR#7421 *)\n type_pat Value ~mode:(no_explosion mode) sp1 nv (fun p1 ->\n rvp k {\n pat_desc = Tpat_lazy p1;\n pat_loc = loc; pat_extra=[];\n pat_type = instance expected_ty;\n pat_attributes = sp.ppat_attributes;\n pat_env = !env })\n | Ppat_constraint(sp, sty) ->\n assert construction_not_used_in_counterexamples;\n (* Pretend separate = true *)\n let cty, ty, expected_ty' =\n solve_Ppat_constraint ~refine loc env sty expected_ty in\n type_pat category sp expected_ty' (fun p ->\n (*Format.printf \"%a@.%a@.\"\n Printtyp.raw_type_expr ty\n Printtyp.raw_type_expr p.pat_type;*)\n let extra = (Tpat_constraint cty, loc, sp.ppat_attributes) in\n let p : k general_pattern =\n match category, (p : k general_pattern) with\n | Value, {pat_desc = Tpat_var (id,s); _} ->\n {p with\n pat_type = ty;\n pat_desc =\n Tpat_alias\n ({p with pat_desc = Tpat_any; pat_attributes = []}, id,s);\n pat_extra = [extra];\n }\n | _, p ->\n { p with pat_type = ty; pat_extra = extra::p.pat_extra }\n in k p)\n | Ppat_type lid ->\n assert construction_not_used_in_counterexamples;\n let (path, p) = build_or_pat !env loc lid in\n k @@ pure category @@ solve_expected\n { p with pat_extra = (Tpat_type (path, lid), loc, sp.ppat_attributes)\n :: p.pat_extra }\n | Ppat_open (lid,p) ->\n assert construction_not_used_in_counterexamples;\n let path, new_env =\n !type_open Asttypes.Fresh !env sp.ppat_loc lid in\n env := new_env;\n type_pat category ~env p expected_ty ( fun p ->\n let new_env = !env in\n begin match Env.remove_last_open path new_env with\n | None -> assert false\n | Some closed_env -> env := closed_env\n end;\n k { p with pat_extra = (Tpat_open (path,lid,new_env),\n loc, sp.ppat_attributes) :: p.pat_extra }\n )\n | Ppat_exception p ->\n type_pat Value p Predef.type_exn (fun p_exn ->\n rcp k {\n pat_desc = Tpat_exception p_exn;\n pat_loc = sp.ppat_loc;\n pat_extra = [];\n pat_type = expected_ty;\n pat_env = !env;\n pat_attributes = sp.ppat_attributes;\n })\n | Ppat_extension ext ->\n raise (Error_forward (Builtin_attributes.error_of_extension ext))\n\nlet type_pat category ?no_existentials ?(mode=Normal)\n ?(lev=get_current_level()) env sp expected_ty =\n Misc.protect_refs [Misc.R (gadt_equations_level, Some lev)] (fun () ->\n type_pat category ~no_existentials ~mode\n ~env sp expected_ty (fun x -> x)\n )\n\n(* this function is passed to Partial.parmatch\n to type check gadt nonexhaustiveness *)\nlet partial_pred ~lev ~splitting_mode ?(explode=0)\n env expected_ty constrs labels p =\n let env = ref env in\n let state = save_state env in\n let mode =\n Counter_example {\n splitting_mode;\n explosion_fuel = explode;\n constrs; labels;\n } in\n try\n reset_pattern true;\n let typed_p = type_pat Value ~lev ~mode env p expected_ty in\n set_state state env;\n (* types are invalidated but we don't need them here *)\n Some typed_p\n with Error _ | Empty_branch ->\n set_state state env;\n None\n\nlet check_partial ?(lev=get_current_level ()) env expected_ty loc cases =\n let explode = match cases with [_] -> 5 | _ -> 0 in\n let splitting_mode = Refine_or {inside_nonsplit_or = false} in\n Parmatch.check_partial\n (partial_pred ~lev ~splitting_mode ~explode env expected_ty) loc cases\n\nlet check_unused ?(lev=get_current_level ()) env expected_ty cases =\n Parmatch.check_unused\n (fun refute constrs labels spat ->\n match\n partial_pred ~lev ~splitting_mode:Backtrack_or ~explode:5\n env expected_ty constrs labels spat\n with\n Some pat when refute ->\n raise (Error (spat.ppat_loc, env, Unrefuted_pattern pat))\n | r -> r)\n cases\n\nlet iter_pattern_variables_type f : pattern_variable list -> unit =\n List.iter (fun {pv_type; _} -> f pv_type)\n\nlet add_pattern_variables ?check ?check_as env pv =\n List.fold_right\n (fun {pv_id; pv_type; pv_loc; pv_as_var; pv_attributes} env ->\n let check = if pv_as_var then check_as else check in\n Env.add_value ?check pv_id\n {val_type = pv_type; val_kind = Val_reg; Types.val_loc = pv_loc;\n val_attributes = pv_attributes;\n val_uid = Uid.mk ~current_unit:(Env.get_unit_name ());\n } env\n )\n pv env\n\nlet type_pattern category ~lev env spat expected_ty =\n reset_pattern true;\n let new_env = ref env in\n let pat = type_pat category ~lev new_env spat expected_ty in\n let pvs = get_ref pattern_variables in\n let unpacks = get_ref module_variables in\n (pat, !new_env, get_ref pattern_force, pvs, unpacks)\n\nlet type_pattern_list\n category no_existentials env spatl expected_tys allow\n =\n reset_pattern allow;\n let new_env = ref env in\n let type_pat (attrs, pat) ty =\n Builtin_attributes.warning_scope ~ppwarning:false attrs\n (fun () ->\n type_pat category ~no_existentials new_env pat ty\n )\n in\n let patl = List.map2 type_pat spatl expected_tys in\n let pvs = get_ref pattern_variables in\n let unpacks =\n List.map (fun (name, loc) ->\n {tu_name = name; tu_loc = loc;\n tu_uid = Uid.mk ~current_unit:(Env.get_unit_name ())}\n ) (get_ref module_variables)\n in\n let new_env = add_pattern_variables !new_env pvs in\n (patl, new_env, get_ref pattern_force, pvs, unpacks)\n\nlet type_class_arg_pattern cl_num val_env met_env l spat =\n reset_pattern false;\n let nv = newvar () in\n let pat =\n type_pat Value ~no_existentials:In_class_args (ref val_env) spat nv in\n if has_variants pat then begin\n Parmatch.pressure_variants val_env [pat];\n finalize_variants pat;\n end;\n List.iter (fun f -> f()) (get_ref pattern_force);\n if is_optional l then unify_pat (ref val_env) pat (type_option (newvar ()));\n let (pv, val_env, met_env) =\n List.fold_right\n (fun {pv_id; pv_type; pv_loc; pv_as_var; pv_attributes}\n (pv, val_env, met_env) ->\n let check s =\n if pv_as_var then Warnings.Unused_var s\n else Warnings.Unused_var_strict s in\n let id' = Ident.rename pv_id in\n let val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in\n let val_env =\n Env.add_value pv_id\n { val_type = pv_type\n ; val_kind = Val_reg\n ; val_attributes = pv_attributes\n ; val_loc = pv_loc\n ; val_uid\n }\n val_env\n in\n let met_env =\n Env.add_value id' ~check\n { val_type = pv_type\n ; val_kind = Val_ivar (Immutable, cl_num)\n ; val_attributes = pv_attributes\n ; val_loc = pv_loc\n ; val_uid\n }\n met_env\n in\n ((id', pv_id, pv_type)::pv, val_env, met_env))\n !pattern_variables ([], val_env, met_env)\n in\n (pat, pv, val_env, met_env)\n\nlet type_self_pattern env spat =\n let open Ast_helper in\n let spat = Pat.mk(Ppat_alias (spat, mknoloc \"selfpat-*\")) in\n reset_pattern false;\n let nv = newvar() in\n let pat =\n type_pat Value ~no_existentials:In_self_pattern (ref env) spat nv in\n List.iter (fun f -> f()) (get_ref pattern_force);\n let pv = !pattern_variables in\n pattern_variables := [];\n pat, pv\n\nlet delayed_checks = ref []\nlet reset_delayed_checks () = delayed_checks := []\nlet add_delayed_check f =\n delayed_checks := (f, Warnings.backup ()) :: !delayed_checks\n\nlet force_delayed_checks () =\n (* checks may change type levels *)\n let snap = Btype.snapshot () in\n let w_old = Warnings.backup () in\n List.iter\n (fun (f, w) -> Warnings.restore w; f ())\n (List.rev !delayed_checks);\n Warnings.restore w_old;\n reset_delayed_checks ();\n Btype.backtrack snap\n\nlet rec final_subexpression exp =\n match exp.exp_desc with\n Texp_let (_, _, e)\n | Texp_sequence (_, e)\n | Texp_try (e, _)\n | Texp_ifthenelse (_, e, _)\n | Texp_match (_, {c_rhs=e} :: _, _)\n | Texp_letmodule (_, _, _, _, e)\n | Texp_letexception (_, e)\n | Texp_open (_, e)\n -> final_subexpression e\n | _ -> exp\n\n(* Generalization criterion for expressions *)\n\nlet rec is_nonexpansive exp =\n match exp.exp_desc with\n | Texp_ident _\n | Texp_constant _\n | Texp_unreachable\n | Texp_function _\n | Texp_array [] -> true\n | Texp_let(_rec_flag, pat_exp_list, body) ->\n List.for_all (fun vb -> is_nonexpansive vb.vb_expr) pat_exp_list &&\n is_nonexpansive body\n | Texp_apply(e, (_,None)::el) ->\n is_nonexpansive e && List.for_all is_nonexpansive_opt (List.map snd el)\n | Texp_match(e, cases, _) ->\n (* Not sure this is necessary, if [e] is nonexpansive then we shouldn't\n care if there are exception patterns. But the previous version enforced\n that there be none, so... *)\n let contains_exception_pat pat =\n exists_general_pattern { f = fun (type k) (p : k general_pattern) ->\n match p.pat_desc with\n | Tpat_exception _ -> true\n | _ -> false } pat\n in\n is_nonexpansive e &&\n List.for_all\n (fun {c_lhs; c_guard; c_rhs} ->\n is_nonexpansive_opt c_guard && is_nonexpansive c_rhs\n && not (contains_exception_pat c_lhs)\n ) cases\n | Texp_tuple el ->\n List.for_all is_nonexpansive el\n | Texp_construct( _, _, el) ->\n List.for_all is_nonexpansive el\n | Texp_variant(_, arg) -> is_nonexpansive_opt arg\n | Texp_record { fields; extended_expression } ->\n Array.for_all\n (fun (lbl, definition) ->\n match definition with\n | Overridden (_, exp) ->\n lbl.lbl_mut = Immutable && is_nonexpansive exp\n | Kept _ -> true)\n fields\n && is_nonexpansive_opt extended_expression\n | Texp_field(exp, _, _) -> is_nonexpansive exp\n | Texp_ifthenelse(_cond, ifso, ifnot) ->\n is_nonexpansive ifso && is_nonexpansive_opt ifnot\n | Texp_sequence (_e1, e2) -> is_nonexpansive e2 (* PR#4354 *)\n | Texp_new (_, _, cl_decl) -> Btype.class_type_arity cl_decl.cty_type > 0\n (* Note: nonexpansive only means no _observable_ side effects *)\n | Texp_lazy e -> is_nonexpansive e\n | Texp_object ({cstr_fields=fields; cstr_type = { csig_vars=vars}}, _) ->\n let count = ref 0 in\n List.for_all\n (fun field -> match field.cf_desc with\n Tcf_method _ -> true\n | Tcf_val (_, _, _, Tcfk_concrete (_, e), _) ->\n incr count; is_nonexpansive e\n | Tcf_val (_, _, _, Tcfk_virtual _, _) ->\n incr count; true\n | Tcf_initializer e -> is_nonexpansive e\n | Tcf_constraint _ -> true\n | Tcf_inherit _ -> false\n | Tcf_attribute _ -> true)\n fields &&\n Vars.fold (fun _ (mut,_,_) b -> decr count; b && mut = Immutable)\n vars true &&\n !count = 0\n | Texp_letmodule (_, _, _, mexp, e)\n | Texp_open ({ open_expr = mexp; _}, e) ->\n is_nonexpansive_mod mexp && is_nonexpansive e\n | Texp_pack mexp ->\n is_nonexpansive_mod mexp\n (* Computations which raise exceptions are nonexpansive, since (raise e) is\n equivalent to (raise e; diverge), and a nonexpansive \"diverge\" can be\n produced using lazy values or the relaxed value restriction.\n See GPR#1142 *)\n | Texp_assert exp ->\n is_nonexpansive exp\n | Texp_apply (\n { exp_desc = Texp_ident (_, _, {val_kind =\n Val_prim {Primitive.prim_name =\n (\"%raise\" | \"%reraise\" | \"%raise_notrace\")}}) },\n [Nolabel, Some e]) ->\n is_nonexpansive e\n | Texp_array (_ :: _)\n | Texp_apply _\n | Texp_try _\n | Texp_setfield _\n | Texp_while _\n | Texp_for _\n | Texp_send _\n | Texp_instvar _\n | Texp_setinstvar _\n | Texp_override _\n | Texp_letexception _\n | Texp_letop _\n | Texp_extension_constructor _ ->\n false\n\nand is_nonexpansive_mod mexp =\n match mexp.mod_desc with\n | Tmod_ident _\n | Tmod_functor _ -> true\n | Tmod_unpack (e, _) -> is_nonexpansive e\n | Tmod_constraint (m, _, _, _) -> is_nonexpansive_mod m\n | Tmod_structure str ->\n List.for_all\n (fun item -> match item.str_desc with\n | Tstr_eval _ | Tstr_primitive _ | Tstr_type _\n | Tstr_modtype _ | Tstr_class_type _ -> true\n | Tstr_value (_, pat_exp_list) ->\n List.for_all (fun vb -> is_nonexpansive vb.vb_expr) pat_exp_list\n | Tstr_module {mb_expr=m;_}\n | Tstr_open {open_expr=m;_}\n | Tstr_include {incl_mod=m;_} -> is_nonexpansive_mod m\n | Tstr_recmodule id_mod_list ->\n List.for_all (fun {mb_expr=m;_} -> is_nonexpansive_mod m)\n id_mod_list\n | Tstr_exception {tyexn_constructor = {ext_kind = Text_decl _}} ->\n false (* true would be unsound *)\n | Tstr_exception {tyexn_constructor = {ext_kind = Text_rebind _}} ->\n true\n | Tstr_typext te ->\n List.for_all\n (function {ext_kind = Text_decl _} -> false\n | {ext_kind = Text_rebind _} -> true)\n te.tyext_constructors\n | Tstr_class _ -> false (* could be more precise *)\n | Tstr_attribute _ -> true\n )\n str.str_items\n | Tmod_apply _ -> false\n\nand is_nonexpansive_opt = function\n | None -> true\n | Some e -> is_nonexpansive e\n\nlet maybe_expansive e = not (is_nonexpansive e)\n\nlet check_recursive_bindings env valbinds =\n let ids = let_bound_idents valbinds in\n List.iter\n (fun {vb_expr} ->\n if not (Rec_check.is_valid_recursive_expression ids vb_expr) then\n raise(Error(vb_expr.exp_loc, env, Illegal_letrec_expr))\n )\n valbinds\n\nlet check_recursive_class_bindings env ids exprs =\n List.iter\n (fun expr ->\n if not (Rec_check.is_valid_class_expr ids expr) then\n raise(Error(expr.cl_loc, env, Illegal_class_expr)))\n exprs\n\nlet is_prim ~name funct =\n match funct.exp_desc with\n | Texp_ident (_, _, {val_kind=Val_prim{Primitive.prim_name; _}}) ->\n prim_name = name\n | _ -> false\n(* Approximate the type of an expression, for better recursion *)\n\nlet rec approx_type env sty =\n match sty.ptyp_desc with\n Ptyp_arrow (p, _, sty) ->\n let ty1 = if is_optional p then type_option (newvar ()) else newvar () in\n newty (Tarrow (p, ty1, approx_type env sty, commu_ok))\n | Ptyp_tuple args ->\n newty (Ttuple (List.map (approx_type env) args))\n | Ptyp_constr (lid, ctl) ->\n let path, decl = Env.lookup_type ~use:false ~loc:lid.loc lid.txt env in\n if List.length ctl <> decl.type_arity then newvar ()\n else begin\n let tyl = List.map (approx_type env) ctl in\n newconstr path tyl\n end\n | Ptyp_poly (_, sty) ->\n approx_type env sty\n | _ -> newvar ()\n\nlet rec type_approx env sexp =\n match sexp.pexp_desc with\n Pexp_let (_, _, e) -> type_approx env e\n | Pexp_fun (p, _, _, e) ->\n let ty = if is_optional p then type_option (newvar ()) else newvar () in\n newty (Tarrow(p, ty, type_approx env e, commu_ok))\n | Pexp_function ({pc_rhs=e}::_) ->\n newty (Tarrow(Nolabel, newvar (), type_approx env e, commu_ok))\n | Pexp_match (_, {pc_rhs=e}::_) -> type_approx env e\n | Pexp_try (e, _) -> type_approx env e\n | Pexp_tuple l -> newty (Ttuple(List.map (type_approx env) l))\n | Pexp_ifthenelse (_,e,_) -> type_approx env e\n | Pexp_sequence (_,e) -> type_approx env e\n | Pexp_constraint (e, sty) ->\n let ty = type_approx env e in\n let ty1 = approx_type env sty in\n begin try unify env ty ty1 with Unify err ->\n raise(Error(sexp.pexp_loc, env, Expr_type_clash (err, None, None)))\n end;\n ty1\n | Pexp_coerce (e, sty1, sty2) ->\n let approx_ty_opt = function\n | None -> newvar ()\n | Some sty -> approx_type env sty\n in\n let ty = type_approx env e\n and ty1 = approx_ty_opt sty1\n and ty2 = approx_type env sty2 in\n begin try unify env ty ty1 with Unify err ->\n raise(Error(sexp.pexp_loc, env, Expr_type_clash (err, None, None)))\n end;\n ty2\n | _ -> newvar ()\n\n(* List labels in a function type, and whether return type is a variable *)\nlet rec list_labels_aux env visited ls ty_fun =\n let ty = expand_head env ty_fun in\n if TypeSet.mem ty visited then\n List.rev ls, false\n else match get_desc ty with\n Tarrow (l, _, ty_res, _) ->\n list_labels_aux env (TypeSet.add ty visited) (l::ls) ty_res\n | _ ->\n List.rev ls, is_Tvar ty\n\nlet list_labels env ty =\n wrap_trace_gadt_instances env (list_labels_aux env TypeSet.empty []) ty\n\n(* Check that all univars are safe in a type. Both exp.exp_type and\n ty_expected should already be generalized. *)\nlet check_univars env kind exp ty_expected vars =\n let pty = instance ty_expected in\n begin_def ();\n let exp_ty, vars =\n match get_desc pty with\n Tpoly (body, tl) ->\n (* Enforce scoping for type_let:\n since body is not generic, instance_poly only makes\n copies of nodes that have a Tvar as descendant *)\n let _, ty' = instance_poly true tl body in\n let vars, exp_ty = instance_parameterized_type vars exp.exp_type in\n unify_exp_types exp.exp_loc env exp_ty ty';\n exp_ty, vars\n | _ -> assert false\n in\n end_def ();\n generalize exp_ty;\n List.iter generalize vars;\n let ty, complete = polyfy env exp_ty vars in\n if not complete then\n let ty_expected = instance ty_expected in\n raise (Error(exp.exp_loc,\n env,\n Less_general(kind,\n Errortrace.unification_error\n ~trace:[Ctype.expanded_diff env\n ~got:ty ~expected:ty_expected])))\n\nlet generalize_and_check_univars env kind exp ty_expected vars =\n generalize exp.exp_type;\n generalize ty_expected;\n List.iter generalize vars;\n check_univars env kind exp ty_expected vars\n\n(* [check_statement] implements the [non-unit-statement] check.\n\n This check is called in contexts where the value of the expression is known\n to be discarded (eg. the lhs of a sequence). We check that [exp] has type\n unit, or has an explicit type annotation; otherwise we raise the\n [non-unit-statement] warning. *)\n\nlet check_statement exp =\n let ty = get_desc (expand_head exp.exp_env exp.exp_type) in\n match ty with\n | Tconstr (p, _, _) when Path.same p Predef.path_unit -> ()\n | Tvar _ -> ()\n | _ ->\n let rec loop {exp_loc; exp_desc; exp_extra; _} =\n match exp_desc with\n | Texp_let (_, _, e)\n | Texp_sequence (_, e)\n | Texp_letexception (_, e)\n | Texp_letmodule (_, _, _, _, e) ->\n loop e\n | _ ->\n let loc =\n match List.find_opt (function\n | (Texp_constraint _, _, _) -> true\n | _ -> false) exp_extra\n with\n | Some (_, loc, _) -> loc\n | None -> exp_loc\n in\n Location.prerr_warning loc Warnings.Non_unit_statement\n in\n loop exp\n\n\n(* [check_partial_application] implements the [ignored-partial-application]\n warning (and if [statement] is [true], also [non-unit-statement]).\n\n If [exp] has a function type, we check that it is not syntactically the\n result of a function application, as this is often a bug in certain contexts\n (eg the rhs of a let-binding or in the argument of [ignore]). For example,\n [ignore (List.map print_int)] written by mistake instad of [ignore (List.map\n print_int li)].\n\n The check can be disabled by explicitly annotating the expression with a type\n constraint, eg [(e : _ -> _)].\n\n If [statement] is [true] and the [ignored-partial-application] is {em not}\n triggered, then the [non-unit-statement] check is performaed (see\n [check_statement]).\n\n If the type of [exp] is not known at the time this function is called, the\n check is retried again after typechecking. *)\n\nlet check_partial_application ~statement exp =\n let check_statement () = if statement then check_statement exp in\n let doit () =\n let ty = get_desc (expand_head exp.exp_env exp.exp_type) in\n match ty with\n | Tarrow _ ->\n let rec check {exp_desc; exp_loc; exp_extra; _} =\n if List.exists (function\n | (Texp_constraint _, _, _) -> true\n | _ -> false) exp_extra then check_statement ()\n else begin\n match exp_desc with\n | Texp_ident _ | Texp_constant _ | Texp_tuple _\n | Texp_construct _ | Texp_variant _ | Texp_record _\n | Texp_field _ | Texp_setfield _ | Texp_array _\n | Texp_while _ | Texp_for _ | Texp_instvar _\n | Texp_setinstvar _ | Texp_override _ | Texp_assert _\n | Texp_lazy _ | Texp_object _ | Texp_pack _ | Texp_unreachable\n | Texp_extension_constructor _ | Texp_ifthenelse (_, _, None)\n | Texp_function _ ->\n check_statement ()\n | Texp_match (_, cases, _) ->\n List.iter (fun {c_rhs; _} -> check c_rhs) cases\n | Texp_try (e, cases) ->\n check e; List.iter (fun {c_rhs; _} -> check c_rhs) cases\n | Texp_ifthenelse (_, e1, Some e2) ->\n check e1; check e2\n | Texp_let (_, _, e) | Texp_sequence (_, e) | Texp_open (_, e)\n | Texp_letexception (_, e) | Texp_letmodule (_, _, _, _, e) ->\n check e\n | Texp_apply _ | Texp_send _ | Texp_new _ | Texp_letop _ ->\n Location.prerr_warning exp_loc\n Warnings.Ignored_partial_application\n end\n in\n check exp\n | _ ->\n check_statement ()\n in\n let ty = get_desc (expand_head exp.exp_env exp.exp_type) in\n match ty with\n | Tvar _ ->\n (* The type of [exp] is not known. Delay the check until after\n typechecking in order to give a chance for the type to become known\n through unification. *)\n add_delayed_check doit\n | _ ->\n doit ()\n\n(* Check that a type is generalizable at some level *)\nlet generalizable level ty =\n let rec check ty =\n if not_marked_node ty then\n if get_level ty <= level then raise Exit else\n (flip_mark_node ty; iter_type_expr check ty)\n in\n try check ty; unmark_type ty; true\n with Exit -> unmark_type ty; false\n\n(* Hack to allow coercion of self. Will clean-up later. *)\nlet self_coercion = ref ([] : (Path.t * Location.t list ref) list)\n\n(* Helpers for type_cases *)\n\nlet contains_variant_either ty =\n let rec loop ty =\n if try_mark_node ty then\n begin match get_desc ty with\n Tvariant row ->\n if not (is_fixed row) then\n List.iter\n (fun (_,f) ->\n match row_field_repr f with Reither _ -> raise Exit | _ -> ())\n (row_fields row);\n iter_row loop row\n | _ ->\n iter_type_expr loop ty\n end\n in\n try loop ty; unmark_type ty; false\n with Exit -> unmark_type ty; true\n\nlet shallow_iter_ppat f p =\n match p.ppat_desc with\n | Ppat_any | Ppat_var _ | Ppat_constant _ | Ppat_interval _\n | Ppat_construct (_, None)\n | Ppat_extension _\n | Ppat_type _ | Ppat_unpack _ -> ()\n | Ppat_array pats -> List.iter f pats\n | Ppat_or (p1,p2) -> f p1; f p2\n | Ppat_variant (_, arg) -> Option.iter f arg\n | Ppat_tuple lst -> List.iter f lst\n | Ppat_construct (_, Some (_, p))\n | Ppat_exception p | Ppat_alias (p,_)\n | Ppat_open (_,p)\n | Ppat_constraint (p,_) | Ppat_lazy p -> f p\n | Ppat_record (args, _flag) -> List.iter (fun (_,p) -> f p) args\n\nlet exists_ppat f p =\n let exception Found in\n let rec loop p =\n if f p then raise Found else ();\n shallow_iter_ppat loop p in\n match loop p with\n | exception Found -> true\n | () -> false\n\nlet contains_polymorphic_variant p =\n exists_ppat\n (function\n | {ppat_desc = (Ppat_variant _ | Ppat_type _)} -> true\n | _ -> false)\n p\n\nlet contains_gadt p =\n exists_general_pattern { f = fun (type k) (p : k general_pattern) ->\n match p.pat_desc with\n | Tpat_construct (_, cd, _, _) when cd.cstr_generalized -> true\n | _ -> false } p\n\n(* There are various things that we need to do in presence of GADT constructors\n that aren't required if there are none.\n However, because of disambiguation, we can't know for sure whether the\n patterns contain some GADT constructors. So we conservatively assume that\n any constructor might be a GADT constructor. *)\nlet may_contain_gadts p =\n exists_ppat\n (function\n | {ppat_desc = Ppat_construct _} -> true\n | _ -> false)\n p\n\nlet check_absent_variant env =\n iter_general_pattern { f = fun (type k) (pat : k general_pattern) ->\n match pat.pat_desc with\n | Tpat_variant (s, arg, row) ->\n let row = !row in\n if List.exists (fun (s',fi) -> s = s' && row_field_repr fi <> Rabsent)\n (row_fields row)\n || not (is_fixed row) && not (static_row row) (* same as Ctype.poly *)\n then () else\n let ty_arg =\n match arg with None -> [] | Some p -> [correct_levels p.pat_type] in\n let fields = [s, rf_either ty_arg ~no_arg:(arg=None) ~matched:true] in\n let row' =\n create_row ~fields\n ~more:(newvar ()) ~closed:false ~fixed:None ~name:None in\n (* Should fail *)\n unify_pat (ref env) {pat with pat_type = newty (Tvariant row')}\n (correct_levels pat.pat_type)\n | _ -> () }\n\n(* Getting proper location of already typed expressions.\n\n Used to avoid confusing locations on type error messages in presence of\n type constraints.\n For example:\n\n (* Before patch *)\n # let x : string = (5 : int);;\n ^\n (* After patch *)\n # let x : string = (5 : int);;\n ^^^^^^^^^\n*)\nlet proper_exp_loc exp =\n let rec aux = function\n | [] -> exp.exp_loc\n | ((Texp_constraint _ | Texp_coerce _), loc, _) :: _ -> loc\n | _ :: rest -> aux rest\n in\n aux exp.exp_extra\n\n(* To find reasonable names for let-bound and lambda-bound idents *)\n\nlet rec name_pattern default = function\n [] -> Ident.create_local default\n | p :: rem ->\n match p.pat_desc with\n Tpat_var (id, _) -> id\n | Tpat_alias(_, id, _) -> id\n | _ -> name_pattern default rem\n\nlet name_cases default lst =\n name_pattern default (List.map (fun c -> c.c_lhs) lst)\n\n(* Typing of expressions *)\n\nlet unify_exp env exp expected_ty =\n let loc = proper_exp_loc exp in\n try\n unify_exp_types loc env exp.exp_type expected_ty\n with Error(loc, env, Expr_type_clash(err, tfc, None)) ->\n raise (Error(loc, env, Expr_type_clash(err, tfc, Some exp.exp_desc)))\n\n(* If [is_inferred e] is true, [e] will be typechecked without using\n the \"expected type\" provided by the context. *)\n\nlet rec is_inferred sexp =\n match sexp.pexp_desc with\n | Pexp_ident _ | Pexp_apply _ | Pexp_field _ | Pexp_constraint _\n | Pexp_coerce _ | Pexp_send _ | Pexp_new _ -> true\n | Pexp_sequence (_, e) | Pexp_open (_, e) -> is_inferred e\n | Pexp_ifthenelse (_, e1, Some e2) -> is_inferred e1 && is_inferred e2\n | _ -> false\n\n(* check if the type of %apply or %revapply matches the type expected by\n the specialized typing rule for those primitives.\n*)\ntype apply_prim =\n | Apply\n | Revapply\nlet check_apply_prim_type prim typ =\n match get_desc typ with\n | Tarrow (Nolabel,a,b,_) ->\n begin match get_desc b with\n | Tarrow(Nolabel,c,d,_) ->\n let f, x, res =\n match prim with\n | Apply -> a, c, d\n | Revapply -> c, a, d\n in\n begin match get_desc f with\n | Tarrow(Nolabel,fl,fr,_) ->\n is_Tvar fl && is_Tvar fr && is_Tvar x && is_Tvar res\n && Types.eq_type fl x && Types.eq_type fr res\n | _ -> false\n end\n | _ -> false\n end\n | _ -> false\n\n(* Merge explanation to type clash error *)\n\nlet with_explanation explanation f =\n match explanation with\n | None -> f ()\n | Some explanation ->\n try f ()\n with Error (loc', env', Expr_type_clash(err', None, exp'))\n when not loc'.Location.loc_ghost ->\n let err = Expr_type_clash(err', Some explanation, exp') in\n raise (Error (loc', env', err))\n\nlet rec type_exp ?recarg env sexp =\n (* We now delegate everything to type_expect *)\n type_expect ?recarg env sexp (mk_expected (newvar ()))\n\n(* Typing of an expression with an expected type.\n This provide better error messages, and allows controlled\n propagation of return type information.\n In the principal case, [type_expected'] may be at generic_level.\n *)\n\nand type_expect ?in_function ?recarg env sexp ty_expected_explained =\n let previous_saved_types = Cmt_format.get_saved_types () in\n let exp =\n Builtin_attributes.warning_scope sexp.pexp_attributes\n (fun () ->\n type_expect_ ?in_function ?recarg env sexp ty_expected_explained\n )\n in\n Cmt_format.set_saved_types\n (Cmt_format.Partial_expression exp :: previous_saved_types);\n exp\n\nand type_expect_\n ?in_function ?(recarg=Rejected)\n env sexp ty_expected_explained =\n let { ty = ty_expected; explanation } = ty_expected_explained in\n let loc = sexp.pexp_loc in\n (* Record the expression type before unifying it with the expected type *)\n let with_explanation = with_explanation explanation in\n let rue exp =\n with_explanation (fun () ->\n unify_exp env (re exp) (instance ty_expected));\n exp\n in\n match sexp.pexp_desc with\n | Pexp_ident lid ->\n let path, desc = type_ident env ~recarg lid in\n let exp_desc =\n match desc.val_kind with\n | Val_ivar (_, cl_num) ->\n let (self_path, _) =\n Env.find_value_by_name\n (Longident.Lident (\"self-\" ^ cl_num)) env\n in\n Texp_instvar(self_path, path,\n match lid.txt with\n Longident.Lident txt -> { txt; loc = lid.loc }\n | _ -> assert false)\n | Val_self (_, _, _, cl_num) ->\n let (path, _) =\n Env.find_value_by_name (Longident.Lident (\"self-\" ^ cl_num)) env\n in\n Texp_ident(path, lid, desc)\n | _ ->\n Texp_ident(path, lid, desc)\n in\n rue {\n exp_desc; exp_loc = loc; exp_extra = [];\n exp_type = instance desc.val_type;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_constant(Pconst_string (str, _, _) as cst) -> (\n let cst = constant_or_raise env loc cst in\n (* Terrible hack for format strings *)\n let ty_exp = expand_head env ty_expected in\n let fmt6_path =\n Path.(Pdot (Pident (Ident.create_persistent \"CamlinternalFormatBasics\"),\n \"format6\"))\n in\n let is_format = match get_desc ty_exp with\n | Tconstr(path, _, _) when Path.same path fmt6_path ->\n if !Clflags.principal && get_level ty_exp <> generic_level then\n Location.prerr_warning loc\n (Warnings.Not_principal \"this coercion to format6\");\n true\n | _ -> false\n in\n if is_format then\n let format_parsetree =\n { (type_format loc str env) with pexp_loc = sexp.pexp_loc } in\n type_expect ?in_function env format_parsetree ty_expected_explained\n else\n rue {\n exp_desc = Texp_constant cst;\n exp_loc = loc; exp_extra = [];\n exp_type = instance Predef.type_string;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n )\n | Pexp_constant cst ->\n let cst = constant_or_raise env loc cst in\n rue {\n exp_desc = Texp_constant cst;\n exp_loc = loc; exp_extra = [];\n exp_type = type_constant cst;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_let(Nonrecursive,\n [{pvb_pat=spat; pvb_expr=sval; pvb_attributes=[]}], sbody)\n when may_contain_gadts spat ->\n (* TODO: allow non-empty attributes? *)\n type_expect ?in_function env\n {sexp with\n pexp_desc = Pexp_match (sval, [Ast_helper.Exp.case spat sbody])}\n ty_expected_explained\n | Pexp_let(rec_flag, spat_sexp_list, sbody) ->\n let existential_context =\n if rec_flag = Recursive then In_rec\n else if List.compare_length_with spat_sexp_list 1 > 0 then In_group\n else With_attributes in\n let (pat_exp_list, new_env, unpacks) =\n type_let existential_context env rec_flag spat_sexp_list true in\n let body = type_unpacks new_env unpacks sbody ty_expected_explained in\n let () =\n if rec_flag = Recursive then\n check_recursive_bindings env pat_exp_list\n in\n re {\n exp_desc = Texp_let(rec_flag, pat_exp_list, body);\n exp_loc = loc; exp_extra = [];\n exp_type = body.exp_type;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_fun (l, Some default, spat, sbody) ->\n assert(is_optional l); (* default allowed only with optional argument *)\n let open Ast_helper in\n let default_loc = default.pexp_loc in\n let scases = [\n Exp.case\n (Pat.construct ~loc:default_loc\n (mknoloc (Longident.(Ldot (Lident \"*predef*\", \"Some\"))))\n (Some ([], Pat.var ~loc:default_loc (mknoloc \"*sth*\"))))\n (Exp.ident ~loc:default_loc (mknoloc (Longident.Lident \"*sth*\")));\n\n Exp.case\n (Pat.construct ~loc:default_loc\n (mknoloc (Longident.(Ldot (Lident \"*predef*\", \"None\"))))\n None)\n default;\n ]\n in\n let sloc =\n { Location.loc_start = spat.ppat_loc.Location.loc_start;\n loc_end = default_loc.Location.loc_end;\n loc_ghost = true }\n in\n let smatch =\n Exp.match_ ~loc:sloc\n (Exp.ident ~loc (mknoloc (Longident.Lident \"*opt*\")))\n scases\n in\n let pat = Pat.var ~loc:sloc (mknoloc \"*opt*\") in\n let body =\n Exp.let_ ~loc Nonrecursive\n ~attrs:[Attr.mk (mknoloc \"#default\") (PStr [])]\n [Vb.mk spat smatch] sbody\n in\n type_function ?in_function loc sexp.pexp_attributes env\n ty_expected_explained l [Exp.case pat body]\n | Pexp_fun (l, None, spat, sbody) ->\n type_function ?in_function loc sexp.pexp_attributes env\n ty_expected_explained l [Ast_helper.Exp.case spat sbody]\n | Pexp_function caselist ->\n type_function ?in_function\n loc sexp.pexp_attributes env ty_expected_explained Nolabel caselist\n | Pexp_apply(sfunct, sargs) ->\n assert (sargs <> []);\n let rec lower_args seen ty_fun =\n let ty = expand_head env ty_fun in\n if TypeSet.mem ty seen then () else\n match get_desc ty with\n Tarrow (_l, ty_arg, ty_fun, _com) ->\n (try unify_var env (newvar()) ty_arg\n with Unify _ -> assert false);\n lower_args (TypeSet.add ty seen) ty_fun\n | _ -> ()\n in\n let type_sfunct sfunct =\n begin_def (); (* one more level for non-returning functions *)\n if !Clflags.principal then begin_def ();\n let funct = type_exp env sfunct in\n if !Clflags.principal then begin\n end_def ();\n generalize_structure funct.exp_type\n end;\n let ty = instance funct.exp_type in\n end_def ();\n wrap_trace_gadt_instances env (lower_args TypeSet.empty) ty;\n funct\n in\n let funct, sargs =\n let funct = type_sfunct sfunct in\n match funct.exp_desc, sargs with\n | Texp_ident (_, _,\n {val_kind = Val_prim {prim_name=\"%revapply\"}; val_type}),\n [Nolabel, sarg; Nolabel, actual_sfunct]\n when is_inferred actual_sfunct\n && check_apply_prim_type Revapply val_type ->\n type_sfunct actual_sfunct, [Nolabel, sarg]\n | Texp_ident (_, _,\n {val_kind = Val_prim {prim_name=\"%apply\"}; val_type}),\n [Nolabel, actual_sfunct; Nolabel, sarg]\n when check_apply_prim_type Apply val_type ->\n type_sfunct actual_sfunct, [Nolabel, sarg]\n | _ ->\n funct, sargs\n in\n begin_def ();\n let (args, ty_res) = type_application env funct sargs in\n end_def ();\n unify_var env (newvar()) funct.exp_type;\n let exp =\n { exp_desc = Texp_apply(funct, args);\n exp_loc = loc; exp_extra = [];\n exp_type = ty_res;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env } in\n begin\n try rue exp\n with Error (_, _, Expr_type_clash _) as err ->\n Misc.reraise_preserving_backtrace err (fun () ->\n check_partial_application ~statement:false exp)\n end\n | Pexp_match(sarg, caselist) ->\n begin_def ();\n let arg = type_exp env sarg in\n end_def ();\n if maybe_expansive arg then lower_contravariant env arg.exp_type;\n generalize arg.exp_type;\n let cases, partial =\n type_cases Computation env\n arg.exp_type ty_expected_explained true loc caselist in\n re {\n exp_desc = Texp_match(arg, cases, partial);\n exp_loc = loc; exp_extra = [];\n exp_type = instance ty_expected;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_try(sbody, caselist) ->\n let body = type_expect env sbody ty_expected_explained in\n let cases, _ =\n type_cases Value env\n Predef.type_exn ty_expected_explained false loc caselist in\n re {\n exp_desc = Texp_try(body, cases);\n exp_loc = loc; exp_extra = [];\n exp_type = body.exp_type;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_tuple sexpl ->\n assert (List.length sexpl >= 2);\n let subtypes = List.map (fun _ -> newgenvar ()) sexpl in\n let to_unify = newgenty (Ttuple subtypes) in\n with_explanation (fun () ->\n unify_exp_types loc env to_unify (generic_instance ty_expected));\n let expl =\n List.map2 (fun body ty -> type_expect env body (mk_expected ty))\n sexpl subtypes\n in\n re {\n exp_desc = Texp_tuple expl;\n exp_loc = loc; exp_extra = [];\n (* Keep sharing *)\n exp_type = newty (Ttuple (List.map (fun e -> e.exp_type) expl));\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_construct(lid, sarg) ->\n type_construct env loc lid sarg ty_expected_explained sexp.pexp_attributes\n | Pexp_variant(l, sarg) ->\n (* Keep sharing *)\n let ty_expected0 = instance ty_expected in\n begin try match\n sarg, get_desc (expand_head env ty_expected),\n get_desc (expand_head env ty_expected0)\n with\n | Some sarg, Tvariant row, Tvariant row0 ->\n begin match\n row_field_repr (get_row_field l row),\n row_field_repr (get_row_field l row0)\n with\n Rpresent (Some ty), Rpresent (Some ty0) ->\n let arg = type_argument env sarg ty ty0 in\n re { exp_desc = Texp_variant(l, Some arg);\n exp_loc = loc; exp_extra = [];\n exp_type = ty_expected0;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | _ -> raise Exit\n end\n | _ -> raise Exit\n with Exit ->\n let arg = Option.map (type_exp env) sarg in\n let arg_type = Option.map (fun arg -> arg.exp_type) arg in\n let row =\n create_row\n ~fields: [l, rf_present arg_type]\n ~more: (newvar ())\n ~closed: false\n ~fixed: None\n ~name: None\n in\n rue {\n exp_desc = Texp_variant(l, arg);\n exp_loc = loc; exp_extra = [];\n exp_type = newty (Tvariant row);\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n end\n | Pexp_record(lid_sexp_list, opt_sexp) ->\n assert (lid_sexp_list <> []);\n let opt_exp =\n match opt_sexp with\n None -> None\n | Some sexp ->\n if !Clflags.principal then begin_def ();\n let exp = type_exp ~recarg env sexp in\n if !Clflags.principal then begin\n end_def ();\n generalize_structure exp.exp_type\n end;\n Some exp\n in\n let ty_record, expected_type =\n let expected_opath =\n match extract_concrete_record env ty_expected with\n | Record_type (p0, p, _) -> Some (p0, p, is_principal ty_expected)\n | Maybe_a_record_type -> None\n | Not_a_record_type ->\n let error =\n Wrong_expected_kind(Record, Expression explanation, ty_expected)\n in\n raise (Error (loc, env, error))\n in\n let opt_exp_opath =\n match opt_exp with\n | None -> None\n | Some exp ->\n match extract_concrete_record env exp.exp_type with\n | Record_type (p0, p, _) -> Some (p0, p, is_principal exp.exp_type)\n | Maybe_a_record_type -> None\n | Not_a_record_type ->\n let error = Expr_not_a_record_type exp.exp_type in\n raise (Error (exp.exp_loc, env, error))\n in\n match expected_opath, opt_exp_opath with\n | None, None -> newvar (), None\n | Some _, None -> ty_expected, expected_opath\n | Some(_, _, true), Some _ -> ty_expected, expected_opath\n | (None | Some (_, _, false)), Some (_, p', _) ->\n let decl = Env.find_type p' env in\n begin_def ();\n let ty = newconstr p' (instance_list decl.type_params) in\n end_def ();\n generalize_structure ty;\n ty, opt_exp_opath\n in\n let closed = (opt_sexp = None) in\n let lbl_exp_list =\n wrap_disambiguate \"This record expression is expected to have\"\n (mk_expected ty_record)\n (type_label_a_list loc closed env Env.Construct\n (fun e k -> k (type_label_exp true env loc ty_record e))\n expected_type lid_sexp_list)\n (fun x -> x)\n in\n with_explanation (fun () ->\n unify_exp_types loc env (instance ty_record) (instance ty_expected));\n\n (* type_label_a_list returns a list of labels sorted by lbl_pos *)\n (* note: check_duplicates would better be implemented in\n type_label_a_list directly *)\n let rec check_duplicates = function\n | (_, lbl1, _) :: (_, lbl2, _) :: _ when lbl1.lbl_pos = lbl2.lbl_pos ->\n raise(Error(loc, env, Label_multiply_defined lbl1.lbl_name))\n | _ :: rem ->\n check_duplicates rem\n | [] -> ()\n in\n check_duplicates lbl_exp_list;\n let opt_exp, label_definitions =\n let (_lid, lbl, _lbl_exp) = List.hd lbl_exp_list in\n let matching_label lbl =\n List.find\n (fun (_, lbl',_) -> lbl'.lbl_pos = lbl.lbl_pos)\n lbl_exp_list\n in\n match opt_exp with\n None ->\n let label_definitions =\n Array.map (fun lbl ->\n match matching_label lbl with\n | (lid, _lbl, lbl_exp) ->\n Overridden (lid, lbl_exp)\n | exception Not_found ->\n let present_indices =\n List.map (fun (_, lbl, _) -> lbl.lbl_pos) lbl_exp_list\n in\n let label_names = extract_label_names env ty_expected in\n let rec missing_labels n = function\n [] -> []\n | lbl :: rem ->\n if List.mem n present_indices\n then missing_labels (n + 1) rem\n else lbl :: missing_labels (n + 1) rem\n in\n let missing = missing_labels 0 label_names in\n raise(Error(loc, env, Label_missing missing)))\n lbl.lbl_all\n in\n None, label_definitions\n | Some exp ->\n let ty_exp = instance exp.exp_type in\n let unify_kept lbl =\n let _, ty_arg1, ty_res1 = instance_label false lbl in\n unify_exp_types exp.exp_loc env ty_exp ty_res1;\n match matching_label lbl with\n | lid, _lbl, lbl_exp ->\n (* do not connect result types for overridden labels *)\n Overridden (lid, lbl_exp)\n | exception Not_found -> begin\n let _, ty_arg2, ty_res2 = instance_label false lbl in\n unify_exp_types loc env ty_arg1 ty_arg2;\n with_explanation (fun () ->\n unify_exp_types loc env (instance ty_expected) ty_res2);\n Kept ty_arg1\n end\n in\n let label_definitions = Array.map unify_kept lbl.lbl_all in\n Some {exp with exp_type = ty_exp}, label_definitions\n in\n let num_fields =\n match lbl_exp_list with [] -> assert false\n | (_, lbl,_)::_ -> Array.length lbl.lbl_all in\n if opt_sexp <> None && List.length lid_sexp_list = num_fields then\n Location.prerr_warning loc Warnings.Useless_record_with;\n let label_descriptions, representation =\n let (_, { lbl_all; lbl_repres }, _) = List.hd lbl_exp_list in\n lbl_all, lbl_repres\n in\n let fields =\n Array.map2 (fun descr def -> descr, def)\n label_descriptions label_definitions\n in\n re {\n exp_desc = Texp_record {\n fields; representation;\n extended_expression = opt_exp\n };\n exp_loc = loc; exp_extra = [];\n exp_type = instance ty_expected;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_field(srecord, lid) ->\n let (record, label, _) =\n type_label_access env srecord Env.Projection lid\n in\n let (_, ty_arg, ty_res) = instance_label false label in\n unify_exp env record ty_res;\n rue {\n exp_desc = Texp_field(record, lid, label);\n exp_loc = loc; exp_extra = [];\n exp_type = ty_arg;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_setfield(srecord, lid, snewval) ->\n let (record, label, expected_type) =\n type_label_access env srecord Env.Mutation lid in\n let ty_record =\n if expected_type = None then newvar () else record.exp_type in\n let (label_loc, label, newval) =\n type_label_exp false env loc ty_record (lid, label, snewval) in\n unify_exp env record ty_record;\n if label.lbl_mut = Immutable then\n raise(Error(loc, env, Label_not_mutable lid.txt));\n rue {\n exp_desc = Texp_setfield(record, label_loc, label, newval);\n exp_loc = loc; exp_extra = [];\n exp_type = instance Predef.type_unit;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_array(sargl) ->\n let ty = newgenvar() in\n let to_unify = Predef.type_array ty in\n with_explanation (fun () ->\n unify_exp_types loc env to_unify (generic_instance ty_expected));\n let argl =\n List.map (fun sarg -> type_expect env sarg (mk_expected ty)) sargl in\n re {\n exp_desc = Texp_array argl;\n exp_loc = loc; exp_extra = [];\n exp_type = instance ty_expected;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_ifthenelse(scond, sifso, sifnot) ->\n let cond = type_expect env scond\n (mk_expected ~explanation:If_conditional Predef.type_bool) in\n begin match sifnot with\n None ->\n let ifso = type_expect env sifso\n (mk_expected ~explanation:If_no_else_branch Predef.type_unit) in\n rue {\n exp_desc = Texp_ifthenelse(cond, ifso, None);\n exp_loc = loc; exp_extra = [];\n exp_type = ifso.exp_type;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Some sifnot ->\n let ifso = type_expect env sifso ty_expected_explained in\n let ifnot = type_expect env sifnot ty_expected_explained in\n (* Keep sharing *)\n unify_exp env ifnot ifso.exp_type;\n re {\n exp_desc = Texp_ifthenelse(cond, ifso, Some ifnot);\n exp_loc = loc; exp_extra = [];\n exp_type = ifso.exp_type;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n end\n | Pexp_sequence(sexp1, sexp2) ->\n let exp1 = type_statement ~explanation:Sequence_left_hand_side\n env sexp1 in\n let exp2 = type_expect env sexp2 ty_expected_explained in\n re {\n exp_desc = Texp_sequence(exp1, exp2);\n exp_loc = loc; exp_extra = [];\n exp_type = exp2.exp_type;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_while(scond, sbody) ->\n let cond = type_expect env scond\n (mk_expected ~explanation:While_loop_conditional Predef.type_bool) in\n let body = type_statement ~explanation:While_loop_body env sbody in\n rue {\n exp_desc = Texp_while(cond, body);\n exp_loc = loc; exp_extra = [];\n exp_type = instance Predef.type_unit;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_for(param, slow, shigh, dir, sbody) ->\n let low = type_expect env slow\n (mk_expected ~explanation:For_loop_start_index Predef.type_int) in\n let high = type_expect env shigh\n (mk_expected ~explanation:For_loop_stop_index Predef.type_int) in\n let id, new_env =\n match param.ppat_desc with\n | Ppat_any -> Ident.create_local \"_for\", env\n | Ppat_var {txt} ->\n Env.enter_value txt\n {val_type = instance Predef.type_int;\n val_attributes = [];\n val_kind = Val_reg;\n val_loc = loc;\n val_uid = Uid.mk ~current_unit:(Env.get_unit_name ());\n } env\n ~check:(fun s -> Warnings.Unused_for_index s)\n | _ ->\n raise (Error (param.ppat_loc, env, Invalid_for_loop_index))\n in\n let body = type_statement ~explanation:For_loop_body new_env sbody in\n rue {\n exp_desc = Texp_for(id, param, low, high, dir, body);\n exp_loc = loc; exp_extra = [];\n exp_type = instance Predef.type_unit;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_constraint (sarg, sty) ->\n (* Pretend separate = true, 1% slowdown for lablgtk *)\n begin_def ();\n let cty = Typetexp.transl_simple_type env false sty in\n let ty = cty.ctyp_type in\n end_def ();\n generalize_structure ty;\n let (arg, ty') = (type_argument env sarg ty (instance ty), instance ty) in\n rue {\n exp_desc = arg.exp_desc;\n exp_loc = arg.exp_loc;\n exp_type = ty';\n exp_attributes = arg.exp_attributes;\n exp_env = env;\n exp_extra =\n (Texp_constraint cty, loc, sexp.pexp_attributes) :: arg.exp_extra;\n }\n | Pexp_coerce(sarg, sty, sty') ->\n (* Pretend separate = true, 1% slowdown for lablgtk *)\n (* Also see PR#7199 for a problem with the following:\n let separate = !Clflags.principal || Env.has_local_constraints env in*)\n let (arg, ty',cty,cty') =\n match sty with\n | None ->\n let (cty', ty', force) =\n Typetexp.transl_simple_type_delayed env sty'\n in\n begin_def ();\n let arg = type_exp env sarg in\n end_def ();\n let tv = newvar () in\n let gen = generalizable (get_level tv) arg.exp_type in\n unify_var env tv arg.exp_type;\n begin match arg.exp_desc, !self_coercion, get_desc ty' with\n Texp_ident(_, _, {val_kind=Val_self _}), (path,r) :: _,\n Tconstr(path',_,_) when Path.same path path' ->\n (* prerr_endline \"self coercion\"; *)\n r := loc :: !r;\n force ()\n | _ when free_variables ~env arg.exp_type = []\n && free_variables ~env ty' = [] ->\n if not gen && (* first try a single coercion *)\n let snap = snapshot () in\n let ty, _b = enlarge_type env ty' in\n try\n force (); Ctype.unify env arg.exp_type ty; true\n with Unify _ ->\n backtrack snap; false\n then ()\n else begin try\n let force' = subtype env arg.exp_type ty' in\n force (); force' ();\n if not gen && !Clflags.principal then\n Location.prerr_warning loc\n (Warnings.Not_principal \"this ground coercion\");\n with Subtype err ->\n (* prerr_endline \"coercion failed\"; *)\n raise (Error(loc, env, Not_subtype err))\n end;\n | _ ->\n let ty, b = enlarge_type env ty' in\n force ();\n begin try Ctype.unify env arg.exp_type ty with Unify err ->\n let expanded = full_expand ~may_forget_scope:true env ty' in\n raise(Error(sarg.pexp_loc, env,\n Coercion_failure({ty = ty'; expanded}, err, b)))\n end\n end;\n (arg, ty', None, cty')\n | Some sty ->\n begin_def ();\n let (cty, ty, force) =\n Typetexp.transl_simple_type_delayed env sty\n and (cty', ty', force') =\n Typetexp.transl_simple_type_delayed env sty'\n in\n end_def ();\n generalize_structure ty;\n generalize_structure ty';\n begin try\n let force'' = subtype env (instance ty) (instance ty') in\n force (); force' (); force'' ()\n with Subtype err ->\n raise (Error(loc, env, Not_subtype err))\n end;\n (type_argument env sarg ty (instance ty),\n instance ty', Some cty, cty')\n in\n rue {\n exp_desc = arg.exp_desc;\n exp_loc = arg.exp_loc;\n exp_type = ty';\n exp_attributes = arg.exp_attributes;\n exp_env = env;\n exp_extra = (Texp_coerce (cty, cty'), loc, sexp.pexp_attributes) ::\n arg.exp_extra;\n }\n | Pexp_send (e, {txt=met}) ->\n if !Clflags.principal then begin_def ();\n let obj = type_exp env e in\n let (meth, typ) =\n match obj.exp_desc with\n | Texp_ident(_, _, {val_kind = Val_self(sign, meths, _, _)}) ->\n let id, typ =\n match meths with\n | Self_concrete meths ->\n let id =\n match Meths.find met meths with\n | id -> id\n | exception Not_found ->\n let valid_methods =\n Meths.fold (fun lab _ acc -> lab :: acc) meths []\n in\n raise (Error(e.pexp_loc, env,\n Undefined_self_method (met, valid_methods)))\n in\n let typ = Btype.method_type met sign in\n id, typ\n | Self_virtual meths_ref -> begin\n match Meths.find met !meths_ref with\n | id -> id, Btype.method_type met sign\n | exception Not_found ->\n let id = Ident.create_local met in\n let ty = newvar () in\n meths_ref := Meths.add met id !meths_ref;\n add_method env met Private Virtual ty sign;\n Location.prerr_warning loc\n (Warnings.Undeclared_virtual_method met);\n id, ty\n end\n in\n Tmeth_val id, typ\n | Texp_ident(_, _, {val_kind = Val_anc (sign, meths, cl_num)}) ->\n let id =\n match Meths.find met meths with\n | id -> id\n | exception Not_found ->\n let valid_methods =\n Meths.fold (fun lab _ acc -> lab :: acc) meths []\n in\n raise (Error(e.pexp_loc, env,\n Undefined_self_method (met, valid_methods)))\n in\n let typ = Btype.method_type met sign in\n let (self_path, _) =\n Env.find_value_by_name\n (Longident.Lident (\"self-\" ^ cl_num)) env\n in\n Tmeth_ancestor(id, self_path), typ\n | _ ->\n let ty =\n match filter_method env met obj.exp_type with\n | ty -> ty\n | exception Filter_method_failed err ->\n let error =\n match err with\n | Unification_error err ->\n Expr_type_clash(err, explanation, None)\n | Not_an_object ty ->\n Not_an_object(ty, explanation)\n | Not_a_method ->\n let valid_methods =\n match get_desc (expand_head env obj.exp_type) with\n | Tobject (fields, _) ->\n let (fields, _) = Ctype.flatten_fields fields in\n let collect_fields li (meth, meth_kind, _meth_ty) =\n if field_kind_repr meth_kind = Fpublic\n then meth::li else li\n in\n Some (List.fold_left collect_fields [] fields)\n | _ -> None\n in\n Undefined_method(obj.exp_type, met, valid_methods)\n in\n raise (Error(e.pexp_loc, env, error))\n in\n Tmeth_name met, ty\n in\n if !Clflags.principal then begin\n end_def ();\n generalize_structure typ;\n end;\n let typ =\n match get_desc typ with\n | Tpoly (ty, []) ->\n instance ty\n | Tpoly (ty, tl) ->\n if !Clflags.principal && get_level typ <> generic_level then\n Location.prerr_warning loc\n (Warnings.Not_principal \"this use of a polymorphic method\");\n snd (instance_poly false tl ty)\n | Tvar _ ->\n let ty' = newvar () in\n unify env (instance typ) (newty(Tpoly(ty',[])));\n (* if not !Clflags.nolabels then\n Location.prerr_warning loc (Warnings.Unknown_method met); *)\n ty'\n | _ ->\n assert false\n in\n rue {\n exp_desc = Texp_send(obj, meth);\n exp_loc = loc; exp_extra = [];\n exp_type = typ;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_new cl ->\n let (cl_path, cl_decl) = Env.lookup_class ~loc:cl.loc cl.txt env in\n begin match cl_decl.cty_new with\n None ->\n raise(Error(loc, env, Virtual_class cl.txt))\n | Some ty ->\n rue {\n exp_desc = Texp_new (cl_path, cl, cl_decl);\n exp_loc = loc; exp_extra = [];\n exp_type = instance ty;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n end\n | Pexp_setinstvar (lab, snewval) -> begin\n let (path, mut, cl_num, ty) =\n Env.lookup_instance_variable ~loc lab.txt env\n in\n match mut with\n | Mutable ->\n let newval =\n type_expect env snewval (mk_expected (instance ty))\n in\n let (path_self, _) =\n Env.find_value_by_name (Longident.Lident (\"self-\" ^ cl_num)) env\n in\n rue {\n exp_desc = Texp_setinstvar(path_self, path, lab, newval);\n exp_loc = loc; exp_extra = [];\n exp_type = instance Predef.type_unit;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | _ ->\n raise(Error(loc, env, Instance_variable_not_mutable lab.txt))\n end\n | Pexp_override lst ->\n let _ =\n List.fold_right\n (fun (lab, _) l ->\n if List.exists (fun l -> l.txt = lab.txt) l then\n raise(Error(loc, env,\n Value_multiply_overridden lab.txt));\n lab::l)\n lst\n [] in\n begin match\n try\n Env.find_value_by_name (Longident.Lident \"selfpat-*\") env,\n Env.find_value_by_name (Longident.Lident \"self-*\") env\n with Not_found ->\n raise(Error(loc, env, Outside_class))\n with\n (_, {val_type = self_ty; val_kind = Val_self (sign, _, vars, _)}),\n (path_self, _) ->\n let type_override (lab, snewval) =\n begin try\n let id = Vars.find lab.txt vars in\n let ty = Btype.instance_variable_type lab.txt sign in\n (id, lab, type_expect env snewval (mk_expected (instance ty)))\n with\n Not_found ->\n let vars = Vars.fold (fun var _ li -> var::li) vars [] in\n raise(Error(loc, env,\n Unbound_instance_variable (lab.txt, vars)))\n end\n in\n let modifs = List.map type_override lst in\n rue {\n exp_desc = Texp_override(path_self, modifs);\n exp_loc = loc; exp_extra = [];\n exp_type = self_ty;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | _ ->\n assert false\n end\n | Pexp_letmodule(name, smodl, sbody) ->\n let ty = newvar() in\n (* remember original level *)\n begin_def ();\n let context = Typetexp.narrow () in\n let modl, md_shape = !type_module env smodl in\n Mtype.lower_nongen (get_level ty) modl.mod_type;\n let pres =\n match modl.mod_type with\n | Mty_alias _ -> Mp_absent\n | _ -> Mp_present\n in\n let scope = create_scope () in\n let md =\n { md_type = modl.mod_type; md_attributes = []; md_loc = name.loc;\n md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()); }\n in\n let (id, new_env) =\n match name.txt with\n | None -> None, env\n | Some name ->\n let id, env =\n Env.enter_module_declaration ~scope ~shape:md_shape name pres md env\n in\n Some id, env\n in\n Typetexp.widen context;\n (* ideally, we should catch Expr_type_clash errors\n in type_expect triggered by escaping identifiers from the local module\n and refine them into Scoping_let_module errors\n *)\n let body = type_expect new_env sbody ty_expected_explained in\n (* go back to original level *)\n end_def ();\n Ctype.unify_var new_env ty body.exp_type;\n re {\n exp_desc = Texp_letmodule(id, name, pres, modl, body);\n exp_loc = loc; exp_extra = [];\n exp_type = ty;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_letexception(cd, sbody) ->\n let (cd, newenv) = Typedecl.transl_exception env cd in\n let body = type_expect newenv sbody ty_expected_explained in\n re {\n exp_desc = Texp_letexception(cd, body);\n exp_loc = loc; exp_extra = [];\n exp_type = body.exp_type;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n\n | Pexp_assert (e) ->\n let cond = type_expect env e\n (mk_expected ~explanation:Assert_condition Predef.type_bool) in\n let exp_type =\n match cond.exp_desc with\n | Texp_construct(_, {cstr_name=\"false\"}, _) ->\n instance ty_expected\n | _ ->\n instance Predef.type_unit\n in\n rue {\n exp_desc = Texp_assert cond;\n exp_loc = loc; exp_extra = [];\n exp_type;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env;\n }\n | Pexp_lazy e ->\n let ty = newgenvar () in\n let to_unify = Predef.type_lazy_t ty in\n with_explanation (fun () ->\n unify_exp_types loc env to_unify (generic_instance ty_expected));\n let arg = type_expect env e (mk_expected ty) in\n re {\n exp_desc = Texp_lazy arg;\n exp_loc = loc; exp_extra = [];\n exp_type = instance ty_expected;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env;\n }\n | Pexp_object s ->\n let desc, meths = !type_object env loc s in\n rue {\n exp_desc = Texp_object (desc, meths);\n exp_loc = loc; exp_extra = [];\n exp_type = desc.cstr_type.csig_self;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env;\n }\n | Pexp_poly(sbody, sty) ->\n if !Clflags.principal then begin_def ();\n let ty, cty =\n match sty with None -> ty_expected, None\n | Some sty ->\n let sty = Ast_helper.Typ.force_poly sty in\n let cty = Typetexp.transl_simple_type env false sty in\n cty.ctyp_type, Some cty\n in\n if !Clflags.principal then begin\n end_def ();\n generalize_structure ty\n end;\n if sty <> None then\n with_explanation (fun () ->\n unify_exp_types loc env (instance ty) (instance ty_expected));\n let exp =\n match get_desc (expand_head env ty) with\n Tpoly (ty', []) ->\n let exp = type_expect env sbody (mk_expected ty') in\n { exp with exp_type = instance ty }\n | Tpoly (ty', tl) ->\n (* One more level to generalize locally *)\n begin_def ();\n if !Clflags.principal then begin_def ();\n let vars, ty'' = instance_poly true tl ty' in\n if !Clflags.principal then begin\n end_def ();\n generalize_structure ty''\n end;\n let exp = type_expect env sbody (mk_expected ty'') in\n end_def ();\n generalize_and_check_univars env \"method\" exp ty_expected vars;\n { exp with exp_type = instance ty }\n | Tvar _ ->\n let exp = type_exp env sbody in\n let exp = {exp with exp_type = newty (Tpoly (exp.exp_type, []))} in\n unify_exp env exp ty;\n exp\n | _ -> assert false\n in\n re { exp with exp_extra =\n (Texp_poly cty, loc, sexp.pexp_attributes) :: exp.exp_extra }\n | Pexp_newtype({txt=name}, sbody) ->\n let ty =\n if Typetexp.valid_tyvar_name name then\n newvar ~name ()\n else\n newvar ()\n in\n (* remember original level *)\n begin_def ();\n (* Create a fake abstract type declaration for name. *)\n let decl = new_local_type ~loc () in\n let scope = create_scope () in\n let (id, new_env) = Env.enter_type ~scope name decl env in\n\n let body = type_exp new_env sbody in\n (* Replace every instance of this type constructor in the resulting\n type. *)\n let seen = Hashtbl.create 8 in\n let rec replace t =\n if Hashtbl.mem seen (get_id t) then ()\n else begin\n Hashtbl.add seen (get_id t) ();\n match get_desc t with\n | Tconstr (Path.Pident id', _, _) when id == id' -> link_type t ty\n | _ -> Btype.iter_type_expr replace t\n end\n in\n let ety = Subst.type_expr Subst.identity body.exp_type in\n replace ety;\n (* back to original level *)\n end_def ();\n (* lower the levels of the result type *)\n (* unify_var env ty ety; *)\n\n (* non-expansive if the body is non-expansive, so we don't introduce\n any new extra node in the typed AST. *)\n rue { body with exp_loc = loc; exp_type = ety;\n exp_extra =\n (Texp_newtype name, loc, sexp.pexp_attributes) :: body.exp_extra }\n | Pexp_pack m ->\n let (p, fl) =\n match get_desc (Ctype.expand_head env (instance ty_expected)) with\n Tpackage (p, fl) ->\n if !Clflags.principal &&\n get_level (Ctype.expand_head env ty_expected)\n < Btype.generic_level\n then\n Location.prerr_warning loc\n (Warnings.Not_principal \"this module packing\");\n (p, fl)\n | Tvar _ ->\n raise (Error (loc, env, Cannot_infer_signature))\n | _ ->\n raise (Error (loc, env, Not_a_packed_module ty_expected))\n in\n let (modl, fl') = !type_package env m p fl in\n rue {\n exp_desc = Texp_pack modl;\n exp_loc = loc; exp_extra = [];\n exp_type = newty (Tpackage (p, fl'));\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | Pexp_open (od, e) ->\n let tv = newvar () in\n let (od, _, newenv) = !type_open_decl env od in\n let exp = type_expect newenv e ty_expected_explained in\n (* Force the return type to be well-formed in the original\n environment. *)\n unify_var newenv tv exp.exp_type;\n re {\n exp_desc = Texp_open (od, exp);\n exp_type = exp.exp_type;\n exp_loc = loc;\n exp_extra = [];\n exp_attributes = sexp.pexp_attributes;\n exp_env = env;\n }\n | Pexp_letop{ let_ = slet; ands = sands; body = sbody } ->\n let rec loop spat_acc ty_acc sands =\n match sands with\n | [] -> spat_acc, ty_acc\n | { pbop_pat = spat; _} :: rest ->\n let ty = newvar () in\n let loc = { slet.pbop_op.loc with Location.loc_ghost = true } in\n let spat_acc = Ast_helper.Pat.tuple ~loc [spat_acc; spat] in\n let ty_acc = newty (Ttuple [ty_acc; ty]) in\n loop spat_acc ty_acc rest\n in\n if !Clflags.principal then begin_def ();\n let let_loc = slet.pbop_op.loc in\n let op_path, op_desc = type_binding_op_ident env slet.pbop_op in\n let op_type = instance op_desc.val_type in\n let spat_params, ty_params = loop slet.pbop_pat (newvar ()) sands in\n let ty_func_result = newvar () in\n let ty_func =\n newty (Tarrow(Nolabel, ty_params, ty_func_result, commu_ok)) in\n let ty_result = newvar () in\n let ty_andops = newvar () in\n let ty_op =\n newty (Tarrow(Nolabel, ty_andops,\n newty (Tarrow(Nolabel, ty_func, ty_result, commu_ok)), commu_ok))\n in\n begin try\n unify env op_type ty_op\n with Unify err ->\n raise(Error(let_loc, env, Letop_type_clash(slet.pbop_op.txt, err)))\n end;\n if !Clflags.principal then begin\n end_def ();\n generalize_structure ty_andops;\n generalize_structure ty_params;\n generalize_structure ty_func_result;\n generalize_structure ty_result\n end;\n let exp, ands = type_andops env slet.pbop_exp sands ty_andops in\n let scase = Ast_helper.Exp.case spat_params sbody in\n let cases, partial =\n type_cases Value env\n ty_params (mk_expected ty_func_result) true loc [scase]\n in\n let body =\n match cases with\n | [case] -> case\n | _ -> assert false\n in\n let param = name_cases \"param\" cases in\n let let_ =\n { bop_op_name = slet.pbop_op;\n bop_op_path = op_path;\n bop_op_val = op_desc;\n bop_op_type = op_type;\n bop_exp = exp;\n bop_loc = slet.pbop_loc; }\n in\n let desc =\n Texp_letop{let_; ands; param; body; partial}\n in\n rue { exp_desc = desc;\n exp_loc = sexp.pexp_loc;\n exp_extra = [];\n exp_type = instance ty_result;\n exp_env = env;\n exp_attributes = sexp.pexp_attributes; }\n\n | Pexp_extension ({ txt = (\"ocaml.extension_constructor\"\n |\"extension_constructor\"); _ },\n payload) ->\n begin match payload with\n | PStr [ { pstr_desc =\n Pstr_eval ({ pexp_desc = Pexp_construct (lid, None); _ }, _)\n } ] ->\n let path =\n let cd =\n Env.lookup_constructor Env.Positive ~loc:lid.loc lid.txt env\n in\n match cd.cstr_tag with\n | Cstr_extension (path, _) -> path\n | _ -> raise (Error (lid.loc, env, Not_an_extension_constructor))\n in\n rue {\n exp_desc = Texp_extension_constructor (lid, path);\n exp_loc = loc; exp_extra = [];\n exp_type = instance Predef.type_extension_constructor;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n | _ ->\n raise (Error (loc, env, Invalid_extension_constructor_payload))\n end\n | Pexp_extension ext ->\n raise (Error_forward (Builtin_attributes.error_of_extension ext))\n\n | Pexp_unreachable ->\n re { exp_desc = Texp_unreachable;\n exp_loc = loc; exp_extra = [];\n exp_type = instance ty_expected;\n exp_attributes = sexp.pexp_attributes;\n exp_env = env }\n\nand type_ident env ?(recarg=Rejected) lid =\n let (path, desc) = Env.lookup_value ~loc:lid.loc lid.txt env in\n let is_recarg =\n match get_desc desc.val_type with\n | Tconstr(p, _, _) -> Path.is_constructor_typath p\n | _ -> false\n in\n begin match is_recarg, recarg, get_desc desc.val_type with\n | _, Allowed, _\n | true, Required, _\n | false, Rejected, _ -> ()\n | true, Rejected, _\n | false, Required, (Tvar _ | Tconstr _) ->\n raise (Error (lid.loc, env, Inlined_record_escape))\n | false, Required, _ -> () (* will fail later *)\n end;\n path, desc\n\nand type_binding_op_ident env s =\n let loc = s.loc in\n let lid = Location.mkloc (Longident.Lident s.txt) loc in\n let path, desc = type_ident env lid in\n let path =\n match desc.val_kind with\n | Val_ivar _ ->\n fatal_error \"Illegal name for instance variable\"\n | Val_self (_, _, _, cl_num) ->\n let path, _ =\n Env.find_value_by_name (Longident.Lident (\"self-\" ^ cl_num)) env\n in\n path\n | _ -> path\n in\n path, desc\n\nand type_function ?(in_function : (Location.t * type_expr) option)\n loc attrs env ty_expected_explained arg_label caselist =\n let { ty = ty_expected; explanation } = ty_expected_explained in\n let (loc_fun, ty_fun) =\n match in_function with Some p -> p\n | None -> (loc, instance ty_expected)\n in\n let separate = !Clflags.principal || Env.has_local_constraints env in\n if separate then begin_def ();\n let (ty_arg, ty_res) =\n try filter_arrow env (instance ty_expected) arg_label\n with Filter_arrow_failed err ->\n let err = match err with\n | Unification_error unif_err ->\n Expr_type_clash(unif_err, explanation, None)\n | Label_mismatch { got; expected; expected_type} ->\n Abstract_wrong_label { got; expected; expected_type; explanation }\n | Not_a_function -> begin\n match in_function with\n | Some _ -> Too_many_arguments(ty_fun, explanation)\n | None -> Not_a_function(ty_fun, explanation)\n end\n in\n raise (Error(loc_fun, env, err))\n in\n let ty_arg =\n if is_optional arg_label then\n let tv = newvar() in\n begin\n try unify env ty_arg (type_option tv)\n with Unify _ -> assert false\n end;\n type_option tv\n else ty_arg\n in\n if separate then begin\n end_def ();\n generalize_structure ty_arg;\n generalize_structure ty_res\n end;\n let cases, partial =\n type_cases Value ~in_function:(loc_fun,ty_fun) env\n ty_arg (mk_expected ty_res) true loc caselist in\n let not_nolabel_function ty =\n let ls, tvar = list_labels env ty in\n List.for_all ((<>) Nolabel) ls && not tvar\n in\n if is_optional arg_label && not_nolabel_function ty_res then\n Location.prerr_warning (List.hd cases).c_lhs.pat_loc\n Warnings.Unerasable_optional_argument;\n let param = name_cases \"param\" cases in\n re {\n exp_desc = Texp_function { arg_label; param; cases; partial; };\n exp_loc = loc; exp_extra = [];\n exp_type =\n instance (newgenty (Tarrow(arg_label, ty_arg, ty_res, commu_ok)));\n exp_attributes = attrs;\n exp_env = env }\n\n\nand type_label_access env srecord usage lid =\n if !Clflags.principal then begin_def ();\n let record = type_exp ~recarg:Allowed env srecord in\n if !Clflags.principal then begin\n end_def ();\n generalize_structure record.exp_type\n end;\n let ty_exp = record.exp_type in\n let expected_type =\n match extract_concrete_record env ty_exp with\n | Record_type(p0, p, _) ->\n Some(p0, p, is_principal ty_exp)\n | Maybe_a_record_type -> None\n | Not_a_record_type ->\n let error = Expr_not_a_record_type ty_exp in\n raise (Error (record.exp_loc, env, error))\n in\n let labels = Env.lookup_all_labels ~loc:lid.loc usage lid.txt env in\n let label =\n wrap_disambiguate \"This expression has\" (mk_expected ty_exp)\n (Label.disambiguate usage lid env expected_type) labels in\n (record, label, expected_type)\n\n(* Typing format strings for printing or reading.\n These formats are used by functions in modules Printf, Format, and Scanf.\n (Handling of * modifiers contributed by Thorsten Ohl.) *)\n\nand type_format loc str env =\n let loc = {loc with Location.loc_ghost = true} in\n try\n CamlinternalFormatBasics.(CamlinternalFormat.(\n let mk_exp_loc pexp_desc = {\n pexp_desc = pexp_desc;\n pexp_loc = loc;\n pexp_loc_stack = [];\n pexp_attributes = [];\n } and mk_lid_loc lid = {\n txt = lid;\n loc = loc;\n } in\n let mk_constr name args =\n let lid = Longident.(Ldot(Lident \"CamlinternalFormatBasics\", name)) in\n let arg = match args with\n | [] -> None\n | [ e ] -> Some e\n | _ :: _ :: _ -> Some (mk_exp_loc (Pexp_tuple args)) in\n mk_exp_loc (Pexp_construct (mk_lid_loc lid, arg)) in\n let mk_cst cst = mk_exp_loc (Pexp_constant cst) in\n let mk_int n = mk_cst (Pconst_integer (Int.to_string n, None))\n and mk_string str = mk_cst (Pconst_string (str, loc, None))\n and mk_char chr = mk_cst (Pconst_char chr) in\n let rec mk_formatting_lit fmting = match fmting with\n | Close_box ->\n mk_constr \"Close_box\" []\n | Close_tag ->\n mk_constr \"Close_tag\" []\n | Break (org, ns, ni) ->\n mk_constr \"Break\" [ mk_string org; mk_int ns; mk_int ni ]\n | FFlush ->\n mk_constr \"FFlush\" []\n | Force_newline ->\n mk_constr \"Force_newline\" []\n | Flush_newline ->\n mk_constr \"Flush_newline\" []\n | Magic_size (org, sz) ->\n mk_constr \"Magic_size\" [ mk_string org; mk_int sz ]\n | Escaped_at ->\n mk_constr \"Escaped_at\" []\n | Escaped_percent ->\n mk_constr \"Escaped_percent\" []\n | Scan_indic c ->\n mk_constr \"Scan_indic\" [ mk_char c ]\n and mk_formatting_gen : type a b c d e f .\n (a, b, c, d, e, f) formatting_gen -> Parsetree.expression =\n fun fmting -> match fmting with\n | Open_tag (Format (fmt', str')) ->\n mk_constr \"Open_tag\" [ mk_format fmt' str' ]\n | Open_box (Format (fmt', str')) ->\n mk_constr \"Open_box\" [ mk_format fmt' str' ]\n and mk_format : type a b c d e f .\n (a, b, c, d, e, f) CamlinternalFormatBasics.fmt -> string ->\n Parsetree.expression = fun fmt str ->\n mk_constr \"Format\" [ mk_fmt fmt; mk_string str ]\n and mk_side side = match side with\n | Left -> mk_constr \"Left\" []\n | Right -> mk_constr \"Right\" []\n | Zeros -> mk_constr \"Zeros\" []\n and mk_iconv iconv = match iconv with\n | Int_d -> mk_constr \"Int_d\" [] | Int_pd -> mk_constr \"Int_pd\" []\n | Int_sd -> mk_constr \"Int_sd\" [] | Int_i -> mk_constr \"Int_i\" []\n | Int_pi -> mk_constr \"Int_pi\" [] | Int_si -> mk_constr \"Int_si\" []\n | Int_x -> mk_constr \"Int_x\" [] | Int_Cx -> mk_constr \"Int_Cx\" []\n | Int_X -> mk_constr \"Int_X\" [] | Int_CX -> mk_constr \"Int_CX\" []\n | Int_o -> mk_constr \"Int_o\" [] | Int_Co -> mk_constr \"Int_Co\" []\n | Int_u -> mk_constr \"Int_u\" [] | Int_Cd -> mk_constr \"Int_Cd\" []\n | Int_Ci -> mk_constr \"Int_Ci\" [] | Int_Cu -> mk_constr \"Int_Cu\" []\n and mk_fconv fconv =\n let flag = match fst fconv with\n | Float_flag_ -> mk_constr \"Float_flag_\" []\n | Float_flag_p -> mk_constr \"Float_flag_p\" []\n | Float_flag_s -> mk_constr \"Float_flag_s\" [] in\n let kind = match snd fconv with\n | Float_f -> mk_constr \"Float_f\" []\n | Float_e -> mk_constr \"Float_e\" []\n | Float_E -> mk_constr \"Float_E\" []\n | Float_g -> mk_constr \"Float_g\" []\n | Float_G -> mk_constr \"Float_G\" []\n | Float_h -> mk_constr \"Float_h\" []\n | Float_H -> mk_constr \"Float_H\" []\n | Float_F -> mk_constr \"Float_F\" []\n | Float_CF -> mk_constr \"Float_CF\" [] in\n mk_exp_loc (Pexp_tuple [flag; kind])\n and mk_counter cnt = match cnt with\n | Line_counter -> mk_constr \"Line_counter\" []\n | Char_counter -> mk_constr \"Char_counter\" []\n | Token_counter -> mk_constr \"Token_counter\" []\n and mk_int_opt n_opt = match n_opt with\n | None ->\n let lid_loc = mk_lid_loc (Longident.Lident \"None\") in\n mk_exp_loc (Pexp_construct (lid_loc, None))\n | Some n ->\n let lid_loc = mk_lid_loc (Longident.Lident \"Some\") in\n mk_exp_loc (Pexp_construct (lid_loc, Some (mk_int n)))\n and mk_fmtty : type a b c d e f g h i j k l .\n (a, b, c, d, e, f, g, h, i, j, k, l) fmtty_rel -> Parsetree.expression\n =\n fun fmtty -> match fmtty with\n | Char_ty rest -> mk_constr \"Char_ty\" [ mk_fmtty rest ]\n | String_ty rest -> mk_constr \"String_ty\" [ mk_fmtty rest ]\n | Int_ty rest -> mk_constr \"Int_ty\" [ mk_fmtty rest ]\n | Int32_ty rest -> mk_constr \"Int32_ty\" [ mk_fmtty rest ]\n | Nativeint_ty rest -> mk_constr \"Nativeint_ty\" [ mk_fmtty rest ]\n | Int64_ty rest -> mk_constr \"Int64_ty\" [ mk_fmtty rest ]\n | Float_ty rest -> mk_constr \"Float_ty\" [ mk_fmtty rest ]\n | Bool_ty rest -> mk_constr \"Bool_ty\" [ mk_fmtty rest ]\n | Alpha_ty rest -> mk_constr \"Alpha_ty\" [ mk_fmtty rest ]\n | Theta_ty rest -> mk_constr \"Theta_ty\" [ mk_fmtty rest ]\n | Any_ty rest -> mk_constr \"Any_ty\" [ mk_fmtty rest ]\n | Reader_ty rest -> mk_constr \"Reader_ty\" [ mk_fmtty rest ]\n | Ignored_reader_ty rest ->\n mk_constr \"Ignored_reader_ty\" [ mk_fmtty rest ]\n | Format_arg_ty (sub_fmtty, rest) ->\n mk_constr \"Format_arg_ty\" [ mk_fmtty sub_fmtty; mk_fmtty rest ]\n | Format_subst_ty (sub_fmtty1, sub_fmtty2, rest) ->\n mk_constr \"Format_subst_ty\"\n [ mk_fmtty sub_fmtty1; mk_fmtty sub_fmtty2; mk_fmtty rest ]\n | End_of_fmtty -> mk_constr \"End_of_fmtty\" []\n and mk_ignored : type a b c d e f .\n (a, b, c, d, e, f) ignored -> Parsetree.expression =\n fun ign -> match ign with\n | Ignored_char ->\n mk_constr \"Ignored_char\" []\n | Ignored_caml_char ->\n mk_constr \"Ignored_caml_char\" []\n | Ignored_string pad_opt ->\n mk_constr \"Ignored_string\" [ mk_int_opt pad_opt ]\n | Ignored_caml_string pad_opt ->\n mk_constr \"Ignored_caml_string\" [ mk_int_opt pad_opt ]\n | Ignored_int (iconv, pad_opt) ->\n mk_constr \"Ignored_int\" [ mk_iconv iconv; mk_int_opt pad_opt ]\n | Ignored_int32 (iconv, pad_opt) ->\n mk_constr \"Ignored_int32\" [ mk_iconv iconv; mk_int_opt pad_opt ]\n | Ignored_nativeint (iconv, pad_opt) ->\n mk_constr \"Ignored_nativeint\" [ mk_iconv iconv; mk_int_opt pad_opt ]\n | Ignored_int64 (iconv, pad_opt) ->\n mk_constr \"Ignored_int64\" [ mk_iconv iconv; mk_int_opt pad_opt ]\n | Ignored_float (pad_opt, prec_opt) ->\n mk_constr \"Ignored_float\" [ mk_int_opt pad_opt; mk_int_opt prec_opt ]\n | Ignored_bool pad_opt ->\n mk_constr \"Ignored_bool\" [ mk_int_opt pad_opt ]\n | Ignored_format_arg (pad_opt, fmtty) ->\n mk_constr \"Ignored_format_arg\" [ mk_int_opt pad_opt; mk_fmtty fmtty ]\n | Ignored_format_subst (pad_opt, fmtty) ->\n mk_constr \"Ignored_format_subst\" [\n mk_int_opt pad_opt; mk_fmtty fmtty ]\n | Ignored_reader ->\n mk_constr \"Ignored_reader\" []\n | Ignored_scan_char_set (width_opt, char_set) ->\n mk_constr \"Ignored_scan_char_set\" [\n mk_int_opt width_opt; mk_string char_set ]\n | Ignored_scan_get_counter counter ->\n mk_constr \"Ignored_scan_get_counter\" [\n mk_counter counter\n ]\n | Ignored_scan_next_char ->\n mk_constr \"Ignored_scan_next_char\" []\n and mk_padding : type x y . (x, y) padding -> Parsetree.expression =\n fun pad -> match pad with\n | No_padding -> mk_constr \"No_padding\" []\n | Lit_padding (s, w) -> mk_constr \"Lit_padding\" [ mk_side s; mk_int w ]\n | Arg_padding s -> mk_constr \"Arg_padding\" [ mk_side s ]\n and mk_precision : type x y . (x, y) precision -> Parsetree.expression =\n fun prec -> match prec with\n | No_precision -> mk_constr \"No_precision\" []\n | Lit_precision w -> mk_constr \"Lit_precision\" [ mk_int w ]\n | Arg_precision -> mk_constr \"Arg_precision\" []\n and mk_fmt : type a b c d e f .\n (a, b, c, d, e, f) fmt -> Parsetree.expression =\n fun fmt -> match fmt with\n | Char rest ->\n mk_constr \"Char\" [ mk_fmt rest ]\n | Caml_char rest ->\n mk_constr \"Caml_char\" [ mk_fmt rest ]\n | String (pad, rest) ->\n mk_constr \"String\" [ mk_padding pad; mk_fmt rest ]\n | Caml_string (pad, rest) ->\n mk_constr \"Caml_string\" [ mk_padding pad; mk_fmt rest ]\n | Int (iconv, pad, prec, rest) ->\n mk_constr \"Int\" [\n mk_iconv iconv; mk_padding pad; mk_precision prec; mk_fmt rest ]\n | Int32 (iconv, pad, prec, rest) ->\n mk_constr \"Int32\" [\n mk_iconv iconv; mk_padding pad; mk_precision prec; mk_fmt rest ]\n | Nativeint (iconv, pad, prec, rest) ->\n mk_constr \"Nativeint\" [\n mk_iconv iconv; mk_padding pad; mk_precision prec; mk_fmt rest ]\n | Int64 (iconv, pad, prec, rest) ->\n mk_constr \"Int64\" [\n mk_iconv iconv; mk_padding pad; mk_precision prec; mk_fmt rest ]\n | Float (fconv, pad, prec, rest) ->\n mk_constr \"Float\" [\n mk_fconv fconv; mk_padding pad; mk_precision prec; mk_fmt rest ]\n | Bool (pad, rest) ->\n mk_constr \"Bool\" [ mk_padding pad; mk_fmt rest ]\n | Flush rest ->\n mk_constr \"Flush\" [ mk_fmt rest ]\n | String_literal (s, rest) ->\n mk_constr \"String_literal\" [ mk_string s; mk_fmt rest ]\n | Char_literal (c, rest) ->\n mk_constr \"Char_literal\" [ mk_char c; mk_fmt rest ]\n | Format_arg (pad_opt, fmtty, rest) ->\n mk_constr \"Format_arg\" [\n mk_int_opt pad_opt; mk_fmtty fmtty; mk_fmt rest ]\n | Format_subst (pad_opt, fmtty, rest) ->\n mk_constr \"Format_subst\" [\n mk_int_opt pad_opt; mk_fmtty fmtty; mk_fmt rest ]\n | Alpha rest ->\n mk_constr \"Alpha\" [ mk_fmt rest ]\n | Theta rest ->\n mk_constr \"Theta\" [ mk_fmt rest ]\n | Formatting_lit (fmting, rest) ->\n mk_constr \"Formatting_lit\" [ mk_formatting_lit fmting; mk_fmt rest ]\n | Formatting_gen (fmting, rest) ->\n mk_constr \"Formatting_gen\" [ mk_formatting_gen fmting; mk_fmt rest ]\n | Reader rest ->\n mk_constr \"Reader\" [ mk_fmt rest ]\n | Scan_char_set (width_opt, char_set, rest) ->\n mk_constr \"Scan_char_set\" [\n mk_int_opt width_opt; mk_string char_set; mk_fmt rest ]\n | Scan_get_counter (cnt, rest) ->\n mk_constr \"Scan_get_counter\" [ mk_counter cnt; mk_fmt rest ]\n | Scan_next_char rest ->\n mk_constr \"Scan_next_char\" [ mk_fmt rest ]\n | Ignored_param (ign, rest) ->\n mk_constr \"Ignored_param\" [ mk_ignored ign; mk_fmt rest ]\n | End_of_format ->\n mk_constr \"End_of_format\" []\n | Custom _ ->\n (* Custom formatters have no syntax so they will never appear\n in formats parsed from strings. *)\n assert false\n in\n let legacy_behavior = not !Clflags.strict_formats in\n let Fmt_EBB fmt = fmt_ebb_of_string ~legacy_behavior str in\n mk_constr \"Format\" [ mk_fmt fmt; mk_string str ]\n ))\n with Failure msg ->\n raise (Error (loc, env, Invalid_format msg))\n\nand type_label_exp create env loc ty_expected\n (lid, label, sarg) =\n (* Here also ty_expected may be at generic_level *)\n begin_def ();\n let separate = !Clflags.principal || Env.has_local_constraints env in\n if separate then (begin_def (); begin_def ());\n let (vars, ty_arg, ty_res) = instance_label true label in\n if separate then begin\n end_def ();\n (* Generalize label information *)\n generalize_structure ty_arg;\n generalize_structure ty_res\n end;\n begin try\n unify env (instance ty_res) (instance ty_expected)\n with Unify err ->\n raise (Error(lid.loc, env, Label_mismatch(lid.txt, err)))\n end;\n (* Instantiate so that we can generalize internal nodes *)\n let ty_arg = instance ty_arg in\n if separate then begin\n end_def ();\n (* Generalize information merged from ty_expected *)\n generalize_structure ty_arg\n end;\n if label.lbl_private = Private then\n if create then\n raise (Error(loc, env, Private_type ty_expected))\n else\n raise (Error(lid.loc, env, Private_label(lid.txt, ty_expected)));\n let arg =\n let snap = if vars = [] then None else Some (Btype.snapshot ()) in\n let arg = type_argument env sarg ty_arg (instance ty_arg) in\n end_def ();\n try\n if (vars = []) then arg\n else begin\n if maybe_expansive arg then\n lower_contravariant env arg.exp_type;\n generalize_and_check_univars env \"field value\" arg label.lbl_arg vars;\n {arg with exp_type = instance arg.exp_type}\n end\n with exn when maybe_expansive arg -> try\n (* Try to retype without propagating ty_arg, cf PR#4862 *)\n Option.iter Btype.backtrack snap;\n begin_def ();\n let arg = type_exp env sarg in\n end_def ();\n lower_contravariant env arg.exp_type;\n begin_def ();\n let arg = {arg with exp_type = instance arg.exp_type} in\n unify_exp env arg (instance ty_arg);\n end_def ();\n generalize_and_check_univars env \"field value\" arg label.lbl_arg vars;\n {arg with exp_type = instance arg.exp_type}\n with Error (_, _, Less_general _) as e -> raise e\n | _ -> raise exn (* In case of failure return the first error *)\n in\n (lid, label, arg)\n\nand type_argument ?explanation ?recarg env sarg ty_expected' ty_expected =\n (* ty_expected' may be generic *)\n let no_labels ty =\n let ls, tvar = list_labels env ty in\n not tvar && List.for_all ((=) Nolabel) ls\n in\n let may_coerce =\n if not (is_inferred sarg) then None else\n let work () =\n let te = expand_head env ty_expected' in\n match get_desc te with\n Tarrow(Nolabel,_,ty_res0,_) ->\n Some (no_labels ty_res0, get_level te)\n | _ -> None\n in\n (* Need to be careful not to expand local constraints here *)\n if Env.has_local_constraints env then\n let snap = Btype.snapshot () in\n try_finally ~always:(fun () -> Btype.backtrack snap) work\n else work ()\n in\n match may_coerce with\n Some (safe_expect, lv) ->\n (* apply optional arguments when expected type is \"\" *)\n (* we must be very careful about not breaking the semantics *)\n if !Clflags.principal then begin_def ();\n let texp = type_exp env sarg in\n if !Clflags.principal then begin\n end_def ();\n generalize_structure texp.exp_type\n end;\n let rec make_args args ty_fun =\n match get_desc (expand_head env ty_fun) with\n | Tarrow (l,ty_arg,ty_fun,_) when is_optional l ->\n let ty = option_none env (instance ty_arg) sarg.pexp_loc in\n make_args ((l, Some ty) :: args) ty_fun\n | Tarrow (l,_,ty_res',_) when l = Nolabel || !Clflags.classic ->\n List.rev args, ty_fun, no_labels ty_res'\n | Tvar _ -> List.rev args, ty_fun, false\n | _ -> [], texp.exp_type, false\n in\n let args, ty_fun', simple_res = make_args [] texp.exp_type\n and texp = {texp with exp_type = instance texp.exp_type} in\n if not (simple_res || safe_expect) then begin\n unify_exp env texp ty_expected;\n texp\n end else begin\n let warn = !Clflags.principal &&\n (lv <> generic_level || get_level ty_fun' <> generic_level)\n and ty_fun = instance ty_fun' in\n let ty_arg, ty_res =\n match get_desc (expand_head env ty_expected') with\n Tarrow(Nolabel,ty_arg,ty_res,_) -> ty_arg, ty_res\n | _ -> assert false\n in\n unify_exp env {texp with exp_type = ty_fun} ty_expected;\n if args = [] then texp else\n (* eta-expand to avoid side effects *)\n let var_pair name ty =\n let id = Ident.create_local name in\n let desc =\n { val_type = ty; val_kind = Val_reg;\n val_attributes = [];\n val_loc = Location.none;\n val_uid = Uid.mk ~current_unit:(Env.get_unit_name ());\n }\n in\n let exp_env = Env.add_value id desc env in\n {pat_desc = Tpat_var (id, mknoloc name); pat_type = ty;pat_extra=[];\n pat_attributes = [];\n pat_loc = Location.none; pat_env = env},\n {exp_type = ty; exp_loc = Location.none; exp_env = exp_env;\n exp_extra = []; exp_attributes = [];\n exp_desc =\n Texp_ident(Path.Pident id, mknoloc (Longident.Lident name), desc)}\n in\n let eta_pat, eta_var = var_pair \"eta\" ty_arg in\n let func texp =\n let e =\n {texp with exp_type = ty_res; exp_desc =\n Texp_apply\n (texp,\n args @ [Nolabel, Some eta_var])}\n in\n let cases = [case eta_pat e] in\n let param = name_cases \"param\" cases in\n { texp with exp_type = ty_fun; exp_desc =\n Texp_function { arg_label = Nolabel; param; cases;\n partial = Total; } }\n in\n Location.prerr_warning texp.exp_loc\n (Warnings.Eliminated_optional_arguments\n (List.map (fun (l, _) -> Printtyp.string_of_label l) args));\n if warn then Location.prerr_warning texp.exp_loc\n (Warnings.Non_principal_labels \"eliminated optional argument\");\n (* let-expand to have side effects *)\n let let_pat, let_var = var_pair \"arg\" texp.exp_type in\n re { texp with exp_type = ty_fun; exp_desc =\n Texp_let (Nonrecursive,\n [{vb_pat=let_pat; vb_expr=texp; vb_attributes=[];\n vb_loc=Location.none;\n }],\n func let_var) }\n end\n | None ->\n let texp = type_expect ?recarg env sarg\n (mk_expected ?explanation ty_expected') in\n unify_exp env texp ty_expected;\n texp\n\nand type_application env funct sargs =\n (* funct.exp_type may be generic *)\n let result_type omitted ty_fun =\n List.fold_left\n (fun ty_fun (l,ty,lv) -> newty2 ~level:lv (Tarrow(l,ty,ty_fun,commu_ok)))\n ty_fun omitted\n in\n let has_label l ty_fun =\n let ls, tvar = list_labels env ty_fun in\n tvar || List.mem l ls\n in\n let eliminated_optional_arguments = ref [] in\n let omitted_parameters = ref [] in\n let type_unknown_arg (ty_fun, typed_args) (lbl, sarg) =\n let (ty_arg, ty_res) =\n let ty_fun = expand_head env ty_fun in\n match get_desc ty_fun with\n | Tvar _ ->\n let t1 = newvar () and t2 = newvar () in\n if get_level ty_fun >= get_level t1 &&\n not (is_prim ~name:\"%identity\" funct)\n then\n Location.prerr_warning sarg.pexp_loc\n Warnings.Ignored_extra_argument;\n unify env ty_fun (newty (Tarrow(lbl,t1,t2,commu_var ())));\n (t1, t2)\n | Tarrow (l,t1,t2,_) when l = lbl\n || !Clflags.classic && lbl = Nolabel && not (is_optional l) ->\n (t1, t2)\n | td ->\n let ty_fun = match td with Tarrow _ -> newty td | _ -> ty_fun in\n let ty_res =\n result_type (!omitted_parameters @ !eliminated_optional_arguments)\n ty_fun\n in\n match get_desc ty_res with\n | Tarrow _ ->\n if !Clflags.classic || not (has_label lbl ty_fun) then\n raise (Error(sarg.pexp_loc, env,\n Apply_wrong_label(lbl, ty_res, false)))\n else\n raise (Error(funct.exp_loc, env, Incoherent_label_order))\n | _ ->\n raise(Error(funct.exp_loc, env, Apply_non_function\n (expand_head env funct.exp_type)))\n in\n let arg () =\n let arg = type_expect env sarg (mk_expected ty_arg) in\n if is_optional lbl then\n unify_exp env arg (type_option(newvar()));\n arg\n in\n (ty_res, (lbl, Some arg) :: typed_args)\n in\n let ignore_labels =\n !Clflags.classic ||\n begin\n let ls, tvar = list_labels env funct.exp_type in\n not tvar &&\n let labels = List.filter (fun l -> not (is_optional l)) ls in\n List.length labels = List.length sargs &&\n List.for_all (fun (l,_) -> l = Nolabel) sargs &&\n List.exists (fun l -> l <> Nolabel) labels &&\n (Location.prerr_warning\n funct.exp_loc\n (Warnings.Labels_omitted\n (List.map Printtyp.string_of_label\n (List.filter ((<>) Nolabel) labels)));\n true)\n end\n in\n let warned = ref false in\n let rec type_args args ty_fun ty_fun0 sargs =\n let ty_fun' = expand_head env ty_fun in\n match get_desc ty_fun', get_desc (expand_head env ty_fun0) with\n | Tarrow (l, ty, ty_fun, com), Tarrow (_, ty0, ty_fun0, _)\n when sargs <> [] && is_commu_ok com ->\n let lv = get_level ty_fun' in\n let may_warn loc w =\n if not !warned && !Clflags.principal && lv <> generic_level\n then begin\n warned := true;\n Location.prerr_warning loc w\n end\n in\n let name = label_name l\n and optional = is_optional l in\n let use_arg sarg l' =\n Some (\n if not optional || is_optional l' then\n (fun () -> type_argument env sarg ty ty0)\n else begin\n may_warn sarg.pexp_loc\n (Warnings.Not_principal \"using an optional argument here\");\n (fun () -> option_some env (type_argument env sarg\n (extract_option_type env ty)\n (extract_option_type env ty0)))\n end\n )\n in\n let eliminate_optional_arg () =\n may_warn funct.exp_loc\n (Warnings.Non_principal_labels \"eliminated optional argument\");\n eliminated_optional_arguments :=\n (l,ty,lv) :: !eliminated_optional_arguments;\n Some (fun () -> option_none env (instance ty) Location.none)\n in\n let remaining_sargs, arg =\n if ignore_labels then begin\n (* No reordering is allowed, process arguments in order *)\n match sargs with\n | [] -> assert false\n | (l', sarg) :: remaining_sargs ->\n if name = label_name l' || (not optional && l' = Nolabel) then\n (remaining_sargs, use_arg sarg l')\n else if\n optional &&\n not (List.exists (fun (l, _) -> name = label_name l)\n remaining_sargs) &&\n List.exists (function (Nolabel, _) -> true | _ -> false)\n sargs\n then\n (sargs, eliminate_optional_arg ())\n else\n raise(Error(sarg.pexp_loc, env,\n Apply_wrong_label(l', ty_fun', optional)))\n end else\n (* Arguments can be commuted, try to fetch the argument\n corresponding to the first parameter. *)\n match extract_label name sargs with\n | Some (l', sarg, commuted, remaining_sargs) ->\n if commuted then begin\n may_warn sarg.pexp_loc\n (Warnings.Not_principal \"commuting this argument\")\n end;\n if not optional && is_optional l' then\n Location.prerr_warning sarg.pexp_loc\n (Warnings.Nonoptional_label (Printtyp.string_of_label l));\n remaining_sargs, use_arg sarg l'\n | None ->\n sargs,\n if optional && List.mem_assoc Nolabel sargs then\n eliminate_optional_arg ()\n else begin\n (* No argument was given for this parameter, we abstract over\n it. *)\n may_warn funct.exp_loc\n (Warnings.Non_principal_labels \"commuted an argument\");\n omitted_parameters := (l,ty,lv) :: !omitted_parameters;\n None\n end\n in\n type_args ((l,arg)::args) ty_fun ty_fun0 remaining_sargs\n | _ ->\n (* We're not looking at a *known* function type anymore, or there are no\n arguments left. *)\n let ty_fun, typed_args =\n List.fold_left type_unknown_arg (ty_fun0, args) sargs\n in\n let args =\n (* Force typing of arguments.\n Careful: the order matters here. Using [List.rev_map] would be\n incorrect. *)\n List.map\n (function\n | l, None -> l, None\n | l, Some f -> l, Some (f ()))\n (List.rev typed_args)\n in\n let result_ty = instance (result_type !omitted_parameters ty_fun) in\n args, result_ty\n in\n let is_ignore funct =\n is_prim ~name:\"%ignore\" funct &&\n (try ignore (filter_arrow env (instance funct.exp_type) Nolabel); true\n with Filter_arrow_failed _ -> false)\n in\n match sargs with\n | (* Special case for ignore: avoid discarding warning *)\n [Nolabel, sarg] when is_ignore funct ->\n let ty_arg, ty_res = filter_arrow env (instance funct.exp_type) Nolabel in\n let exp = type_expect env sarg (mk_expected ty_arg) in\n check_partial_application ~statement:false exp;\n ([Nolabel, Some exp], ty_res)\n | _ ->\n let ty = funct.exp_type in\n type_args [] ty (instance ty) sargs\n\nand type_construct env loc lid sarg ty_expected_explained attrs =\n let { ty = ty_expected; explanation } = ty_expected_explained in\n let expected_type =\n match extract_concrete_variant env ty_expected with\n | Variant_type(p0, p,_) ->\n Some(p0, p, is_principal ty_expected)\n | Maybe_a_variant_type -> None\n | Not_a_variant_type ->\n let srt = wrong_kind_sort_of_constructor lid.txt in\n let ctx = Expression explanation in\n let error = Wrong_expected_kind(srt, ctx, ty_expected) in\n raise (Error (loc, env, error))\n in\n let constrs =\n Env.lookup_all_constructors ~loc:lid.loc Env.Positive lid.txt env\n in\n let constr =\n wrap_disambiguate \"This variant expression is expected to have\"\n ty_expected_explained\n (Constructor.disambiguate Env.Positive lid env expected_type) constrs\n in\n let sargs =\n match sarg with\n None -> []\n | Some {pexp_desc = Pexp_tuple sel} when\n constr.cstr_arity > 1 || Builtin_attributes.explicit_arity attrs\n -> sel\n | Some se -> [se] in\n if List.length sargs <> constr.cstr_arity then\n raise(Error(loc, env, Constructor_arity_mismatch\n (lid.txt, constr.cstr_arity, List.length sargs)));\n let separate = !Clflags.principal || Env.has_local_constraints env in\n if separate then (begin_def (); begin_def ());\n let (ty_args, ty_res, _) = instance_constructor constr in\n let texp =\n re {\n exp_desc = Texp_construct(lid, constr, []);\n exp_loc = loc; exp_extra = [];\n exp_type = ty_res;\n exp_attributes = attrs;\n exp_env = env } in\n if separate then begin\n end_def ();\n generalize_structure ty_res;\n with_explanation explanation (fun () ->\n unify_exp env {texp with exp_type = instance ty_res}\n (instance ty_expected));\n end_def ();\n List.iter generalize_structure ty_args;\n generalize_structure ty_res;\n end;\n let ty_args0, ty_res =\n match instance_list (ty_res :: ty_args) with\n t :: tl -> tl, t\n | _ -> assert false\n in\n let texp = {texp with exp_type = ty_res} in\n if not separate then unify_exp env texp (instance ty_expected);\n let recarg =\n match constr.cstr_inlined with\n | None -> Rejected\n | Some _ ->\n begin match sargs with\n | [{pexp_desc =\n Pexp_ident _ |\n Pexp_record (_, (Some {pexp_desc = Pexp_ident _}| None))}] ->\n Required\n | _ ->\n raise (Error(loc, env, Inlined_record_expected))\n end\n in\n let args =\n List.map2 (fun e (t,t0) -> type_argument ~recarg env e t t0) sargs\n (List.combine ty_args ty_args0) in\n if constr.cstr_private = Private then\n begin match constr.cstr_tag with\n | Cstr_extension _ ->\n raise(Error(loc, env, Private_constructor (constr, ty_res)))\n | Cstr_constant _ | Cstr_block _ | Cstr_unboxed ->\n raise (Error(loc, env, Private_type ty_res));\n end;\n (* NOTE: shouldn't we call \"re\" on this final expression? -- AF *)\n { texp with\n exp_desc = Texp_construct(lid, constr, args) }\n\n(* Typing of statements (expressions whose values are discarded) *)\n\nand type_statement ?explanation env sexp =\n begin_def();\n let exp = type_exp env sexp in\n end_def();\n let ty = expand_head env exp.exp_type and tv = newvar() in\n if is_Tvar ty && get_level ty > get_level tv then\n Location.prerr_warning\n (final_subexpression exp).exp_loc\n Warnings.Nonreturning_statement;\n if !Clflags.strict_sequence then\n let expected_ty = instance Predef.type_unit in\n with_explanation explanation (fun () ->\n unify_exp env exp expected_ty);\n exp\n else begin\n check_partial_application ~statement:true exp;\n unify_var env tv ty;\n exp\n end\n\nand type_unpacks ?(in_function : (Location.t * type_expr) option)\n env (unpacks : to_unpack list) sbody expected_ty =\n if unpacks = [] then type_expect ?in_function env sbody expected_ty else\n let ty = newvar() in\n (* remember original level *)\n let extended_env, tunpacks =\n List.fold_left (fun (env, tunpacks) unpack ->\n begin_def ();\n let context = Typetexp.narrow () in\n let modl, md_shape =\n !type_module env\n Ast_helper.(\n Mod.unpack ~loc:unpack.tu_loc\n (Exp.ident ~loc:unpack.tu_name.loc\n (mkloc (Longident.Lident unpack.tu_name.txt)\n unpack.tu_name.loc)))\n in\n Mtype.lower_nongen (get_level ty) modl.mod_type;\n let pres =\n match modl.mod_type with\n | Mty_alias _ -> Mp_absent\n | _ -> Mp_present\n in\n let scope = create_scope () in\n let md =\n { md_type = modl.mod_type; md_attributes = [];\n md_loc = unpack.tu_name.loc;\n md_uid = unpack.tu_uid; }\n in\n let (id, env) =\n Env.enter_module_declaration ~scope ~shape:md_shape\n unpack.tu_name.txt pres md env\n in\n Typetexp.widen context;\n env, (id, unpack.tu_name, pres, modl) :: tunpacks\n ) (env, []) unpacks\n in\n (* ideally, we should catch Expr_type_clash errors\n in type_expect triggered by escaping identifiers from the local module\n and refine them into Scoping_let_module errors\n *)\n let body = type_expect ?in_function extended_env sbody expected_ty in\n let exp_loc = { body.exp_loc with loc_ghost = true } in\n let exp_attributes = [Ast_helper.Attr.mk (mknoloc \"#modulepat\") (PStr [])] in\n List.fold_left (fun body (id, name, pres, modl) ->\n (* go back to parent level *)\n end_def ();\n Ctype.unify_var extended_env ty body.exp_type;\n re {\n exp_desc = Texp_letmodule(Some id, { name with txt = Some name.txt },\n pres, modl, body);\n exp_loc;\n exp_attributes;\n exp_extra = [];\n exp_type = ty;\n exp_env = env }\n ) body tunpacks\n\n(* Typing of match cases *)\nand type_cases\n : type k . k pattern_category ->\n ?in_function:_ -> _ -> _ -> _ -> _ -> _ -> Parsetree.case list ->\n k case list * partial\n = fun category ?in_function env\n ty_arg ty_res_explained partial_flag loc caselist ->\n (* ty_arg is _fully_ generalized *)\n let { ty = ty_res; explanation } = ty_res_explained in\n let patterns = List.map (fun {pc_lhs=p} -> p) caselist in\n let contains_polyvars = List.exists contains_polymorphic_variant patterns in\n let erase_either = contains_polyvars && contains_variant_either ty_arg in\n let may_contain_gadts = List.exists may_contain_gadts patterns in\n let ty_arg =\n if (may_contain_gadts || erase_either) && not !Clflags.principal\n then correct_levels ty_arg else ty_arg\n in\n let rec is_var spat =\n match spat.ppat_desc with\n Ppat_any | Ppat_var _ -> true\n | Ppat_alias (spat, _) -> is_var spat\n | _ -> false in\n let needs_exhaust_check =\n match caselist with\n [{pc_rhs = {pexp_desc = Pexp_unreachable}}] -> true\n | [{pc_lhs}] when is_var pc_lhs -> false\n | _ -> true\n in\n let outer_level = get_current_level () in\n let lev =\n if may_contain_gadts then begin_def ();\n get_current_level ()\n in\n let take_partial_instance =\n if erase_either\n then Some false else None\n in\n begin_def (); (* propagation of the argument *)\n let pattern_force = ref [] in\n(* Format.printf \"@[%i %i@ %a@]@.\" lev (get_current_level())\n Printtyp.raw_type_expr ty_arg; *)\n let half_typed_cases =\n List.map\n (fun ({pc_lhs; pc_guard = _; pc_rhs = _} as case) ->\n if !Clflags.principal then begin_def (); (* propagation of pattern *)\n begin_def ();\n let ty_arg = instance ?partial:take_partial_instance ty_arg in\n end_def ();\n generalize_structure ty_arg;\n let (pat, ext_env, force, pvs, unpacks) =\n type_pattern category ~lev env pc_lhs ty_arg\n in\n pattern_force := force @ !pattern_force;\n let pat =\n if !Clflags.principal then begin\n end_def ();\n iter_pattern_variables_type generalize_structure pvs;\n { pat with pat_type = instance pat.pat_type }\n end else pat\n in\n (* Ensure that no ambivalent pattern type escapes its branch *)\n check_scope_escape pat.pat_loc env outer_level ty_arg;\n { typed_pat = pat;\n pat_type_for_unif = ty_arg;\n untyped_case = case;\n branch_env = ext_env;\n pat_vars = pvs;\n unpacks;\n contains_gadt = contains_gadt (as_comp_pattern category pat); }\n )\n caselist in\n let patl = List.map (fun { typed_pat; _ } -> typed_pat) half_typed_cases in\n let does_contain_gadt =\n List.exists (fun { contains_gadt; _ } -> contains_gadt) half_typed_cases\n in\n let ty_res, do_copy_types =\n if does_contain_gadt && not !Clflags.principal then\n correct_levels ty_res, Env.make_copy_of_types env\n else ty_res, (fun env -> env)\n in\n (* Unify all cases (delayed to keep it order-free) *)\n let ty_arg' = newvar () in\n let unify_pats ty =\n List.iter (fun { typed_pat = pat; pat_type_for_unif = pat_ty; _ } ->\n unify_pat_types pat.pat_loc (ref env) pat_ty ty\n ) half_typed_cases\n in\n unify_pats ty_arg';\n (* Check for polymorphic variants to close *)\n if List.exists has_variants patl then begin\n Parmatch.pressure_variants_in_computation_pattern env\n (List.map (as_comp_pattern category) patl);\n List.iter finalize_variants patl\n end;\n (* `Contaminating' unifications start here *)\n List.iter (fun f -> f()) !pattern_force;\n (* Post-processing and generalization *)\n if take_partial_instance <> None then unify_pats (instance ty_arg);\n List.iter (fun { pat_vars; _ } ->\n iter_pattern_variables_type (fun t -> unify_var env (newvar()) t) pat_vars\n ) half_typed_cases;\n end_def ();\n generalize ty_arg';\n List.iter (fun { pat_vars; _ } ->\n iter_pattern_variables_type generalize pat_vars\n ) half_typed_cases;\n (* type bodies *)\n let in_function = if List.length caselist = 1 then in_function else None in\n let cases =\n List.map\n (fun { typed_pat = pat; branch_env = ext_env; pat_vars = pvs; unpacks;\n untyped_case = {pc_lhs = _; pc_guard; pc_rhs};\n contains_gadt; _ } ->\n let ext_env =\n if contains_gadt then\n do_copy_types ext_env\n else\n ext_env\n in\n let ext_env =\n add_pattern_variables ext_env pvs\n ~check:(fun s -> Warnings.Unused_var_strict s)\n ~check_as:(fun s -> Warnings.Unused_var s)\n in\n let unpacks =\n List.map (fun (name, loc) ->\n {tu_name = name; tu_loc = loc;\n tu_uid = Uid.mk ~current_unit:(Env.get_unit_name ())}\n ) unpacks\n in\n let ty_res' =\n if !Clflags.principal then begin\n begin_def ();\n let ty = instance ~partial:true ty_res in\n end_def ();\n generalize_structure ty; ty\n end\n else if contains_gadt then\n (* allow propagation from preceding branches *)\n correct_levels ty_res\n else ty_res in\n let guard =\n match pc_guard with\n | None -> None\n | Some scond ->\n Some\n (type_unpacks ext_env unpacks scond\n (mk_expected ~explanation:When_guard Predef.type_bool))\n in\n let exp =\n type_unpacks ?in_function ext_env\n unpacks pc_rhs (mk_expected ?explanation ty_res')\n in\n {\n c_lhs = pat;\n c_guard = guard;\n c_rhs = {exp with exp_type = instance ty_res'}\n }\n )\n half_typed_cases\n in\n if !Clflags.principal || does_contain_gadt then begin\n let ty_res' = instance ty_res in\n List.iter (fun c -> unify_exp env c.c_rhs ty_res') cases\n end;\n let do_init = may_contain_gadts || needs_exhaust_check in\n let ty_arg_check =\n if do_init then\n (* Hack: use for_saving to copy variables too *)\n Subst.type_expr (Subst.for_saving Subst.identity) ty_arg'\n else ty_arg'\n in\n let val_cases, exn_cases =\n match category with\n | Value -> (cases : value case list), []\n | Computation -> split_cases env cases in\n if val_cases = [] && exn_cases <> [] then\n raise (Error (loc, env, No_value_clauses));\n let partial =\n if partial_flag then\n check_partial ~lev env ty_arg_check loc val_cases\n else\n Partial\n in\n let unused_check delayed =\n List.iter (fun { typed_pat; branch_env; _ } ->\n check_absent_variant branch_env (as_comp_pattern category typed_pat)\n ) half_typed_cases;\n if delayed then (begin_def (); init_def lev);\n check_unused ~lev env ty_arg_check val_cases ;\n check_unused ~lev env Predef.type_exn exn_cases ;\n if delayed then end_def ();\n Parmatch.check_ambiguous_bindings val_cases ;\n Parmatch.check_ambiguous_bindings exn_cases\n in\n if contains_polyvars then\n add_delayed_check (fun () -> unused_check true)\n else\n (* Check for unused cases, do not delay because of gadts *)\n unused_check false;\n if may_contain_gadts then begin\n end_def ();\n (* Ensure that existential types do not escape *)\n unify_exp_types loc env (instance ty_res) (newvar ()) ;\n end;\n cases, partial\n\n(* Typing of let bindings *)\n\nand type_let\n ?(check = fun s -> Warnings.Unused_var s)\n ?(check_strict = fun s -> Warnings.Unused_var_strict s)\n existential_context\n env rec_flag spat_sexp_list allow =\n let open Ast_helper in\n begin_def();\n if !Clflags.principal then begin_def ();\n\n let is_fake_let =\n match spat_sexp_list with\n | [{pvb_expr={pexp_desc=Pexp_match(\n {pexp_desc=Pexp_ident({ txt = Longident.Lident \"*opt*\"})},_)}}] ->\n true (* the fake let-declaration introduced by fun ?(x = e) -> ... *)\n | _ ->\n false\n in\n let check = if is_fake_let then check_strict else check in\n\n let spatl =\n List.map\n (fun {pvb_pat=spat; pvb_expr=sexp; pvb_attributes=attrs} ->\n attrs,\n match spat.ppat_desc, sexp.pexp_desc with\n (Ppat_any | Ppat_constraint _), _ -> spat\n | _, Pexp_coerce (_, _, sty)\n | _, Pexp_constraint (_, sty) when !Clflags.principal ->\n (* propagate type annotation to pattern,\n to allow it to be generalized in -principal mode *)\n Pat.constraint_\n ~loc:{spat.ppat_loc with Location.loc_ghost=true}\n spat\n sty\n | _ -> spat)\n spat_sexp_list in\n let nvs = List.map (fun _ -> newvar ()) spatl in\n let (pat_list, new_env, force, pvs, unpacks) =\n type_pattern_list Value existential_context env spatl nvs allow in\n let attrs_list = List.map fst spatl in\n let is_recursive = (rec_flag = Recursive) in\n (* If recursive, first unify with an approximation of the expression *)\n if is_recursive then\n List.iter2\n (fun pat binding ->\n let pat =\n match get_desc pat.pat_type with\n | Tpoly (ty, tl) ->\n {pat with pat_type =\n snd (instance_poly ~keep_names:true false tl ty)}\n | _ -> pat\n in unify_pat (ref env) pat (type_approx env binding.pvb_expr))\n pat_list spat_sexp_list;\n (* Polymorphic variant processing *)\n List.iter\n (fun pat ->\n if has_variants pat then begin\n Parmatch.pressure_variants env [pat];\n finalize_variants pat\n end)\n pat_list;\n (* Generalize the structure *)\n let pat_list =\n if !Clflags.principal then begin\n end_def ();\n iter_pattern_variables_type generalize_structure pvs;\n List.map (fun pat ->\n generalize_structure pat.pat_type;\n {pat with pat_type = instance pat.pat_type}\n ) pat_list\n end else\n pat_list\n in\n (* Only bind pattern variables after generalizing *)\n List.iter (fun f -> f()) force;\n let sexp_is_fun { pvb_expr = sexp; _ } =\n match sexp.pexp_desc with\n | Pexp_fun _ | Pexp_function _ -> true\n | _ -> false\n in\n let exp_env =\n if is_recursive then new_env\n else if List.for_all sexp_is_fun spat_sexp_list\n then begin\n (* Add ghost bindings to help detecting missing \"rec\" keywords.\n\n We only add those if the body of the definition is obviously a\n function. The rationale is that, in other cases, the hint is probably\n wrong (and the user is using \"advanced features\" anyway (lazy,\n recursive values...)).\n\n [pvb_loc] (below) is the location of the first let-binding (in case of\n a let .. and ..), and is where the missing \"rec\" hint suggests to add a\n \"rec\" keyword. *)\n match spat_sexp_list with\n | {pvb_loc; _} :: _ -> maybe_add_pattern_variables_ghost pvb_loc env pvs\n | _ -> assert false\n end\n else env in\n\n let current_slot = ref None in\n let rec_needed = ref false in\n let warn_about_unused_bindings =\n List.exists\n (fun attrs ->\n Builtin_attributes.warning_scope ~ppwarning:false attrs (fun () ->\n Warnings.is_active (check \"\") || Warnings.is_active (check_strict \"\")\n || (is_recursive && (Warnings.is_active Warnings.Unused_rec_flag))))\n attrs_list\n in\n let pat_slot_list =\n (* Algorithm to detect unused declarations in recursive bindings:\n - During type checking of the definitions, we capture the 'value_used'\n events on the bound identifiers and record them in a slot corresponding\n to the current definition (!current_slot).\n In effect, this creates a dependency graph between definitions.\n\n - After type checking the definition (!current_slot = None),\n when one of the bound identifier is effectively used, we trigger\n again all the events recorded in the corresponding slot.\n The effect is to traverse the transitive closure of the graph created\n in the first step.\n\n We also keep track of whether *all* variables in a given pattern\n are unused. If this is the case, for local declarations, the issued\n warning is 26, not 27.\n *)\n List.map2\n (fun attrs pat ->\n Builtin_attributes.warning_scope ~ppwarning:false attrs (fun () ->\n if not warn_about_unused_bindings then pat, None\n else\n let some_used = ref false in\n (* has one of the identifier of this pattern been used? *)\n let slot = ref [] in\n List.iter\n (fun id ->\n let vd = Env.find_value (Path.Pident id) new_env in\n (* note: Env.find_value does not trigger the value_used\n event *)\n let name = Ident.name id in\n let used = ref false in\n if not (name = \"\" || name.[0] = '_' || name.[0] = '#') then\n add_delayed_check\n (fun () ->\n if not !used then\n Location.prerr_warning vd.Types.val_loc\n ((if !some_used then check_strict else check) name)\n );\n Env.set_value_used_callback\n vd\n (fun () ->\n match !current_slot with\n | Some slot ->\n slot := vd.val_uid :: !slot; rec_needed := true\n | None ->\n List.iter Env.mark_value_used (get_ref slot);\n used := true;\n some_used := true\n )\n )\n (Typedtree.pat_bound_idents pat);\n pat, Some slot\n ))\n attrs_list\n pat_list\n in\n let exp_list =\n List.map2\n (fun {pvb_expr=sexp; pvb_attributes; _} (pat, slot) ->\n if is_recursive then current_slot := slot;\n match get_desc pat.pat_type with\n | Tpoly (ty, tl) ->\n if !Clflags.principal then begin_def ();\n let vars, ty' = instance_poly ~keep_names:true true tl ty in\n if !Clflags.principal then begin\n end_def ();\n generalize_structure ty'\n end;\n let exp =\n Builtin_attributes.warning_scope pvb_attributes (fun () ->\n if rec_flag = Recursive then\n type_unpacks exp_env unpacks sexp (mk_expected ty')\n else\n type_expect exp_env sexp (mk_expected ty')\n )\n in\n exp, Some vars\n | _ ->\n let exp =\n Builtin_attributes.warning_scope pvb_attributes (fun () ->\n if rec_flag = Recursive then\n type_unpacks exp_env unpacks sexp (mk_expected pat.pat_type)\n else\n type_expect exp_env sexp (mk_expected pat.pat_type))\n in\n exp, None)\n spat_sexp_list pat_slot_list in\n current_slot := None;\n if is_recursive && not !rec_needed then begin\n let {pvb_pat; pvb_attributes} = List.hd spat_sexp_list in\n (* See PR#6677 *)\n Builtin_attributes.warning_scope ~ppwarning:false pvb_attributes\n (fun () ->\n Location.prerr_warning pvb_pat.ppat_loc Warnings.Unused_rec_flag\n )\n end;\n List.iter2\n (fun pat (attrs, exp) ->\n Builtin_attributes.warning_scope ~ppwarning:false attrs\n (fun () ->\n ignore(check_partial env pat.pat_type pat.pat_loc\n [case pat exp])\n )\n )\n pat_list\n (List.map2 (fun (attrs, _) (e, _) -> attrs, e) spatl exp_list);\n let pvs = List.map (fun pv -> { pv with pv_type = instance pv.pv_type}) pvs in\n end_def();\n List.iter2\n (fun pat (exp, _) ->\n if maybe_expansive exp then\n lower_contravariant env pat.pat_type)\n pat_list exp_list;\n iter_pattern_variables_type generalize pvs;\n List.iter2\n (fun pat (exp, vars) ->\n match vars with\n | None ->\n (* We generalize expressions even if they are not bound to a variable\n and do not have an expliclit polymorphic type annotation. This is\n not needed in general, however those types may be shown by the\n interactive toplevel, for example:\n {[\n let _ = Array.get;;\n - : 'a array -> int -> 'a = \n ]}\n so we do it anyway. *)\n generalize exp.exp_type\n | Some vars ->\n if maybe_expansive exp then\n lower_contravariant env exp.exp_type;\n generalize_and_check_univars env \"definition\" exp pat.pat_type vars)\n pat_list exp_list;\n let l = List.combine pat_list exp_list in\n let l =\n List.map2\n (fun (p, (e, _)) pvb ->\n {vb_pat=p; vb_expr=e; vb_attributes=pvb.pvb_attributes;\n vb_loc=pvb.pvb_loc;\n })\n l spat_sexp_list\n in\n if is_recursive then\n List.iter\n (fun {vb_pat=pat} -> match pat.pat_desc with\n Tpat_var _ -> ()\n | Tpat_alias ({pat_desc=Tpat_any}, _, _) -> ()\n | _ -> raise(Error(pat.pat_loc, env, Illegal_letrec_pat)))\n l;\n List.iter (function\n | {vb_pat = {pat_desc = Tpat_any; pat_extra; _}; vb_expr; _} ->\n if not (List.exists (function (Tpat_constraint _, _, _) -> true\n | _ -> false) pat_extra) then\n check_partial_application ~statement:false vb_expr\n | _ -> ()) l;\n (l, new_env, unpacks)\n\nand type_andops env sarg sands expected_ty =\n let rec loop env let_sarg rev_sands expected_ty =\n match rev_sands with\n | [] -> type_expect env let_sarg (mk_expected expected_ty), []\n | { pbop_op = sop; pbop_exp = sexp; pbop_loc = loc; _ } :: rest ->\n if !Clflags.principal then begin_def ();\n let op_path, op_desc = type_binding_op_ident env sop in\n let op_type = instance op_desc.val_type in\n let ty_arg = newvar () in\n let ty_rest = newvar () in\n let ty_result = newvar() in\n let ty_rest_fun =\n newty (Tarrow(Nolabel, ty_arg, ty_result, commu_ok)) in\n let ty_op = newty (Tarrow(Nolabel, ty_rest, ty_rest_fun, commu_ok)) in\n begin try\n unify env op_type ty_op\n with Unify err ->\n raise(Error(sop.loc, env, Andop_type_clash(sop.txt, err)))\n end;\n if !Clflags.principal then begin\n end_def ();\n generalize_structure ty_rest;\n generalize_structure ty_arg;\n generalize_structure ty_result\n end;\n let let_arg, rest = loop env let_sarg rest ty_rest in\n let exp = type_expect env sexp (mk_expected ty_arg) in\n begin try\n unify env (instance ty_result) (instance expected_ty)\n with Unify err ->\n raise(Error(loc, env, Bindings_type_clash(err)))\n end;\n let andop =\n { bop_op_name = sop;\n bop_op_path = op_path;\n bop_op_val = op_desc;\n bop_op_type = op_type;\n bop_exp = exp;\n bop_loc = loc }\n in\n let_arg, andop :: rest\n in\n let let_arg, rev_ands = loop env sarg (List.rev sands) expected_ty in\n let_arg, List.rev rev_ands\n\n(* Typing of toplevel bindings *)\n\nlet type_binding env rec_flag spat_sexp_list =\n Typetexp.reset_type_variables();\n let (pat_exp_list, new_env, _unpacks) =\n type_let\n ~check:(fun s -> Warnings.Unused_value_declaration s)\n ~check_strict:(fun s -> Warnings.Unused_value_declaration s)\n At_toplevel\n env rec_flag spat_sexp_list false\n in\n (pat_exp_list, new_env)\n\nlet type_let existential_ctx env rec_flag spat_sexp_list =\n let (pat_exp_list, new_env, _unpacks) =\n type_let existential_ctx env rec_flag spat_sexp_list false in\n (pat_exp_list, new_env)\n\n(* Typing of toplevel expressions *)\n\nlet type_expression env sexp =\n Typetexp.reset_type_variables();\n begin_def();\n let exp = type_exp env sexp in\n end_def();\n if maybe_expansive exp then lower_contravariant env exp.exp_type;\n generalize exp.exp_type;\n match sexp.pexp_desc with\n Pexp_ident lid ->\n let loc = sexp.pexp_loc in\n (* Special case for keeping type variables when looking-up a variable *)\n let (_path, desc) = Env.lookup_value ~use:false ~loc lid.txt env in\n {exp with exp_type = desc.val_type}\n | _ -> exp\n\n(* Error report *)\n\nlet spellcheck ppf unbound_name valid_names =\n Misc.did_you_mean ppf (fun () ->\n Misc.spellcheck valid_names unbound_name\n )\n\nlet spellcheck_idents ppf unbound valid_idents =\n spellcheck ppf (Ident.name unbound) (List.map Ident.name valid_idents)\n\nopen Format\n\nlet longident = Printtyp.longident\n\n(* Returns the first diff of the trace *)\nlet type_clash_of_trace trace =\n Errortrace.(explain trace (fun ~prev:_ -> function\n | Diff diff -> Some diff\n | _ -> None\n ))\n\n(* Hint on type error on integer literals\n To avoid confusion, it is disabled on float literals\n and when the expected type is `int` *)\nlet report_literal_type_constraint expected_type const =\n let const_str = match const with\n | Const_int n -> Some (Int.to_string n)\n | Const_int32 n -> Some (Int32.to_string n)\n | Const_int64 n -> Some (Int64.to_string n)\n | Const_nativeint n -> Some (Nativeint.to_string n)\n | _ -> None\n in\n let suffix =\n if Path.same expected_type Predef.path_int32 then\n Some 'l'\n else if Path.same expected_type Predef.path_int64 then\n Some 'L'\n else if Path.same expected_type Predef.path_nativeint then\n Some 'n'\n else if Path.same expected_type Predef.path_float then\n Some '.'\n else None\n in\n match const_str, suffix with\n | Some c, Some s -> [ Location.msg \"@[Hint: Did you mean `%s%c'?@]\" c s ]\n | _, _ -> []\n\nlet report_literal_type_constraint const = function\n | Some tr ->\n begin match get_desc Errortrace.(tr.expected.ty) with\n Tconstr (typ, [], _) ->\n report_literal_type_constraint typ const\n | _ -> []\n end\n | None -> []\n\nlet report_expr_type_clash_hints exp diff =\n match exp with\n | Some (Texp_constant const) -> report_literal_type_constraint const diff\n | _ -> []\n\nlet report_pattern_type_clash_hints\n (type k) (pat : k pattern_desc option) diff =\n match pat with\n | Some (Tpat_constant const) -> report_literal_type_constraint const diff\n | _ -> []\n\nlet report_type_expected_explanation expl ppf =\n let because expl_str = fprintf ppf \"@ because it is in %s\" expl_str in\n match expl with\n | If_conditional ->\n because \"the condition of an if-statement\"\n | If_no_else_branch ->\n because \"the result of a conditional with no else branch\"\n | While_loop_conditional ->\n because \"the condition of a while-loop\"\n | While_loop_body ->\n because \"the body of a while-loop\"\n | For_loop_start_index ->\n because \"a for-loop start index\"\n | For_loop_stop_index ->\n because \"a for-loop stop index\"\n | For_loop_body ->\n because \"the body of a for-loop\"\n | Assert_condition ->\n because \"the condition of an assertion\"\n | Sequence_left_hand_side ->\n because \"the left-hand side of a sequence\"\n | When_guard ->\n because \"a when-guard\"\n\nlet report_type_expected_explanation_opt expl ppf =\n match expl with\n | None -> ()\n | Some expl -> report_type_expected_explanation expl ppf\n\nlet report_unification_error ~loc ?sub env err\n ?type_expected_explanation txt1 txt2 =\n Location.error_of_printer ~loc ?sub (fun ppf () ->\n Printtyp.report_unification_error ppf env err\n ?type_expected_explanation txt1 txt2\n ) ()\n\nlet report_error ~loc env = function\n | Constructor_arity_mismatch(lid, expected, provided) ->\n Location.errorf ~loc\n \"@[The constructor %a@ expects %i argument(s),@ \\\n but is applied here to %i argument(s)@]\"\n longident lid expected provided\n | Label_mismatch(lid, err) ->\n report_unification_error ~loc env err\n (function ppf ->\n fprintf ppf \"The record field %a@ belongs to the type\"\n longident lid)\n (function ppf ->\n fprintf ppf \"but is mixed here with fields of type\")\n | Pattern_type_clash (err, pat) ->\n let diff = type_clash_of_trace err.trace in\n let sub = report_pattern_type_clash_hints pat diff in\n report_unification_error ~loc ~sub env err\n (function ppf ->\n fprintf ppf \"This pattern matches values of type\")\n (function ppf ->\n fprintf ppf \"but a pattern was expected which matches values of \\\n type\");\n | Or_pattern_type_clash (id, err) ->\n report_unification_error ~loc env err\n (function ppf ->\n fprintf ppf \"The variable %s on the left-hand side of this \\\n or-pattern has type\" (Ident.name id))\n (function ppf ->\n fprintf ppf \"but on the right-hand side it has type\")\n | Multiply_bound_variable name ->\n Location.errorf ~loc\n \"Variable %s is bound several times in this matching\"\n name\n | Orpat_vars (id, valid_idents) ->\n Location.error_of_printer ~loc (fun ppf () ->\n fprintf ppf\n \"Variable %s must occur on both sides of this | pattern\"\n (Ident.name id);\n spellcheck_idents ppf id valid_idents\n ) ()\n | Expr_type_clash (err, explanation, exp) ->\n let diff = type_clash_of_trace err.trace in\n let sub = report_expr_type_clash_hints exp diff in\n report_unification_error ~loc ~sub env err\n ~type_expected_explanation:\n (report_type_expected_explanation_opt explanation)\n (function ppf ->\n fprintf ppf \"This expression has type\")\n (function ppf ->\n fprintf ppf \"but an expression was expected of type\");\n | Apply_non_function typ ->\n begin match get_desc typ with\n Tarrow _ ->\n Location.errorf ~loc\n \"@[@[<2>This function has type@ %a@]\\\n @ @[It is applied to too many arguments;@ %s@]@]\"\n Printtyp.type_expr typ \"maybe you forgot a `;'.\";\n | _ ->\n Location.errorf ~loc \"@[@[<2>This expression has type@ %a@]@ %s@]\"\n Printtyp.type_expr typ\n \"This is not a function; it cannot be applied.\"\n end\n | Apply_wrong_label (l, ty, extra_info) ->\n let print_label ppf = function\n | Nolabel -> fprintf ppf \"without label\"\n | l -> fprintf ppf \"with label %s\" (prefixed_label_name l)\n in\n let extra_info =\n if not extra_info then\n []\n else\n [ Location.msg\n \"Since OCaml 4.11, optional arguments do not commute when \\\n -nolabels is given\" ]\n in\n Location.errorf ~loc ~sub:extra_info\n \"@[@[<2>The function applied to this argument has type@ %a@]@.\\\n This argument cannot be applied %a@]\"\n Printtyp.type_expr ty print_label l\n | Label_multiply_defined s ->\n Location.errorf ~loc \"The record field label %s is defined several times\"\n s\n | Label_missing labels ->\n let print_labels ppf =\n List.iter (fun lbl -> fprintf ppf \"@ %s\" (Ident.name lbl)) in\n Location.errorf ~loc \"@[Some record fields are undefined:%a@]\"\n print_labels labels\n | Label_not_mutable lid ->\n Location.errorf ~loc \"The record field %a is not mutable\" longident lid\n | Wrong_name (eorp, ty_expected, { type_path; kind; name; valid_names; }) ->\n Location.error_of_printer ~loc (fun ppf () ->\n Printtyp.wrap_printing_env ~error:true env (fun () ->\n let { ty; explanation } = ty_expected in\n if Path.is_constructor_typath type_path then begin\n fprintf ppf\n \"@[The field %s is not part of the record \\\n argument for the %a constructor@]\"\n name.txt\n Printtyp.type_path type_path;\n end else begin\n fprintf ppf\n \"@[@[<2>%s type@ %a%t@]@ \\\n There is no %s %s within type %a@]\"\n eorp Printtyp.type_expr ty\n (report_type_expected_explanation_opt explanation)\n (Datatype_kind.label_name kind)\n name.txt (*kind*) Printtyp.type_path type_path;\n end;\n spellcheck ppf name.txt valid_names\n )) ()\n | Name_type_mismatch (kind, lid, tp, tpl) ->\n let type_name = Datatype_kind.type_name kind in\n let name = Datatype_kind.label_name kind in\n Location.error_of_printer ~loc (fun ppf () ->\n Printtyp.report_ambiguous_type_error ppf env tp tpl\n (function ppf ->\n fprintf ppf \"The %s %a@ belongs to the %s type\"\n name longident lid type_name)\n (function ppf ->\n fprintf ppf \"The %s %a@ belongs to one of the following %s types:\"\n name longident lid type_name)\n (function ppf ->\n fprintf ppf \"but a %s was expected belonging to the %s type\"\n name type_name)\n ) ()\n | Invalid_format msg ->\n Location.errorf ~loc \"%s\" msg\n | Not_an_object (ty, explanation) ->\n Location.error_of_printer ~loc (fun ppf () ->\n fprintf ppf \"This expression is not an object;@ \\\n it has type %a\"\n Printtyp.type_expr ty;\n report_type_expected_explanation_opt explanation ppf\n ) ()\n | Undefined_method (ty, me, valid_methods) ->\n Location.error_of_printer ~loc (fun ppf () ->\n Printtyp.wrap_printing_env ~error:true env (fun () ->\n fprintf ppf\n \"@[@[This expression has type@;<1 2>%a@]@,\\\n It has no method %s@]\" Printtyp.type_expr ty me;\n begin match valid_methods with\n | None -> ()\n | Some valid_methods -> spellcheck ppf me valid_methods\n end\n )) ()\n | Undefined_self_method (me, valid_methods) ->\n Location.error_of_printer ~loc (fun ppf () ->\n fprintf ppf \"This expression has no method %s\" me;\n spellcheck ppf me valid_methods;\n ) ()\n | Virtual_class cl ->\n Location.errorf ~loc \"Cannot instantiate the virtual class %a\"\n longident cl\n | Unbound_instance_variable (var, valid_vars) ->\n Location.error_of_printer ~loc (fun ppf () ->\n fprintf ppf \"Unbound instance variable %s\" var;\n spellcheck ppf var valid_vars;\n ) ()\n | Instance_variable_not_mutable v ->\n Location.errorf ~loc \"The instance variable %s is not mutable\" v\n | Not_subtype err ->\n Location.error_of_printer ~loc (fun ppf () ->\n Printtyp.Subtype.report_error ppf env err \"is not a subtype of\"\n ) ()\n | Outside_class ->\n Location.errorf ~loc\n \"This object duplication occurs outside a method definition\"\n | Value_multiply_overridden v ->\n Location.errorf ~loc\n \"The instance variable %s is overridden several times\"\n v\n | Coercion_failure (ty_exp, err, b) ->\n Location.error_of_printer ~loc (fun ppf () ->\n Printtyp.report_unification_error ppf env err\n (function ppf ->\n let ty_exp = Printtyp.prepare_expansion ty_exp in\n fprintf ppf \"This expression cannot be coerced to type@;<1 2>%a;@ \\\n it has type\"\n (Printtyp.type_expansion Type) ty_exp)\n (function ppf ->\n fprintf ppf \"but is here used with type\");\n if b then\n fprintf ppf \".@.@[%s@ %s@ %s@]\"\n \"This simple coercion was not fully general.\"\n \"Hint: Consider using a fully explicit coercion\"\n \"of the form: `(foo : ty1 :> ty2)'.\"\n ) ()\n | Not_a_function (ty, explanation) ->\n Location.errorf ~loc\n \"This expression should not be a function,@ \\\n the expected type is@ %a%t\"\n Printtyp.type_expr ty\n (report_type_expected_explanation_opt explanation)\n | Too_many_arguments (ty, explanation) ->\n Location.errorf ~loc\n \"This function expects too many arguments,@ \\\n it should have type@ %a%t\"\n Printtyp.type_expr ty\n (report_type_expected_explanation_opt explanation)\n | Abstract_wrong_label {got; expected; expected_type; explanation} ->\n let label ~long = function\n | Nolabel -> \"unlabeled\"\n | l -> (if long then \"labeled \" else \"\") ^ prefixed_label_name l\n in\n let second_long = match got, expected with\n | Nolabel, _ | _, Nolabel -> true\n | _ -> false\n in\n Location.errorf ~loc\n \"@[@[<2>This function should have type@ %a%t@]@,\\\n @[but its first argument is %s@ instead of %s%s@]@]\"\n Printtyp.type_expr expected_type\n (report_type_expected_explanation_opt explanation)\n (label ~long:true got)\n (if second_long then \"being \" else \"\")\n (label ~long:second_long expected)\n | Scoping_let_module(id, ty) ->\n Location.errorf ~loc\n \"This `let module' expression has type@ %a@ \\\n In this type, the locally bound module name %s escapes its scope\"\n Printtyp.type_expr ty id\n | Private_type ty ->\n Location.errorf ~loc \"Cannot create values of the private type %a\"\n Printtyp.type_expr ty\n | Private_label (lid, ty) ->\n Location.errorf ~loc \"Cannot assign field %a of the private type %a\"\n longident lid Printtyp.type_expr ty\n | Private_constructor (constr, ty) ->\n Location.errorf ~loc\n \"Cannot use private constructor %s to create values of type %a\"\n constr.cstr_name Printtyp.type_expr ty\n | Not_a_polymorphic_variant_type lid ->\n Location.errorf ~loc \"The type %a@ is not a variant type\" longident lid\n | Incoherent_label_order ->\n Location.errorf ~loc\n \"This function is applied to arguments@ \\\n in an order different from other calls.@ \\\n This is only allowed when the real type is known.\"\n | Less_general (kind, err) ->\n report_unification_error ~loc env err\n (fun ppf -> fprintf ppf \"This %s has type\" kind)\n (fun ppf -> fprintf ppf \"which is less general than\")\n | Modules_not_allowed ->\n Location.errorf ~loc \"Modules are not allowed in this pattern.\"\n | Cannot_infer_signature ->\n Location.errorf ~loc\n \"The signature for this packaged module couldn't be inferred.\"\n | Not_a_packed_module ty ->\n Location.errorf ~loc\n \"This expression is packed module, but the expected type is@ %a\"\n Printtyp.type_expr ty\n | Unexpected_existential (reason, name, types) ->\n let reason_str =\n match reason with\n | In_class_args ->\n \"Existential types are not allowed in class arguments\"\n | In_class_def ->\n \"Existential types are not allowed in bindings inside \\\n class definition\"\n | In_self_pattern ->\n \"Existential types are not allowed in self patterns\"\n | At_toplevel ->\n \"Existential types are not allowed in toplevel bindings\"\n | In_group ->\n \"Existential types are not allowed in \\\"let ... and ...\\\" bindings\"\n | In_rec ->\n \"Existential types are not allowed in recursive bindings\"\n | With_attributes ->\n \"Existential types are not allowed in presence of attributes\"\n in\n begin match List.find (fun ty -> ty <> \"$\" ^ name) types with\n | example ->\n Location.errorf ~loc\n \"%s,@ but this pattern introduces the existential type %s.\"\n reason_str example\n | exception Not_found ->\n Location.errorf ~loc\n \"%s,@ but the constructor %s introduces existential types.\"\n reason_str name\n end\n | Invalid_interval ->\n Location.errorf ~loc\n \"@[Only character intervals are supported in patterns.@]\"\n | Invalid_for_loop_index ->\n Location.errorf ~loc\n \"@[Invalid for-loop index: only variables and _ are allowed.@]\"\n | No_value_clauses ->\n Location.errorf ~loc\n \"None of the patterns in this 'match' expression match values.\"\n | Exception_pattern_disallowed ->\n Location.errorf ~loc\n \"@[Exception patterns are not allowed in this position.@]\"\n | Mixed_value_and_exception_patterns_under_guard ->\n Location.errorf ~loc\n \"@[Mixing value and exception patterns under when-guards is not \\\n supported.@]\"\n | Inlined_record_escape ->\n Location.errorf ~loc\n \"@[This form is not allowed as the type of the inlined record could \\\n escape.@]\"\n | Inlined_record_expected ->\n Location.errorf ~loc\n \"@[This constructor expects an inlined record argument.@]\"\n | Unrefuted_pattern pat ->\n Location.errorf ~loc\n \"@[%s@ %s@ %a@]\"\n \"This match case could not be refuted.\"\n \"Here is an example of a value that would reach it:\"\n Printpat.top_pretty pat\n | Invalid_extension_constructor_payload ->\n Location.errorf ~loc\n \"Invalid [%%extension_constructor] payload, a constructor is expected.\"\n | Not_an_extension_constructor ->\n Location.errorf ~loc\n \"This constructor is not an extension constructor.\"\n | Literal_overflow ty ->\n Location.errorf ~loc\n \"Integer literal exceeds the range of representable integers of type %s\"\n ty\n | Unknown_literal (n, m) ->\n Location.errorf ~loc \"Unknown modifier '%c' for literal %s%c\" m n m\n | Illegal_letrec_pat ->\n Location.errorf ~loc\n \"Only variables are allowed as left-hand side of `let rec'\"\n | Illegal_letrec_expr ->\n Location.errorf ~loc\n \"This kind of expression is not allowed as right-hand side of `let rec'\"\n | Illegal_class_expr ->\n Location.errorf ~loc\n \"This kind of recursive class expression is not allowed\"\n | Letop_type_clash(name, err) ->\n report_unification_error ~loc env err\n (function ppf ->\n fprintf ppf \"The operator %s has type\" name)\n (function ppf ->\n fprintf ppf \"but it was expected to have type\")\n | Andop_type_clash(name, err) ->\n report_unification_error ~loc env err\n (function ppf ->\n fprintf ppf \"The operator %s has type\" name)\n (function ppf ->\n fprintf ppf \"but it was expected to have type\")\n | Bindings_type_clash(err) ->\n report_unification_error ~loc env err\n (function ppf ->\n fprintf ppf \"These bindings have type\")\n (function ppf ->\n fprintf ppf \"but bindings were expected of type\")\n | Unbound_existential (ids, ty) ->\n Location.errorf ~loc\n \"@[<2>%s:@ @[type %s.@ %a@]@]\"\n \"This type does not bind all existentials in the constructor\"\n (String.concat \" \" (List.map Ident.name ids))\n Printtyp.type_expr ty\n | Missing_type_constraint ->\n Location.errorf ~loc\n \"@[%s@ %s@]\"\n \"Existential types introduced in a constructor pattern\"\n \"must be bound by a type constraint on the argument.\"\n | Wrong_expected_kind(sort, ctx, ty) ->\n let ctx, explanation =\n match ctx with\n | Expression explanation -> \"expression\", explanation\n | Pattern -> \"pattern\", None\n in\n let sort =\n match sort with\n | Constructor -> \"constructor\"\n | Boolean -> \"boolean literal\"\n | List -> \"list literal\"\n | Unit -> \"unit literal\"\n | Record -> \"record\"\n in\n Location.errorf ~loc\n \"This %s should not be a %s,@ \\\n the expected type is@ %a%t\"\n ctx sort Printtyp.type_expr ty\n (report_type_expected_explanation_opt explanation)\n | Expr_not_a_record_type ty ->\n Location.errorf ~loc\n \"This expression has type %a@ \\\n which is not a record type.\"\n Printtyp.type_expr ty\n\nlet report_error ~loc env err =\n Printtyp.wrap_printing_env ~error:true env\n (fun () -> report_error ~loc env err)\n\nlet () =\n Location.register_error_of_exn\n (function\n | Error (loc, env, err) ->\n Some (report_error ~loc env err)\n | Error_forward err ->\n Some err\n | _ ->\n None\n )\n\nlet () =\n Persistent_env.add_delayed_check_forward := add_delayed_check;\n Env.add_delayed_check_forward := add_delayed_check;\n ()\n\n(* drop ?recarg argument from the external API *)\nlet type_expect ?in_function env e ty = type_expect ?in_function env e ty\nlet type_exp env e = type_exp env e\nlet type_argument env e t1 t2 = type_argument env e t1 t2\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Jerome Vouillon, 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 Parsetree\nopen Asttypes\nopen Path\nopen Types\nopen Typecore\nopen Typetexp\nopen Format\n\ntype 'a class_info = {\n cls_id : Ident.t;\n cls_id_loc : string loc;\n cls_decl : class_declaration;\n cls_ty_id : Ident.t;\n cls_ty_decl : class_type_declaration;\n cls_obj_id : Ident.t;\n cls_obj_abbr : type_declaration;\n cls_typesharp_id : Ident.t;\n cls_abbr : type_declaration;\n cls_arity : int;\n cls_pub_methods : string list;\n cls_info : 'a;\n}\n\ntype class_type_info = {\n clsty_ty_id : Ident.t;\n clsty_id_loc : string loc;\n clsty_ty_decl : class_type_declaration;\n clsty_obj_id : Ident.t;\n clsty_obj_abbr : type_declaration;\n clsty_typesharp_id : Ident.t;\n clsty_abbr : type_declaration;\n clsty_info : Typedtree.class_type_declaration;\n}\n\ntype 'a full_class = {\n id : Ident.t;\n id_loc : tag loc;\n clty: class_declaration;\n ty_id: Ident.t;\n cltydef: class_type_declaration;\n obj_id: Ident.t;\n obj_abbr: type_declaration;\n cl_id: Ident.t;\n cl_abbr: type_declaration;\n arity: int;\n pub_meths: string list;\n coe: Warnings.loc list;\n req: 'a Typedtree.class_infos;\n}\n\ntype kind =\n | Object\n | Class\n | Class_type\n\ntype final =\n | Final\n | Not_final\n\nlet kind_of_final = function\n | Final -> Object\n | Not_final -> Class\n\ntype error =\n | Unconsistent_constraint of Errortrace.unification_error\n | Field_type_mismatch of string * string * Errortrace.unification_error\n | Unexpected_field of type_expr * string\n | Structure_expected of class_type\n | Cannot_apply of class_type\n | Apply_wrong_label of arg_label\n | Pattern_type_clash of type_expr\n | Repeated_parameter\n | Unbound_class_2 of Longident.t\n | Unbound_class_type_2 of Longident.t\n | Abbrev_type_clash of type_expr * type_expr * type_expr\n | Constructor_type_mismatch of string * Errortrace.unification_error\n | Virtual_class of kind * string list * string list\n | Undeclared_methods of kind * string list\n | Parameter_arity_mismatch of Longident.t * int * int\n | Parameter_mismatch of Errortrace.unification_error\n | Bad_parameters of Ident.t * type_expr * type_expr\n | Class_match_failure of Ctype.class_match_failure list\n | Unbound_val of string\n | Unbound_type_var of\n (formatter -> unit) * (type_expr * bool * string * type_expr)\n | Non_generalizable_class of Ident.t * Types.class_declaration\n | Cannot_coerce_self of type_expr\n | Non_collapsable_conjunction of\n Ident.t * Types.class_declaration * Errortrace.unification_error\n | Self_clash of Errortrace.unification_error\n | Mutability_mismatch of string * mutable_flag\n | No_overriding of string * string\n | Duplicate of string * string\n | Closing_self_type of class_signature\n\nexception Error of Location.t * Env.t * error\nexception Error_forward of Location.error\n\nopen Typedtree\n\nlet type_open_descr :\n (?used_slot:bool ref -> Env.t -> Parsetree.open_description\n -> open_description * Env.t) ref =\n ref (fun ?used_slot:_ _ -> assert false)\n\nlet ctyp desc typ env loc =\n { ctyp_desc = desc; ctyp_type = typ; ctyp_loc = loc; ctyp_env = env;\n ctyp_attributes = [] }\n\n(*\n Path associated to the temporary class type of a class being typed\n (its constructor is not available).\n*)\nlet unbound_class =\n Path.Pident (Ident.create_local \"*undef*\")\n\n\n (************************************)\n (* Some operations on class types *)\n (************************************)\n\nlet extract_constraints cty =\n let sign = Btype.signature_of_class_type cty in\n (Btype.instance_vars sign,\n Btype.methods sign,\n Btype.concrete_methods sign)\n\n(* Record a class type *)\nlet rc node =\n Cmt_format.add_saved_type (Cmt_format.Partial_class_expr node);\n node\n\nlet update_class_signature loc env ~warn_implicit_public virt kind sign =\n let implicit_public, implicit_declared =\n Ctype.update_class_signature env sign\n in\n if implicit_declared <> [] then begin\n match virt with\n | Virtual -> () (* Should perhaps emit warning 17 here *)\n | Concrete ->\n raise (Error(loc, env, Undeclared_methods(kind, implicit_declared)))\n end;\n if warn_implicit_public && implicit_public <> [] then begin\n Location.prerr_warning\n loc (Warnings.Implicit_public_methods implicit_public)\n end\n\nlet complete_class_signature loc env virt kind sign =\n update_class_signature loc env ~warn_implicit_public:false virt kind sign;\n Ctype.hide_private_methods env sign\n\nlet complete_class_type loc env virt kind typ =\n let sign = Btype.signature_of_class_type typ in\n complete_class_signature loc env virt kind sign\n\nlet check_virtual loc env virt kind sign =\n match virt with\n | Virtual -> ()\n | Concrete ->\n match Btype.virtual_methods sign, Btype.virtual_instance_vars sign with\n | [], [] -> ()\n | meths, vars ->\n raise(Error(loc, env, Virtual_class(kind, meths, vars)))\n\n(* Return the constructor type associated to a class type *)\nlet rec constructor_type constr cty =\n match cty with\n Cty_constr (_, _, cty) ->\n constructor_type constr cty\n | Cty_signature _ ->\n constr\n | Cty_arrow (l, ty, cty) ->\n Ctype.newty (Tarrow (l, ty, constructor_type constr cty, commu_ok))\n\n (***********************************)\n (* Primitives for typing classes *)\n (***********************************)\n\nlet raise_add_method_failure loc env label sign failure =\n match (failure : Ctype.add_method_failure) with\n | Ctype.Unexpected_method ->\n raise(Error(loc, env, Unexpected_field (sign.Types.csig_self, label)))\n | Ctype.Type_mismatch trace ->\n raise(Error(loc, env, Field_type_mismatch (\"method\", label, trace)))\n\nlet raise_add_instance_variable_failure loc env label failure =\n match (failure : Ctype.add_instance_variable_failure) with\n | Ctype.Mutability_mismatch mut ->\n raise (Error(loc, env, Mutability_mismatch(label, mut)))\n | Ctype.Type_mismatch trace ->\n raise (Error(loc, env,\n Field_type_mismatch(\"instance variable\", label, trace)))\n\nlet raise_inherit_class_signature_failure loc env sign = function\n | Ctype.Self_type_mismatch trace ->\n raise(Error(loc, env, Self_clash trace))\n | Ctype.Method(label, failure) ->\n raise_add_method_failure loc env label sign failure\n | Ctype.Instance_variable(label, failure) ->\n raise_add_instance_variable_failure loc env label failure\n\nlet add_method loc env label priv virt ty sign =\n match Ctype.add_method env label priv virt ty sign with\n | () -> ()\n | exception Ctype.Add_method_failed failure ->\n raise_add_method_failure loc env label sign failure\n\nlet add_instance_variable ~strict loc env label mut virt ty sign =\n match Ctype.add_instance_variable ~strict env label mut virt ty sign with\n | () -> ()\n | exception Ctype.Add_instance_variable_failed failure ->\n raise_add_instance_variable_failure loc env label failure\n\nlet inherit_class_signature ~strict loc env sign1 sign2 =\n match Ctype.inherit_class_signature ~strict env sign1 sign2 with\n | () -> ()\n | exception Ctype.Inherit_class_signature_failed failure ->\n raise_inherit_class_signature_failure loc env sign1 failure\n\nlet inherit_class_type ~strict loc env sign1 cty2 =\n let sign2 =\n match Btype.scrape_class_type cty2 with\n | Cty_signature sign2 -> sign2\n | _ ->\n raise(Error(loc, env, Structure_expected cty2))\n in\n inherit_class_signature ~strict loc env sign1 sign2\n\nlet unify_delayed_method_type loc env label ty expected_ty=\n match Ctype.unify env ty expected_ty with\n | () -> ()\n | exception Ctype.Unify trace ->\n raise(Error(loc, env, Field_type_mismatch (\"method\", label, trace)))\n\nlet type_constraint val_env sty sty' loc =\n let cty = transl_simple_type val_env false sty in\n let ty = cty.ctyp_type in\n let cty' = transl_simple_type val_env false sty' in\n let ty' = cty'.ctyp_type in\n begin\n try Ctype.unify val_env ty ty' with Ctype.Unify err ->\n raise(Error(loc, val_env, Unconsistent_constraint err));\n end;\n (cty, cty')\n\nlet make_method loc cl_num expr =\n let open Ast_helper in\n let mkid s = mkloc s loc in\n Exp.fun_ ~loc:expr.pexp_loc Nolabel None\n (Pat.alias ~loc (Pat.var ~loc (mkid \"self-*\")) (mkid (\"self-\" ^ cl_num)))\n expr\n\n(*******************************)\n\nlet delayed_meth_specs = ref []\n\nlet rec class_type_field env sign self_scope ctf =\n let loc = ctf.pctf_loc in\n let mkctf desc =\n { ctf_desc = desc; ctf_loc = loc; ctf_attributes = ctf.pctf_attributes }\n in\n let mkctf_with_attrs f =\n Builtin_attributes.warning_scope ctf.pctf_attributes\n (fun () -> mkctf (f ()))\n in\n match ctf.pctf_desc with\n | Pctf_inherit sparent ->\n mkctf_with_attrs\n (fun () ->\n let parent = class_type env Virtual self_scope sparent in\n complete_class_type parent.cltyp_loc\n env Virtual Class_type parent.cltyp_type;\n inherit_class_type ~strict:false loc env sign parent.cltyp_type;\n Tctf_inherit parent)\n | Pctf_val ({txt=lab}, mut, virt, sty) ->\n mkctf_with_attrs\n (fun () ->\n let cty = transl_simple_type env false sty in\n let ty = cty.ctyp_type in\n add_instance_variable ~strict:false loc env lab mut virt ty sign;\n Tctf_val (lab, mut, virt, cty))\n\n | Pctf_method ({txt=lab}, priv, virt, sty) ->\n mkctf_with_attrs\n (fun () ->\n let sty = Ast_helper.Typ.force_poly sty in\n match sty.ptyp_desc, priv with\n | Ptyp_poly ([],sty'), Public ->\n let expected_ty = Ctype.newvar () in\n add_method loc env lab priv virt expected_ty sign;\n let returned_cty = ctyp Ttyp_any (Ctype.newty Tnil) env loc in\n delayed_meth_specs :=\n Warnings.mk_lazy (fun () ->\n let cty = transl_simple_type_univars env sty' in\n let ty = cty.ctyp_type in\n unify_delayed_method_type loc env lab ty expected_ty;\n returned_cty.ctyp_desc <- Ttyp_poly ([], cty);\n returned_cty.ctyp_type <- ty;\n ) :: !delayed_meth_specs;\n Tctf_method (lab, priv, virt, returned_cty)\n | _ ->\n let cty = transl_simple_type env false sty in\n let ty = cty.ctyp_type in\n add_method loc env lab priv virt ty sign;\n Tctf_method (lab, priv, virt, cty))\n\n | Pctf_constraint (sty, sty') ->\n mkctf_with_attrs\n (fun () ->\n let (cty, cty') = type_constraint env sty sty' ctf.pctf_loc in\n Tctf_constraint (cty, cty'))\n\n | Pctf_attribute x ->\n Builtin_attributes.warning_attribute x;\n mkctf (Tctf_attribute x)\n\n | Pctf_extension ext ->\n raise (Error_forward (Builtin_attributes.error_of_extension ext))\n\nand class_signature virt env pcsig self_scope loc =\n let {pcsig_self=sty; pcsig_fields=psign} = pcsig in\n let sign = Ctype.new_class_signature () in\n (* Introduce a dummy method preventing self type from being closed. *)\n Ctype.add_dummy_method env ~scope:self_scope sign;\n\n let self_cty = transl_simple_type env false sty in\n let self_type = self_cty.ctyp_type in\n begin try\n Ctype.unify env self_type sign.csig_self\n with Ctype.Unify _ ->\n raise(Error(sty.ptyp_loc, env, Pattern_type_clash self_type))\n end;\n\n (* Class type fields *)\n let fields =\n Builtin_attributes.warning_scope []\n (fun () -> List.map (class_type_field env sign self_scope) psign)\n in\n check_virtual loc env virt Class_type sign;\n { csig_self = self_cty;\n csig_fields = fields;\n csig_type = sign; }\n\nand class_type env virt self_scope scty =\n Builtin_attributes.warning_scope scty.pcty_attributes\n (fun () -> class_type_aux env virt self_scope scty)\n\nand class_type_aux env virt self_scope scty =\n let cltyp desc typ =\n {\n cltyp_desc = desc;\n cltyp_type = typ;\n cltyp_loc = scty.pcty_loc;\n cltyp_env = env;\n cltyp_attributes = scty.pcty_attributes;\n }\n in\n match scty.pcty_desc with\n | Pcty_constr (lid, styl) ->\n let (path, decl) = Env.lookup_cltype ~loc:scty.pcty_loc lid.txt env in\n if Path.same decl.clty_path unbound_class then\n raise(Error(scty.pcty_loc, env, Unbound_class_type_2 lid.txt));\n let (params, clty) =\n Ctype.instance_class decl.clty_params decl.clty_type\n in\n (* Adding a dummy method to the self type prevents it from being closed /\n escaping. *)\n Ctype.add_dummy_method env ~scope:self_scope\n (Btype.signature_of_class_type clty);\n if List.length params <> List.length styl then\n raise(Error(scty.pcty_loc, env,\n Parameter_arity_mismatch (lid.txt, List.length params,\n List.length styl)));\n let ctys = List.map2\n (fun sty ty ->\n let cty' = transl_simple_type env false sty in\n let ty' = cty'.ctyp_type in\n begin\n try Ctype.unify env ty' ty with Ctype.Unify err ->\n raise(Error(sty.ptyp_loc, env, Parameter_mismatch err))\n end;\n cty'\n ) styl params\n in\n let typ = Cty_constr (path, params, clty) in\n cltyp (Tcty_constr ( path, lid , ctys)) typ\n\n | Pcty_signature pcsig ->\n let clsig = class_signature virt env pcsig self_scope scty.pcty_loc in\n let typ = Cty_signature clsig.csig_type in\n cltyp (Tcty_signature clsig) typ\n\n | Pcty_arrow (l, sty, scty) ->\n let cty = transl_simple_type env false sty in\n let ty = cty.ctyp_type in\n let ty =\n if Btype.is_optional l\n then Ctype.newty (Tconstr(Predef.path_option,[ty], ref Mnil))\n else ty in\n let clty = class_type env virt self_scope scty in\n let typ = Cty_arrow (l, ty, clty.cltyp_type) in\n cltyp (Tcty_arrow (l, cty, clty)) typ\n\n | Pcty_open (od, e) ->\n let (od, newenv) = !type_open_descr env od in\n let clty = class_type newenv virt self_scope e in\n cltyp (Tcty_open (od, clty)) clty.cltyp_type\n\n | Pcty_extension ext ->\n raise (Error_forward (Builtin_attributes.error_of_extension ext))\n\nlet class_type env virt self_scope scty =\n delayed_meth_specs := [];\n let cty = class_type env virt self_scope scty in\n List.iter Lazy.force (List.rev !delayed_meth_specs);\n delayed_meth_specs := [];\n cty\n\n(*******************************)\n\nlet enter_ancestor_val name val_env =\n Env.enter_unbound_value name Val_unbound_ancestor val_env\n\nlet enter_self_val name val_env =\n Env.enter_unbound_value name Val_unbound_self val_env\n\nlet enter_instance_var_val name val_env =\n Env.enter_unbound_value name Val_unbound_instance_variable val_env\n\nlet enter_ancestor_met ~loc name ~sign ~meths ~cl_num ~ty ~attrs met_env =\n let check s = Warnings.Unused_ancestor s in\n let kind = Val_anc (sign, meths, cl_num) in\n let desc =\n { val_type = ty; val_kind = kind;\n val_attributes = attrs;\n Types.val_loc = loc;\n val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) }\n in\n Env.enter_value ~check name desc met_env\n\nlet add_self_met loc id sign self_var_kind vars cl_num\n as_var ty attrs met_env =\n let check =\n if as_var then (fun s -> Warnings.Unused_var s)\n else (fun s -> Warnings.Unused_var_strict s)\n in\n let kind = Val_self (sign, self_var_kind, vars, cl_num) in\n let desc =\n { val_type = ty; val_kind = kind;\n val_attributes = attrs;\n Types.val_loc = loc;\n val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) }\n in\n Env.add_value ~check id desc met_env\n\nlet add_instance_var_met loc label id sign cl_num attrs met_env =\n let mut, ty =\n match Vars.find label sign.csig_vars with\n | (mut, _, ty) -> mut, ty\n | exception Not_found -> assert false\n in\n let kind = Val_ivar (mut, cl_num) in\n let desc =\n { val_type = ty; val_kind = kind;\n val_attributes = attrs;\n Types.val_loc = loc;\n val_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) }\n in\n Env.add_value id desc met_env\n\nlet add_instance_vars_met loc vars sign cl_num met_env =\n List.fold_left\n (fun met_env (label, id) ->\n add_instance_var_met loc label id sign cl_num [] met_env)\n met_env vars\n\ntype intermediate_class_field =\n | Inherit of\n { override : override_flag;\n parent : class_expr;\n super : string option;\n inherited_vars : (string * Ident.t) list;\n super_meths : (string * Ident.t) list;\n loc : Location.t;\n attributes : attribute list; }\n | Virtual_val of\n { label : string loc;\n mut : mutable_flag;\n id : Ident.t;\n cty : core_type;\n already_declared : bool;\n loc : Location.t;\n attributes : attribute list; }\n | Concrete_val of\n { label : string loc;\n mut : mutable_flag;\n id : Ident.t;\n override : override_flag;\n definition : expression;\n already_declared : bool;\n loc : Location.t;\n attributes : attribute list; }\n | Virtual_method of\n { label : string loc;\n priv : private_flag;\n cty : core_type;\n loc : Location.t;\n attributes : attribute list; }\n | Concrete_method of\n { label : string loc;\n priv : private_flag;\n override : override_flag;\n sdefinition : Parsetree.expression;\n warning_state : Warnings.state;\n loc : Location.t;\n attributes : attribute list; }\n | Constraint of\n { cty1 : core_type;\n cty2 : core_type;\n loc : Location.t;\n attributes : attribute list; }\n | Initializer of\n { sexpr : Parsetree.expression;\n warning_state : Warnings.state;\n loc : Location.t;\n attributes : attribute list; }\n | Attribute of\n { attribute : attribute;\n loc : Location.t;\n attributes : attribute list; }\n\ntype first_pass_accummulater =\n { rev_fields : intermediate_class_field list;\n val_env : Env.t;\n par_env : Env.t;\n concrete_meths : MethSet.t;\n concrete_vals : VarSet.t;\n local_meths : MethSet.t;\n local_vals : VarSet.t;\n vars : Ident.t Vars.t;\n meths : Ident.t Meths.t; }\n\nlet rec class_field_first_pass self_loc cl_num sign self_scope acc cf =\n let { rev_fields; val_env; par_env; concrete_meths; concrete_vals;\n local_meths; local_vals; vars; meths } = acc\n in\n let loc = cf.pcf_loc in\n let attributes = cf.pcf_attributes in\n let with_attrs f = Builtin_attributes.warning_scope attributes f in\n match cf.pcf_desc with\n | Pcf_inherit (override, sparent, super) ->\n with_attrs\n (fun () ->\n let parent =\n class_expr cl_num val_env par_env\n Virtual self_scope sparent\n in\n complete_class_type parent.cl_loc\n par_env Virtual Class parent.cl_type;\n inherit_class_type ~strict:true loc val_env sign parent.cl_type;\n let parent_sign = Btype.signature_of_class_type parent.cl_type in\n let new_concrete_meths = Btype.concrete_methods parent_sign in\n let new_concrete_vals = Btype.concrete_instance_vars parent_sign in\n let over_meths = MethSet.inter new_concrete_meths concrete_meths in\n let over_vals = VarSet.inter new_concrete_vals concrete_vals in\n begin match override with\n | Fresh ->\n let cname =\n match parent.cl_type with\n | Cty_constr (p, _, _) -> Path.name p\n | _ -> \"inherited\"\n in\n if not (MethSet.is_empty over_meths) then\n Location.prerr_warning loc\n (Warnings.Method_override\n (cname :: MethSet.elements over_meths));\n if not (VarSet.is_empty over_vals) then\n Location.prerr_warning loc\n (Warnings.Instance_variable_override\n (cname :: VarSet.elements over_vals));\n | Override ->\n if MethSet.is_empty over_meths && VarSet.is_empty over_vals then\n raise (Error(loc, val_env, No_overriding (\"\",\"\")))\n end;\n let concrete_vals = VarSet.union new_concrete_vals concrete_vals in\n let concrete_meths =\n MethSet.union new_concrete_meths concrete_meths\n in\n let val_env, par_env, inherited_vars, vars =\n Vars.fold\n (fun label _ (val_env, par_env, inherited_vars, vars) ->\n let val_env = enter_instance_var_val label val_env in\n let par_env = enter_instance_var_val label par_env in\n let id = Ident.create_local label in\n let inherited_vars = (label, id) :: inherited_vars in\n let vars = Vars.add label id vars in\n (val_env, par_env, inherited_vars, vars))\n parent_sign.csig_vars (val_env, par_env, [], vars)\n in\n let meths =\n Meths.fold\n (fun label _ meths ->\n if Meths.mem label meths then meths\n else Meths.add label (Ident.create_local label) meths)\n parent_sign.csig_meths meths\n in\n (* Methods available through super *)\n let super_meths =\n MethSet.fold\n (fun label acc -> (label, Ident.create_local label) :: acc)\n new_concrete_meths []\n in\n (* Super *)\n let (val_env, par_env, super) =\n match super with\n | None -> (val_env, par_env, None)\n | Some {txt=name} ->\n let val_env = enter_ancestor_val name val_env in\n let par_env = enter_ancestor_val name par_env in\n (val_env, par_env, Some name)\n in\n let field =\n Inherit\n { override; parent; super; inherited_vars;\n super_meths; loc; attributes }\n in\n let rev_fields = field :: rev_fields in\n { acc with rev_fields; val_env; par_env;\n concrete_meths; concrete_vals; vars; meths })\n | Pcf_val (label, mut, Cfk_virtual styp) ->\n with_attrs\n (fun () ->\n if !Clflags.principal then Ctype.begin_def ();\n let cty = Typetexp.transl_simple_type val_env false styp in\n let ty = cty.ctyp_type in\n if !Clflags.principal then begin\n Ctype.end_def ();\n Ctype.generalize_structure ty\n end;\n add_instance_variable ~strict:true loc val_env\n label.txt mut Virtual ty sign;\n let already_declared, val_env, par_env, id, vars =\n match Vars.find label.txt vars with\n | id -> true, val_env, par_env, id, vars\n | exception Not_found ->\n let name = label.txt in\n let val_env = enter_instance_var_val name val_env in\n let par_env = enter_instance_var_val name par_env in\n let id = Ident.create_local name in\n let vars = Vars.add label.txt id vars in\n false, val_env, par_env, id, vars\n in\n let field =\n Virtual_val\n { label; mut; id; cty; already_declared; loc; attributes }\n in\n let rev_fields = field :: rev_fields in\n { acc with rev_fields; val_env; par_env; vars })\n | Pcf_val (label, mut, Cfk_concrete (override, sdefinition)) ->\n with_attrs\n (fun () ->\n if VarSet.mem label.txt local_vals then\n raise(Error(loc, val_env,\n Duplicate (\"instance variable\", label.txt)));\n if VarSet.mem label.txt concrete_vals then begin\n if override = Fresh then\n Location.prerr_warning label.loc\n (Warnings.Instance_variable_override[label.txt])\n end else begin\n if override = Override then\n raise(Error(loc, val_env,\n No_overriding (\"instance variable\", label.txt)))\n end;\n if !Clflags.principal then Ctype.begin_def ();\n let definition = type_exp val_env sdefinition in\n if !Clflags.principal then begin\n Ctype.end_def ();\n Ctype.generalize_structure definition.exp_type\n end;\n add_instance_variable ~strict:true loc val_env\n label.txt mut Concrete definition.exp_type sign;\n let already_declared, val_env, par_env, id, vars =\n match Vars.find label.txt vars with\n | id -> true, val_env, par_env, id, vars\n | exception Not_found ->\n let name = label.txt in\n let val_env = enter_instance_var_val name val_env in\n let par_env = enter_instance_var_val name par_env in\n let id = Ident.create_local name in\n let vars = Vars.add label.txt id vars in\n false, val_env, par_env, id, vars\n in\n let field =\n Concrete_val\n { label; mut; id; override; definition;\n already_declared; loc; attributes }\n in\n let rev_fields = field :: rev_fields in\n let concrete_vals = VarSet.add label.txt concrete_vals in\n let local_vals = VarSet.add label.txt local_vals in\n { acc with rev_fields; val_env; par_env;\n concrete_vals; local_vals; vars })\n\n | Pcf_method (label, priv, Cfk_virtual sty) ->\n with_attrs\n (fun () ->\n let sty = Ast_helper.Typ.force_poly sty in\n let cty = transl_simple_type val_env false sty in\n let ty = cty.ctyp_type in\n add_method loc val_env label.txt priv Virtual ty sign;\n let meths =\n if Meths.mem label.txt meths then meths\n else Meths.add label.txt (Ident.create_local label.txt) meths\n in\n let field =\n Virtual_method { label; priv; cty; loc; attributes }\n in\n let rev_fields = field :: rev_fields in\n { acc with rev_fields; meths })\n\n | Pcf_method (label, priv, Cfk_concrete (override, expr)) ->\n with_attrs\n (fun () ->\n if MethSet.mem label.txt local_meths then\n raise(Error(loc, val_env, Duplicate (\"method\", label.txt)));\n if MethSet.mem label.txt concrete_meths then begin\n if override = Fresh then begin\n Location.prerr_warning loc\n (Warnings.Method_override [label.txt])\n end\n end else begin\n if override = Override then begin\n raise(Error(loc, val_env, No_overriding(\"method\", label.txt)))\n end\n end;\n let expr =\n match expr.pexp_desc with\n | Pexp_poly _ -> expr\n | _ -> Ast_helper.Exp.poly ~loc:expr.pexp_loc expr None\n in\n let sbody, sty =\n match expr.pexp_desc with\n | Pexp_poly (sbody, sty) -> sbody, sty\n | _ -> assert false\n in\n let ty =\n match sty with\n | None -> Ctype.newvar ()\n | Some sty ->\n let sty = Ast_helper.Typ.force_poly sty in\n let cty' =\n Typetexp.transl_simple_type val_env false sty\n in\n cty'.ctyp_type\n in\n add_method loc val_env label.txt priv Concrete ty sign;\n begin\n try\n match get_desc ty with\n | Tvar _ ->\n let ty' = Ctype.newvar () in\n Ctype.unify val_env (Ctype.newty (Tpoly (ty', []))) ty;\n Ctype.unify val_env (type_approx val_env sbody) ty'\n | Tpoly (ty1, tl) ->\n let _, ty1' = Ctype.instance_poly false tl ty1 in\n let ty2 = type_approx val_env sbody in\n Ctype.unify val_env ty2 ty1'\n | _ -> assert false\n with Ctype.Unify err ->\n raise(Error(loc, val_env,\n Field_type_mismatch (\"method\", label.txt, err)))\n end;\n let meths =\n if Meths.mem label.txt meths then meths\n else Meths.add label.txt (Ident.create_local label.txt) meths\n in\n let sdefinition = make_method self_loc cl_num expr in\n let warning_state = Warnings.backup () in\n let field =\n Concrete_method\n { label; priv; override; sdefinition;\n warning_state; loc; attributes }\n in\n let rev_fields = field :: rev_fields in\n let concrete_meths = MethSet.add label.txt concrete_meths in\n let local_meths = MethSet.add label.txt local_meths in\n { acc with rev_fields; concrete_meths; local_meths; meths })\n\n | Pcf_constraint (sty1, sty2) ->\n with_attrs\n (fun () ->\n let (cty1, cty2) = type_constraint val_env sty1 sty2 loc in\n let field =\n Constraint { cty1; cty2; loc; attributes }\n in\n let rev_fields = field :: rev_fields in\n { acc with rev_fields })\n\n | Pcf_initializer sexpr ->\n with_attrs\n (fun () ->\n let sexpr = make_method self_loc cl_num sexpr in\n let warning_state = Warnings.backup () in\n let field =\n Initializer { sexpr; warning_state; loc; attributes }\n in\n let rev_fields = field :: rev_fields in\n { acc with rev_fields })\n | Pcf_attribute attribute ->\n Builtin_attributes.warning_attribute attribute;\n let field = Attribute { attribute; loc; attributes } in\n let rev_fields = field :: rev_fields in\n { acc with rev_fields }\n | Pcf_extension ext ->\n raise (Error_forward (Builtin_attributes.error_of_extension ext))\n\nand class_fields_first_pass self_loc cl_num sign self_scope\n val_env par_env cfs =\n let rev_fields = [] in\n let concrete_meths = MethSet.empty in\n let concrete_vals = VarSet.empty in\n let local_meths = MethSet.empty in\n let local_vals = VarSet.empty in\n let vars = Vars.empty in\n let meths = Meths.empty in\n let init_acc =\n { rev_fields; val_env; par_env;\n concrete_meths; concrete_vals;\n local_meths; local_vals; vars; meths }\n in\n let acc =\n Builtin_attributes.warning_scope []\n (fun () ->\n List.fold_left\n (class_field_first_pass self_loc cl_num sign self_scope)\n init_acc cfs)\n in\n List.rev acc.rev_fields, acc.vars, acc.meths\n\nand class_field_second_pass cl_num sign met_env field =\n let mkcf desc loc attrs =\n { cf_desc = desc; cf_loc = loc; cf_attributes = attrs }\n in\n match field with\n | Inherit { override; parent; super;\n inherited_vars; super_meths; loc; attributes } ->\n let met_env =\n add_instance_vars_met loc inherited_vars sign cl_num met_env\n in\n let met_env =\n match super with\n | None -> met_env\n | Some name ->\n let meths =\n List.fold_left\n (fun acc (label, id) -> Meths.add label id acc)\n Meths.empty super_meths\n in\n let ty = Btype.self_type parent.cl_type in\n let attrs = [] in\n let _id, met_env =\n enter_ancestor_met ~loc name ~sign ~meths\n ~cl_num ~ty ~attrs met_env\n in\n met_env\n in\n let desc =\n Tcf_inherit(override, parent, super, inherited_vars, super_meths)\n in\n met_env, mkcf desc loc attributes\n | Virtual_val { label; mut; id; cty; already_declared; loc; attributes } ->\n let met_env =\n if already_declared then met_env\n else begin\n add_instance_var_met loc label.txt id sign cl_num attributes met_env\n end\n in\n let kind = Tcfk_virtual cty in\n let desc = Tcf_val(label, mut, id, kind, already_declared) in\n met_env, mkcf desc loc attributes\n | Concrete_val { label; mut; id; override;\n definition; already_declared; loc; attributes } ->\n let met_env =\n if already_declared then met_env\n else begin\n add_instance_var_met loc label.txt id sign cl_num attributes met_env\n end\n in\n let kind = Tcfk_concrete(override, definition) in\n let desc = Tcf_val(label, mut, id, kind, already_declared) in\n met_env, mkcf desc loc attributes\n | Virtual_method { label; priv; cty; loc; attributes } ->\n let kind = Tcfk_virtual cty in\n let desc = Tcf_method(label, priv, kind) in\n met_env, mkcf desc loc attributes\n | Concrete_method { label; priv; override;\n sdefinition; warning_state; loc; attributes } ->\n Warnings.with_state warning_state\n (fun () ->\n let ty = Btype.method_type label.txt sign in\n let self_type = sign.Types.csig_self in\n let meth_type =\n mk_expected\n (Btype.newgenty (Tarrow(Nolabel, self_type, ty, commu_ok)))\n in\n Ctype.raise_nongen_level ();\n let texp = type_expect met_env sdefinition meth_type in\n Ctype.end_def ();\n let kind = Tcfk_concrete (override, texp) in\n let desc = Tcf_method(label, priv, kind) in\n met_env, mkcf desc loc attributes)\n | Constraint { cty1; cty2; loc; attributes } ->\n let desc = Tcf_constraint(cty1, cty2) in\n met_env, mkcf desc loc attributes\n | Initializer { sexpr; warning_state; loc; attributes } ->\n Warnings.with_state warning_state\n (fun () ->\n Ctype.raise_nongen_level ();\n let unit_type = Ctype.instance Predef.type_unit in\n let self_type = sign.Types.csig_self in\n let meth_type =\n mk_expected\n (Ctype.newty (Tarrow (Nolabel, self_type, unit_type, commu_ok)))\n in\n let texp = type_expect met_env sexpr meth_type in\n Ctype.end_def ();\n let desc = Tcf_initializer texp in\n met_env, mkcf desc loc attributes)\n | Attribute { attribute; loc; attributes; } ->\n let desc = Tcf_attribute attribute in\n met_env, mkcf desc loc attributes\n\nand class_fields_second_pass cl_num sign met_env fields =\n let _, rev_cfs =\n List.fold_left\n (fun (met_env, cfs) field ->\n let met_env, cf =\n class_field_second_pass cl_num sign met_env field\n in\n met_env, cf :: cfs)\n (met_env, []) fields\n in\n List.rev rev_cfs\n\n(* N.B. the self type of a final object type doesn't contain a dummy method in\n the beginning.\n We only explicitly add a dummy method to class definitions (and class (type)\n declarations)), which are later removed (made absent) by [final_decl].\n\n If we ever find a dummy method in a final object self type, it means that\n somehow we've unified the self type of the object with the self type of a not\n yet finished class.\n When this happens, we cannot close the object type and must error. *)\nand class_structure cl_num virt self_scope final val_env met_env loc\n { pcstr_self = spat; pcstr_fields = str } =\n (* Environment for substructures *)\n let par_env = met_env in\n\n (* Location of self. Used for locations of self arguments *)\n let self_loc = {spat.ppat_loc with Location.loc_ghost = true} in\n\n let sign = Ctype.new_class_signature () in\n\n (* Adding a dummy method to the signature prevents it from being closed /\n escaping. That isn't needed for objects though. *)\n begin match final with\n | Not_final -> Ctype.add_dummy_method val_env ~scope:self_scope sign;\n | Final -> ()\n end;\n\n (* Self binder *)\n let (self_pat, self_pat_vars) = type_self_pattern val_env spat in\n let val_env, par_env =\n List.fold_right\n (fun {pv_id; _} (val_env, par_env) ->\n let name = Ident.name pv_id in\n let val_env = enter_self_val name val_env in\n let par_env = enter_self_val name par_env in\n val_env, par_env)\n self_pat_vars (val_env, par_env)\n in\n\n (* Check that the binder has a correct type *)\n begin try Ctype.unify val_env self_pat.pat_type sign.csig_self with\n Ctype.Unify _ ->\n raise(Error(spat.ppat_loc, val_env,\n Pattern_type_clash self_pat.pat_type))\n end;\n\n (* Typing of class fields *)\n let (fields, vars, meths) =\n class_fields_first_pass self_loc cl_num sign self_scope\n val_env par_env str\n in\n let kind = kind_of_final final in\n\n (* Check for unexpected virtual methods *)\n check_virtual loc val_env virt kind sign;\n\n (* Update the class signature *)\n update_class_signature loc val_env\n ~warn_implicit_public:false virt kind sign;\n\n (* Close the signature if it is final *)\n begin match final with\n | Not_final -> ()\n | Final ->\n if not (Ctype.close_class_signature val_env sign) then\n raise(Error(loc, val_env, Closing_self_type sign));\n end;\n (* Typing of method bodies *)\n Ctype.generalize_class_signature_spine val_env sign;\n let self_var_kind =\n match virt with\n | Virtual -> Self_virtual(ref meths)\n | Concrete -> Self_concrete meths\n in\n let met_env =\n List.fold_right\n (fun {pv_id; pv_type; pv_loc; pv_as_var; pv_attributes} met_env ->\n add_self_met pv_loc pv_id sign self_var_kind vars\n cl_num pv_as_var pv_type pv_attributes met_env)\n self_pat_vars met_env\n in\n let fields =\n class_fields_second_pass cl_num sign met_env fields\n in\n\n (* Update the class signature and warn about public methods made private *)\n update_class_signature loc val_env\n ~warn_implicit_public:true virt kind sign;\n\n let meths =\n match self_var_kind with\n | Self_virtual meths_ref -> !meths_ref\n | Self_concrete meths -> meths\n in\n { cstr_self = self_pat;\n cstr_fields = fields;\n cstr_type = sign;\n cstr_meths = meths; }\n\nand class_expr cl_num val_env met_env virt self_scope scl =\n Builtin_attributes.warning_scope scl.pcl_attributes\n (fun () -> class_expr_aux cl_num val_env met_env virt self_scope scl)\n\nand class_expr_aux cl_num val_env met_env virt self_scope scl =\n match scl.pcl_desc with\n | Pcl_constr (lid, styl) ->\n let (path, decl) = Env.lookup_class ~loc:scl.pcl_loc lid.txt val_env in\n if Path.same decl.cty_path unbound_class then\n raise(Error(scl.pcl_loc, val_env, Unbound_class_2 lid.txt));\n let tyl = List.map\n (fun sty -> transl_simple_type val_env false sty)\n styl\n in\n let (params, clty) =\n Ctype.instance_class decl.cty_params decl.cty_type\n in\n let clty' = Btype.abbreviate_class_type path params clty in\n (* Adding a dummy method to the self type prevents it from being closed /\n escaping. *)\n Ctype.add_dummy_method val_env ~scope:self_scope\n (Btype.signature_of_class_type clty');\n if List.length params <> List.length tyl then\n raise(Error(scl.pcl_loc, val_env,\n Parameter_arity_mismatch (lid.txt, List.length params,\n List.length tyl)));\n List.iter2\n (fun cty' ty ->\n let ty' = cty'.ctyp_type in\n try Ctype.unify val_env ty' ty with Ctype.Unify err ->\n raise(Error(cty'.ctyp_loc, val_env, Parameter_mismatch err)))\n tyl params;\n let cl =\n rc {cl_desc = Tcl_ident (path, lid, tyl);\n cl_loc = scl.pcl_loc;\n cl_type = clty';\n cl_env = val_env;\n cl_attributes = scl.pcl_attributes;\n }\n in\n let (vals, meths, concrs) = extract_constraints clty in\n rc {cl_desc = Tcl_constraint (cl, None, vals, meths, concrs);\n cl_loc = scl.pcl_loc;\n cl_type = clty';\n cl_env = val_env;\n cl_attributes = []; (* attributes are kept on the inner cl node *)\n }\n | Pcl_structure cl_str ->\n let desc =\n class_structure cl_num virt self_scope Not_final\n val_env met_env scl.pcl_loc cl_str\n in\n rc {cl_desc = Tcl_structure desc;\n cl_loc = scl.pcl_loc;\n cl_type = Cty_signature desc.cstr_type;\n cl_env = val_env;\n cl_attributes = scl.pcl_attributes;\n }\n | Pcl_fun (l, Some default, spat, sbody) ->\n let loc = default.pexp_loc in\n let open Ast_helper in\n let scases = [\n Exp.case\n (Pat.construct ~loc\n (mknoloc (Longident.(Ldot (Lident \"*predef*\", \"Some\"))))\n (Some ([], Pat.var ~loc (mknoloc \"*sth*\"))))\n (Exp.ident ~loc (mknoloc (Longident.Lident \"*sth*\")));\n\n Exp.case\n (Pat.construct ~loc\n (mknoloc (Longident.(Ldot (Lident \"*predef*\", \"None\"))))\n None)\n default;\n ]\n in\n let smatch =\n Exp.match_ ~loc (Exp.ident ~loc (mknoloc (Longident.Lident \"*opt*\")))\n scases\n in\n let sfun =\n Cl.fun_ ~loc:scl.pcl_loc\n l None\n (Pat.var ~loc (mknoloc \"*opt*\"))\n (Cl.let_ ~loc:scl.pcl_loc Nonrecursive [Vb.mk spat smatch] sbody)\n (* Note: we don't put the '#default' attribute, as it\n is not detected for class-level let bindings. See #5975.*)\n in\n class_expr cl_num val_env met_env virt self_scope sfun\n | Pcl_fun (l, None, spat, scl') ->\n if !Clflags.principal then Ctype.begin_def ();\n let (pat, pv, val_env', met_env) =\n Typecore.type_class_arg_pattern cl_num val_env met_env l spat\n in\n if !Clflags.principal then begin\n Ctype.end_def ();\n let gen {pat_type = ty} = Ctype.generalize_structure ty in\n iter_pattern gen pat\n end;\n let pv =\n List.map\n begin fun (id, id', _ty) ->\n let path = Pident id' in\n (* do not mark the value as being used *)\n let vd = Env.find_value path val_env' in\n (id,\n {exp_desc =\n Texp_ident(path, mknoloc (Longident.Lident (Ident.name id)), vd);\n exp_loc = Location.none; exp_extra = [];\n exp_type = Ctype.instance vd.val_type;\n exp_attributes = []; (* check *)\n exp_env = val_env'})\n end\n pv\n in\n let rec not_nolabel_function = function\n | Cty_arrow(Nolabel, _, _) -> false\n | Cty_arrow(_, _, cty) -> not_nolabel_function cty\n | _ -> true\n in\n let partial =\n let dummy = type_exp val_env (Ast_helper.Exp.unreachable ()) in\n Typecore.check_partial val_env pat.pat_type pat.pat_loc\n [{c_lhs = pat; c_guard = None; c_rhs = dummy}]\n in\n Ctype.raise_nongen_level ();\n let cl = class_expr cl_num val_env' met_env virt self_scope scl' in\n Ctype.end_def ();\n if Btype.is_optional l && not_nolabel_function cl.cl_type then\n Location.prerr_warning pat.pat_loc\n Warnings.Unerasable_optional_argument;\n rc {cl_desc = Tcl_fun (l, pat, pv, cl, partial);\n cl_loc = scl.pcl_loc;\n cl_type = Cty_arrow\n (l, Ctype.instance pat.pat_type, cl.cl_type);\n cl_env = val_env;\n cl_attributes = scl.pcl_attributes;\n }\n | Pcl_apply (scl', sargs) ->\n assert (sargs <> []);\n if !Clflags.principal then Ctype.begin_def ();\n let cl = class_expr cl_num val_env met_env virt self_scope scl' in\n if !Clflags.principal then begin\n Ctype.end_def ();\n Ctype.generalize_class_type_structure cl.cl_type;\n end;\n let rec nonopt_labels ls ty_fun =\n match ty_fun with\n | Cty_arrow (l, _, ty_res) ->\n if Btype.is_optional l then nonopt_labels ls ty_res\n else nonopt_labels (l::ls) ty_res\n | _ -> ls\n in\n let ignore_labels =\n !Clflags.classic ||\n let labels = nonopt_labels [] cl.cl_type in\n List.length labels = List.length sargs &&\n List.for_all (fun (l,_) -> l = Nolabel) sargs &&\n List.exists (fun l -> l <> Nolabel) labels &&\n begin\n Location.prerr_warning\n cl.cl_loc\n (Warnings.Labels_omitted\n (List.map Printtyp.string_of_label\n (List.filter ((<>) Nolabel) labels)));\n true\n end\n in\n let rec type_args args omitted ty_fun ty_fun0 sargs =\n match ty_fun, ty_fun0 with\n | Cty_arrow (l, ty, ty_fun), Cty_arrow (_, ty0, ty_fun0)\n when sargs <> [] ->\n let name = Btype.label_name l\n and optional = Btype.is_optional l in\n let use_arg sarg l' =\n Some (\n if not optional || Btype.is_optional l' then\n type_argument val_env sarg ty ty0\n else\n let ty' = extract_option_type val_env ty\n and ty0' = extract_option_type val_env ty0 in\n let arg = type_argument val_env sarg ty' ty0' in\n option_some val_env arg\n )\n in\n let eliminate_optional_arg () =\n Some (option_none val_env ty0 Location.none)\n in\n let remaining_sargs, arg =\n if ignore_labels then begin\n match sargs with\n | [] -> assert false\n | (l', sarg) :: remaining_sargs ->\n if name = Btype.label_name l' ||\n (not optional && l' = Nolabel)\n then\n (remaining_sargs, use_arg sarg l')\n else if\n optional &&\n not (List.exists (fun (l, _) -> name = Btype.label_name l)\n remaining_sargs)\n then\n (sargs, eliminate_optional_arg ())\n else\n raise(Error(sarg.pexp_loc, val_env, Apply_wrong_label l'))\n end else\n match Btype.extract_label name sargs with\n | Some (l', sarg, _, remaining_sargs) ->\n if not optional && Btype.is_optional l' then\n Location.prerr_warning sarg.pexp_loc\n (Warnings.Nonoptional_label\n (Printtyp.string_of_label l));\n remaining_sargs, use_arg sarg l'\n | None ->\n sargs,\n if Btype.is_optional l && List.mem_assoc Nolabel sargs then\n eliminate_optional_arg ()\n else\n None\n in\n let omitted = if arg = None then (l,ty0) :: omitted else omitted in\n type_args ((l,arg)::args) omitted ty_fun ty_fun0 remaining_sargs\n | _ ->\n match sargs with\n (l, sarg0)::_ ->\n if omitted <> [] then\n raise(Error(sarg0.pexp_loc, val_env, Apply_wrong_label l))\n else\n raise(Error(cl.cl_loc, val_env, Cannot_apply cl.cl_type))\n | [] ->\n (List.rev args,\n List.fold_left\n (fun ty_fun (l,ty) -> Cty_arrow(l,ty,ty_fun))\n ty_fun0 omitted)\n in\n let (args, cty) =\n let (_, ty_fun0) = Ctype.instance_class [] cl.cl_type in\n type_args [] [] cl.cl_type ty_fun0 sargs\n in\n rc {cl_desc = Tcl_apply (cl, args);\n cl_loc = scl.pcl_loc;\n cl_type = cty;\n cl_env = val_env;\n cl_attributes = scl.pcl_attributes;\n }\n | Pcl_let (rec_flag, sdefs, scl') ->\n let (defs, val_env) =\n Typecore.type_let In_class_def val_env rec_flag sdefs in\n let (vals, met_env) =\n List.fold_right\n (fun (id, _id_loc, _typ) (vals, met_env) ->\n let path = Pident id in\n (* do not mark the value as used *)\n let vd = Env.find_value path val_env in\n Ctype.begin_def ();\n let expr =\n {exp_desc =\n Texp_ident(path, mknoloc(Longident.Lident (Ident.name id)),vd);\n exp_loc = Location.none; exp_extra = [];\n exp_type = Ctype.instance vd.val_type;\n exp_attributes = [];\n exp_env = val_env;\n }\n in\n Ctype.end_def ();\n Ctype.generalize expr.exp_type;\n let desc =\n {val_type = expr.exp_type; val_kind = Val_ivar (Immutable,\n cl_num);\n val_attributes = [];\n Types.val_loc = vd.Types.val_loc;\n val_uid = vd.val_uid;\n }\n in\n let id' = Ident.create_local (Ident.name id) in\n ((id', expr)\n :: vals,\n Env.add_value id' desc met_env))\n (let_bound_idents_full defs)\n ([], met_env)\n in\n let cl = class_expr cl_num val_env met_env virt self_scope scl' in\n let () = if rec_flag = Recursive then\n check_recursive_bindings val_env defs\n in\n rc {cl_desc = Tcl_let (rec_flag, defs, vals, cl);\n cl_loc = scl.pcl_loc;\n cl_type = cl.cl_type;\n cl_env = val_env;\n cl_attributes = scl.pcl_attributes;\n }\n | Pcl_constraint (scl', scty) ->\n Ctype.begin_class_def ();\n let context = Typetexp.narrow () in\n let cl = class_expr cl_num val_env met_env virt self_scope scl' in\n complete_class_type cl.cl_loc val_env virt Class_type cl.cl_type;\n Typetexp.widen context;\n let context = Typetexp.narrow () in\n let clty = class_type val_env virt self_scope scty in\n complete_class_type clty.cltyp_loc val_env virt Class clty.cltyp_type;\n Typetexp.widen context;\n Ctype.end_def ();\n\n Ctype.limited_generalize_class_type\n (Btype.self_type_row cl.cl_type) cl.cl_type;\n Ctype.limited_generalize_class_type\n (Btype.self_type_row clty.cltyp_type) clty.cltyp_type;\n\n begin match\n Includeclass.class_types val_env cl.cl_type clty.cltyp_type\n with\n [] -> ()\n | error -> raise(Error(cl.cl_loc, val_env, Class_match_failure error))\n end;\n let (vals, meths, concrs) = extract_constraints clty.cltyp_type in\n let ty = snd (Ctype.instance_class [] clty.cltyp_type) in\n (* Adding a dummy method to the self type prevents it from being closed /\n escaping. *)\n Ctype.add_dummy_method val_env ~scope:self_scope\n (Btype.signature_of_class_type ty);\n rc {cl_desc = Tcl_constraint (cl, Some clty, vals, meths, concrs);\n cl_loc = scl.pcl_loc;\n cl_type = ty;\n cl_env = val_env;\n cl_attributes = scl.pcl_attributes;\n }\n | Pcl_open (pod, e) ->\n let used_slot = ref false in\n let (od, new_val_env) = !type_open_descr ~used_slot val_env pod in\n let ( _, new_met_env) = !type_open_descr ~used_slot met_env pod in\n let cl = class_expr cl_num new_val_env new_met_env virt self_scope e in\n rc {cl_desc = Tcl_open (od, cl);\n cl_loc = scl.pcl_loc;\n cl_type = cl.cl_type;\n cl_env = val_env;\n cl_attributes = scl.pcl_attributes;\n }\n | Pcl_extension ext ->\n raise (Error_forward (Builtin_attributes.error_of_extension ext))\n\n(*******************************)\n\n(* Approximate the type of the constructor to allow recursive use *)\n(* of optional parameters *)\n\nlet var_option = Predef.type_option (Btype.newgenvar ())\n\nlet rec approx_declaration cl =\n match cl.pcl_desc with\n Pcl_fun (l, _, _, cl) ->\n let arg =\n if Btype.is_optional l then Ctype.instance var_option\n else Ctype.newvar () in\n Ctype.newty (Tarrow (l, arg, approx_declaration cl, commu_ok))\n | Pcl_let (_, _, cl) ->\n approx_declaration cl\n | Pcl_constraint (cl, _) ->\n approx_declaration cl\n | _ -> Ctype.newvar ()\n\nlet rec approx_description ct =\n match ct.pcty_desc with\n Pcty_arrow (l, _, ct) ->\n let arg =\n if Btype.is_optional l then Ctype.instance var_option\n else Ctype.newvar () in\n Ctype.newty (Tarrow (l, arg, approx_description ct, commu_ok))\n | _ -> Ctype.newvar ()\n\n(*******************************)\n\nlet temp_abbrev loc env id arity uid =\n let params = ref [] in\n for _i = 1 to arity do\n params := Ctype.newvar () :: !params\n done;\n let ty = Ctype.newobj (Ctype.newvar ()) in\n let env =\n Env.add_type ~check:true id\n {type_params = !params;\n type_arity = arity;\n type_kind = Type_abstract;\n type_private = Public;\n type_manifest = Some ty;\n type_variance = Variance.unknown_signature ~injective:false ~arity;\n type_separability = Types.Separability.default_signature ~arity;\n type_is_newtype = false;\n type_expansion_scope = Btype.lowest_level;\n type_loc = loc;\n type_attributes = []; (* or keep attrs from the class decl? *)\n type_immediate = Unknown;\n type_unboxed_default = false;\n type_uid = uid;\n }\n env\n in\n (!params, ty, env)\n\nlet initial_env define_class approx\n (res, env) (cl, id, ty_id, obj_id, cl_id, uid) =\n (* Temporary abbreviations *)\n let arity = List.length cl.pci_params in\n let (obj_params, obj_ty, env) = temp_abbrev cl.pci_loc env obj_id arity uid in\n let (cl_params, cl_ty, env) = temp_abbrev cl.pci_loc env cl_id arity uid in\n\n (* Temporary type for the class constructor *)\n if !Clflags.principal then Ctype.begin_def ();\n let constr_type = approx cl.pci_expr in\n if !Clflags.principal then begin\n Ctype.end_def ();\n Ctype.generalize_structure constr_type;\n end;\n let dummy_cty = Cty_signature (Ctype.new_class_signature ()) in\n let dummy_class =\n {Types.cty_params = []; (* Dummy value *)\n cty_variance = [];\n cty_type = dummy_cty; (* Dummy value *)\n cty_path = unbound_class;\n cty_new =\n begin match cl.pci_virt with\n | Virtual -> None\n | Concrete -> Some constr_type\n end;\n cty_loc = Location.none;\n cty_attributes = [];\n cty_uid = uid;\n }\n in\n let env =\n Env.add_cltype ty_id\n {clty_params = []; (* Dummy value *)\n clty_variance = [];\n clty_type = dummy_cty; (* Dummy value *)\n clty_path = unbound_class;\n clty_loc = Location.none;\n clty_attributes = [];\n clty_uid = uid;\n }\n (\n if define_class then\n Env.add_class id dummy_class env\n else\n env\n )\n in\n ((cl, id, ty_id,\n obj_id, obj_params, obj_ty,\n cl_id, cl_params, cl_ty,\n constr_type, dummy_class)::res,\n env)\n\nlet class_infos define_class kind\n (cl, id, ty_id,\n obj_id, obj_params, obj_ty,\n cl_id, cl_params, cl_ty,\n constr_type, dummy_class)\n (res, env) =\n\n reset_type_variables ();\n Ctype.begin_class_def ();\n\n (* Introduce class parameters *)\n let ci_params =\n let make_param (sty, v) =\n try\n (transl_type_param env sty, v)\n with Already_bound ->\n raise(Error(sty.ptyp_loc, env, Repeated_parameter))\n in\n List.map make_param cl.pci_params\n in\n let params = List.map (fun (cty, _) -> cty.ctyp_type) ci_params in\n\n (* Allow self coercions (only for class declarations) *)\n let coercion_locs = ref [] in\n\n (* Type the class expression *)\n let (expr, typ) =\n try\n Typecore.self_coercion :=\n (Path.Pident obj_id, coercion_locs) :: !Typecore.self_coercion;\n let res = kind env cl.pci_virt cl.pci_expr in\n Typecore.self_coercion := List.tl !Typecore.self_coercion;\n res\n with exn ->\n Typecore.self_coercion := []; raise exn\n in\n let sign = Btype.signature_of_class_type typ in\n\n Ctype.end_def ();\n\n (* Generalize the row variable *)\n List.iter (Ctype.limited_generalize sign.csig_self_row) params;\n Ctype.limited_generalize_class_type sign.csig_self_row typ;\n\n (* Check the abbreviation for the object type *)\n let (obj_params', obj_type) = Ctype.instance_class params typ in\n let constr = Ctype.newconstr (Path.Pident obj_id) obj_params in\n begin\n let row = Btype.self_type_row obj_type in\n Ctype.unify env row (Ctype.newty Tnil);\n begin try\n List.iter2 (Ctype.unify env) obj_params obj_params'\n with Ctype.Unify _ ->\n raise(Error(cl.pci_loc, env,\n Bad_parameters (obj_id, constr,\n Ctype.newconstr (Path.Pident obj_id)\n obj_params')))\n end;\n let ty = Btype.self_type obj_type in\n begin try\n Ctype.unify env ty constr\n with Ctype.Unify _ ->\n raise(Error(cl.pci_loc, env,\n Abbrev_type_clash (constr, ty, Ctype.expand_head env constr)))\n end\n end;\n\n Ctype.set_object_name obj_id params (Btype.self_type typ);\n\n (* Check the other temporary abbreviation (#-type) *)\n begin\n let (cl_params', cl_type) = Ctype.instance_class params typ in\n let ty = Btype.self_type cl_type in\n begin try\n List.iter2 (Ctype.unify env) cl_params cl_params'\n with Ctype.Unify _ ->\n raise(Error(cl.pci_loc, env,\n Bad_parameters (cl_id,\n Ctype.newconstr (Path.Pident cl_id)\n cl_params,\n Ctype.newconstr (Path.Pident cl_id)\n cl_params')))\n end;\n begin try\n Ctype.unify env ty cl_ty\n with Ctype.Unify _ ->\n let constr = Ctype.newconstr (Path.Pident cl_id) params in\n raise(Error(cl.pci_loc, env, Abbrev_type_clash (constr, ty, cl_ty)))\n end\n end;\n\n (* Type of the class constructor *)\n begin try\n Ctype.unify env\n (constructor_type constr obj_type)\n (Ctype.instance constr_type)\n with Ctype.Unify err ->\n raise(Error(cl.pci_loc, env,\n Constructor_type_mismatch (cl.pci_name.txt, err)))\n end;\n\n (* Class and class type temporary definitions *)\n let cty_variance =\n Variance.unknown_signature ~injective:false ~arity:(List.length params) in\n let cltydef =\n {clty_params = params; clty_type = Btype.class_body typ;\n clty_variance = cty_variance;\n clty_path = Path.Pident obj_id;\n clty_loc = cl.pci_loc;\n clty_attributes = cl.pci_attributes;\n clty_uid = dummy_class.cty_uid;\n }\n and clty =\n {cty_params = params; cty_type = typ;\n cty_variance = cty_variance;\n cty_path = Path.Pident obj_id;\n cty_new =\n begin match cl.pci_virt with\n | Virtual -> None\n | Concrete -> Some constr_type\n end;\n cty_loc = cl.pci_loc;\n cty_attributes = cl.pci_attributes;\n cty_uid = dummy_class.cty_uid;\n }\n in\n dummy_class.cty_type <- typ;\n let env =\n Env.add_cltype ty_id cltydef (\n if define_class then Env.add_class id clty env else env)\n in\n\n (* Misc. *)\n let arity = Btype.class_type_arity typ in\n let pub_meths = Btype.public_methods sign in\n\n (* Final definitions *)\n let (params', typ') = Ctype.instance_class params typ in\n let cltydef =\n {clty_params = params'; clty_type = Btype.class_body typ';\n clty_variance = cty_variance;\n clty_path = Path.Pident obj_id;\n clty_loc = cl.pci_loc;\n clty_attributes = cl.pci_attributes;\n clty_uid = dummy_class.cty_uid;\n }\n and clty =\n {cty_params = params'; cty_type = typ';\n cty_variance = cty_variance;\n cty_path = Path.Pident obj_id;\n cty_new =\n begin match cl.pci_virt with\n | Virtual -> None\n | Concrete -> Some (Ctype.instance constr_type)\n end;\n cty_loc = cl.pci_loc;\n cty_attributes = cl.pci_attributes;\n cty_uid = dummy_class.cty_uid;\n }\n in\n let obj_abbr =\n let arity = List.length obj_params in\n {\n type_params = obj_params;\n type_arity = arity;\n type_kind = Type_abstract;\n type_private = Public;\n type_manifest = Some obj_ty;\n type_variance = Variance.unknown_signature ~injective:false ~arity;\n type_separability = Types.Separability.default_signature ~arity;\n type_is_newtype = false;\n type_expansion_scope = Btype.lowest_level;\n type_loc = cl.pci_loc;\n type_attributes = []; (* or keep attrs from cl? *)\n type_immediate = Unknown;\n type_unboxed_default = false;\n type_uid = dummy_class.cty_uid;\n }\n in\n let (cl_params, cl_ty) =\n Ctype.instance_parameterized_type params (Btype.self_type typ)\n in\n Ctype.set_object_name obj_id cl_params cl_ty;\n let cl_abbr =\n let arity = List.length cl_params in\n {\n type_params = cl_params;\n type_arity = arity;\n type_kind = Type_abstract;\n type_private = Public;\n type_manifest = Some cl_ty;\n type_variance = Variance.unknown_signature ~injective:false ~arity;\n type_separability = Types.Separability.default_signature ~arity;\n type_is_newtype = false;\n type_expansion_scope = Btype.lowest_level;\n type_loc = cl.pci_loc;\n type_attributes = []; (* or keep attrs from cl? *)\n type_immediate = Unknown;\n type_unboxed_default = false;\n type_uid = dummy_class.cty_uid;\n }\n in\n ((cl, id, clty, ty_id, cltydef, obj_id, obj_abbr, cl_id, cl_abbr, ci_params,\n arity, pub_meths, List.rev !coercion_locs, expr) :: res,\n env)\n\nlet final_decl env define_class\n (cl, id, clty, ty_id, cltydef, obj_id, obj_abbr, cl_id, cl_abbr, ci_params,\n arity, pub_meths, coe, expr) =\n\n begin try Ctype.collapse_conj_params env clty.cty_params\n with Ctype.Unify err ->\n raise(Error(cl.pci_loc, env, Non_collapsable_conjunction (id, clty, err)))\n end;\n\n List.iter Ctype.generalize clty.cty_params;\n Ctype.generalize_class_type clty.cty_type;\n Option.iter Ctype.generalize clty.cty_new;\n List.iter Ctype.generalize obj_abbr.type_params;\n Option.iter Ctype.generalize obj_abbr.type_manifest;\n List.iter Ctype.generalize cl_abbr.type_params;\n Option.iter Ctype.generalize cl_abbr.type_manifest;\n\n if Ctype.nongen_class_declaration clty then\n raise(Error(cl.pci_loc, env, Non_generalizable_class (id, clty)));\n\n begin match\n Ctype.closed_class clty.cty_params\n (Btype.signature_of_class_type clty.cty_type)\n with\n None -> ()\n | Some reason ->\n let printer =\n if define_class\n then function ppf -> Printtyp.class_declaration id ppf clty\n else function ppf -> Printtyp.cltype_declaration id ppf cltydef\n in\n raise(Error(cl.pci_loc, env, Unbound_type_var(printer, reason)))\n end;\n { id; clty; ty_id; cltydef; obj_id; obj_abbr; cl_id; cl_abbr; arity;\n pub_meths; coe;\n id_loc = cl.pci_name;\n req = { ci_loc = cl.pci_loc;\n ci_virt = cl.pci_virt;\n ci_params = ci_params;\n (* TODO : check that we have the correct use of identifiers *)\n ci_id_name = cl.pci_name;\n ci_id_class = id;\n ci_id_class_type = ty_id;\n ci_id_object = obj_id;\n ci_id_typehash = cl_id;\n ci_expr = expr;\n ci_decl = clty;\n ci_type_decl = cltydef;\n ci_attributes = cl.pci_attributes;\n }\n }\n(* (cl.pci_variance, cl.pci_loc)) *)\n\nlet class_infos define_class kind\n (cl, id, ty_id,\n obj_id, obj_params, obj_ty,\n cl_id, cl_params, cl_ty,\n constr_type, dummy_class)\n (res, env) =\n Builtin_attributes.warning_scope cl.pci_attributes\n (fun () ->\n class_infos define_class kind\n (cl, id, ty_id,\n obj_id, obj_params, obj_ty,\n cl_id, cl_params, cl_ty,\n constr_type, dummy_class)\n (res, env)\n )\n\nlet extract_type_decls { clty; cltydef; obj_id; obj_abbr; cl_abbr; req} decls =\n (obj_id, obj_abbr, cl_abbr, clty, cltydef, req) :: decls\n\nlet merge_type_decls decl (obj_abbr, cl_abbr, clty, cltydef) =\n {decl with obj_abbr; cl_abbr; clty; cltydef}\n\nlet final_env define_class env { id; clty; ty_id; cltydef; obj_id; obj_abbr;\n cl_id; cl_abbr } =\n (* Add definitions after cleaning them *)\n Env.add_type ~check:true obj_id\n (Subst.type_declaration Subst.identity obj_abbr) (\n Env.add_type ~check:true cl_id\n (Subst.type_declaration Subst.identity cl_abbr) (\n Env.add_cltype ty_id (Subst.cltype_declaration Subst.identity cltydef) (\n if define_class then\n Env.add_class id (Subst.class_declaration Subst.identity clty) env\n else env)))\n\n(* Check that #c is coercible to c if there is a self-coercion *)\nlet check_coercions env { id; id_loc; clty; ty_id; cltydef; obj_id; obj_abbr;\n cl_id; cl_abbr; arity; pub_meths; coe; req } =\n begin match coe with [] -> ()\n | loc :: _ ->\n let cl_ty, obj_ty =\n match cl_abbr.type_manifest, obj_abbr.type_manifest with\n Some cl_ab, Some obj_ab ->\n let cl_params, cl_ty =\n Ctype.instance_parameterized_type cl_abbr.type_params cl_ab\n and obj_params, obj_ty =\n Ctype.instance_parameterized_type obj_abbr.type_params obj_ab\n in\n List.iter2 (Ctype.unify env) cl_params obj_params;\n cl_ty, obj_ty\n | _ -> assert false\n in\n begin try Ctype.subtype env cl_ty obj_ty ()\n with Ctype.Subtype err ->\n raise(Typecore.Error(loc, env, Typecore.Not_subtype err))\n end;\n if not (Ctype.opened_object cl_ty) then\n raise(Error(loc, env, Cannot_coerce_self obj_ty))\n end;\n {cls_id = id;\n cls_id_loc = id_loc;\n cls_decl = clty;\n cls_ty_id = ty_id;\n cls_ty_decl = cltydef;\n cls_obj_id = obj_id;\n cls_obj_abbr = obj_abbr;\n cls_typesharp_id = cl_id;\n cls_abbr = cl_abbr;\n cls_arity = arity;\n cls_pub_methods = pub_meths;\n cls_info=req}\n\n(*******************************)\n\nlet type_classes define_class approx kind env cls =\n let scope = Ctype.create_scope () in\n let cls =\n List.map\n (function cl ->\n (cl,\n Ident.create_scoped ~scope cl.pci_name.txt,\n Ident.create_scoped ~scope cl.pci_name.txt,\n Ident.create_scoped ~scope cl.pci_name.txt,\n Ident.create_scoped ~scope (\"#\" ^ cl.pci_name.txt),\n Uid.mk ~current_unit:(Env.get_unit_name ())\n ))\n cls\n in\n Ctype.begin_class_def ();\n let (res, env) =\n List.fold_left (initial_env define_class approx) ([], env) cls\n in\n let (res, env) =\n List.fold_right (class_infos define_class kind) res ([], env)\n in\n Ctype.end_def ();\n let res = List.rev_map (final_decl env define_class) res in\n let decls = List.fold_right extract_type_decls res [] in\n let decls =\n try Typedecl_variance.update_class_decls env decls\n with Typedecl_variance.Error(loc, err) ->\n raise (Typedecl.Error(loc, Typedecl.Variance err))\n in\n let res = List.map2 merge_type_decls res decls in\n let env = List.fold_left (final_env define_class) env res in\n let res = List.map (check_coercions env) res in\n (res, env)\n\nlet class_num = ref 0\nlet class_declaration env virt sexpr =\n incr class_num;\n let self_scope = Ctype.get_current_level () in\n let expr =\n class_expr (Int.to_string !class_num) env env virt self_scope sexpr\n in\n complete_class_type expr.cl_loc env virt Class expr.cl_type;\n (expr, expr.cl_type)\n\nlet class_description env virt sexpr =\n let self_scope = Ctype.get_current_level () in\n let expr = class_type env virt self_scope sexpr in\n complete_class_type expr.cltyp_loc env virt Class_type expr.cltyp_type;\n (expr, expr.cltyp_type)\n\nlet class_declarations env cls =\n let info, env =\n type_classes true approx_declaration class_declaration env cls\n in\n let ids, exprs =\n List.split\n (List.map\n (fun ci -> ci.cls_id, ci.cls_info.ci_expr)\n info)\n in\n check_recursive_class_bindings env ids exprs;\n info, env\n\nlet class_descriptions env cls =\n type_classes true approx_description class_description env cls\n\nlet class_type_declarations env cls =\n let (decls, env) =\n type_classes false approx_description class_description env cls\n in\n (List.map\n (fun decl ->\n {clsty_ty_id = decl.cls_ty_id;\n clsty_id_loc = decl.cls_id_loc;\n clsty_ty_decl = decl.cls_ty_decl;\n clsty_obj_id = decl.cls_obj_id;\n clsty_obj_abbr = decl.cls_obj_abbr;\n clsty_typesharp_id = decl.cls_typesharp_id;\n clsty_abbr = decl.cls_abbr;\n clsty_info = decl.cls_info})\n decls,\n env)\n\nlet type_object env loc s =\n incr class_num;\n let desc =\n class_structure (Int.to_string !class_num)\n Concrete Btype.lowest_level Final env env loc s\n in\n complete_class_signature loc env Concrete Object desc.cstr_type;\n let meths = Btype.public_methods desc.cstr_type in\n (desc, meths)\n\nlet () =\n Typecore.type_object := type_object\n\n(*******************************)\n\n(* Approximate the class declaration as class ['params] id = object end *)\nlet approx_class sdecl =\n let open Ast_helper in\n let self' = Typ.any () in\n let clty' = Cty.signature ~loc:sdecl.pci_expr.pcty_loc (Csig.mk self' []) in\n { sdecl with pci_expr = clty' }\n\nlet approx_class_declarations env sdecls =\n fst (class_type_declarations env (List.map approx_class sdecls))\n\n(*******************************)\n\n(* Error report *)\n\nopen Format\n\nlet non_virtual_string_of_kind = function\n | Object -> \"object\"\n | Class -> \"non-virtual class\"\n | Class_type -> \"non-virtual class type\"\n\nlet report_error env ppf = function\n | Repeated_parameter ->\n fprintf ppf \"A type parameter occurs several times\"\n | Unconsistent_constraint err ->\n fprintf ppf \"@[The class constraints are not consistent.@ \";\n Printtyp.report_unification_error ppf env err\n (fun ppf -> fprintf ppf \"Type\")\n (fun ppf -> fprintf ppf \"is not compatible with type\");\n fprintf ppf \"@]\"\n | Field_type_mismatch (k, m, err) ->\n Printtyp.report_unification_error ppf env err\n (function ppf ->\n fprintf ppf \"The %s %s@ has type\" k m)\n (function ppf ->\n fprintf ppf \"but is expected to have type\")\n | Unexpected_field (ty, lab) ->\n Printtyp.prepare_for_printing [ty];\n fprintf ppf\n \"@[@[<2>This object is expected to have type :@ %a@]\\\n @ This type does not have a method %s.\"\n Printtyp.type_expr ty lab\n | Structure_expected clty ->\n fprintf ppf\n \"@[This class expression is not a class structure; it has type@ %a@]\"\n Printtyp.class_type clty\n | Cannot_apply _ ->\n fprintf ppf\n \"This class expression is not a class function, it cannot be applied\"\n | Apply_wrong_label l ->\n let mark_label = function\n | Nolabel -> \"out label\"\n | l -> sprintf \" label %s\" (Btype.prefixed_label_name l) in\n fprintf ppf \"This argument cannot be applied with%s\" (mark_label l)\n | Pattern_type_clash ty ->\n (* XXX Trace *)\n (* XXX Revoir message d'erreur | Improve error message *)\n fprintf ppf \"@[%s@ %a@]\"\n \"This pattern cannot match self: it only matches values of type\"\n Printtyp.type_expr ty\n | Unbound_class_2 cl ->\n fprintf ppf \"@[The class@ %a@ is not yet completely defined@]\"\n Printtyp.longident cl\n | Unbound_class_type_2 cl ->\n fprintf ppf \"@[The class type@ %a@ is not yet completely defined@]\"\n Printtyp.longident cl\n | Abbrev_type_clash (abbrev, actual, expected) ->\n (* XXX Afficher une trace ? | Print a trace? *)\n Printtyp.prepare_for_printing [abbrev; actual; expected];\n fprintf ppf \"@[The abbreviation@ %a@ expands to type@ %a@ \\\n but is used with type@ %a@]\"\n !Oprint.out_type (Printtyp.tree_of_typexp Type abbrev)\n !Oprint.out_type (Printtyp.tree_of_typexp Type actual)\n !Oprint.out_type (Printtyp.tree_of_typexp Type expected)\n | Constructor_type_mismatch (c, err) ->\n Printtyp.report_unification_error ppf env err\n (function ppf ->\n fprintf ppf \"The expression \\\"new %s\\\" has type\" c)\n (function ppf ->\n fprintf ppf \"but is used with type\")\n | Virtual_class (kind, mets, vals) ->\n let kind = non_virtual_string_of_kind kind in\n let missings =\n match mets, vals with\n [], _ -> \"variables\"\n | _, [] -> \"methods\"\n | _ -> \"methods and variables\"\n in\n fprintf ppf\n \"@[This %s has virtual %s.@ \\\n @[<2>The following %s are virtual : %a@]@]\"\n kind missings missings\n (pp_print_list ~pp_sep:pp_print_space pp_print_string) (mets @ vals)\n | Undeclared_methods(kind, mets) ->\n let kind = non_virtual_string_of_kind kind in\n fprintf ppf\n \"@[This %s has undeclared virtual methods.@ \\\n @[<2>The following methods were not declared : %a@]@]\"\n kind (pp_print_list ~pp_sep:pp_print_space pp_print_string) mets\n | Parameter_arity_mismatch(lid, expected, provided) ->\n fprintf ppf\n \"@[The class constructor %a@ expects %i type argument(s),@ \\\n but is here applied to %i type argument(s)@]\"\n Printtyp.longident lid expected provided\n | Parameter_mismatch err ->\n Printtyp.report_unification_error ppf env err\n (function ppf ->\n fprintf ppf \"The type parameter\")\n (function ppf ->\n fprintf ppf \"does not meet its constraint: it should be\")\n | Bad_parameters (id, params, cstrs) ->\n Printtyp.prepare_for_printing [params; cstrs];\n fprintf ppf\n \"@[The abbreviation %a@ is used with parameters@ %a@ \\\n which are incompatible with constraints@ %a@]\"\n Printtyp.ident id\n !Oprint.out_type (Printtyp.tree_of_typexp Type params)\n !Oprint.out_type (Printtyp.tree_of_typexp Type cstrs)\n | Class_match_failure error ->\n Includeclass.report_error Type ppf error\n | Unbound_val lab ->\n fprintf ppf \"Unbound instance variable %s\" lab\n | Unbound_type_var (printer, reason) ->\n let print_reason ppf (ty0, real, lab, ty) =\n let ty1 =\n if real then ty0 else Btype.newgenty(Tobject(ty0, ref None)) in\n Printtyp.prepare_for_printing [ty; ty1];\n fprintf ppf\n \"The method %s@ has type@;<1 2>%a@ where@ %a@ is unbound\"\n lab\n !Oprint.out_type (Printtyp.tree_of_typexp Type ty)\n !Oprint.out_type (Printtyp.tree_of_typexp Type ty0)\n in\n fprintf ppf\n \"@[@[Some type variables are unbound in this type:@;<1 2>%t@]@ \\\n @[%a@]@]\"\n printer print_reason reason\n | Non_generalizable_class (id, clty) ->\n fprintf ppf\n \"@[The type of this class,@ %a,@ \\\n contains type variables that cannot be generalized@]\"\n (Printtyp.class_declaration id) clty\n | Cannot_coerce_self ty ->\n fprintf ppf\n \"@[The type of self cannot be coerced to@ \\\n the type of the current class:@ %a.@.\\\n Some occurrences are contravariant@]\"\n Printtyp.type_scheme ty\n | Non_collapsable_conjunction (id, clty, err) ->\n fprintf ppf\n \"@[The type of this class,@ %a,@ \\\n contains non-collapsible conjunctive types in constraints.@ %t@]\"\n (Printtyp.class_declaration id) clty\n (fun ppf -> Printtyp.report_unification_error ppf env err\n (fun ppf -> fprintf ppf \"Type\")\n (fun ppf -> fprintf ppf \"is not compatible with type\")\n )\n | Self_clash err ->\n Printtyp.report_unification_error ppf env err\n (function ppf ->\n fprintf ppf \"This object is expected to have type\")\n (function ppf ->\n fprintf ppf \"but actually has type\")\n | Mutability_mismatch (_lab, mut) ->\n let mut1, mut2 =\n if mut = Immutable then \"mutable\", \"immutable\"\n else \"immutable\", \"mutable\" in\n fprintf ppf\n \"@[The instance variable is %s;@ it cannot be redefined as %s@]\"\n mut1 mut2\n | No_overriding (_, \"\") ->\n fprintf ppf \"@[This inheritance does not override any method@ %s@]\"\n \"instance variable\"\n | No_overriding (kind, name) ->\n fprintf ppf \"@[The %s `%s'@ has no previous definition@]\" kind name\n | Duplicate (kind, name) ->\n fprintf ppf \"@[The %s `%s'@ has multiple definitions in this object@]\"\n kind name\n | Closing_self_type sign ->\n fprintf ppf\n \"@[Cannot close type of object literal:@ %a@,\\\n it has been unified with the self type of a class that is not yet@ \\\n completely defined.@]\"\n Printtyp.type_scheme sign.csig_self\n\nlet report_error env ppf err =\n Printtyp.wrap_printing_env ~error:true\n env (fun () -> report_error env ppf err)\n\nlet () =\n Location.register_error_of_exn\n (function\n | Error (loc, env, err) ->\n Some (Location.error_of_printer ~loc (report_error env) err)\n | Error_forward err ->\n Some err\n | _ ->\n None\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(* Environment handling *)\n\nopen Cmi_format\nopen Misc\nopen Asttypes\nopen Longident\nopen Path\nopen Types\n\nopen Local_store\n\nmodule String = Misc.Stdlib.String\n\nlet add_delayed_check_forward = ref (fun _ -> assert false)\n\ntype 'a usage_tbl = ('a -> unit) Types.Uid.Tbl.t\n(** This table is used to track usage of value declarations.\n A declaration is identified by its uid.\n The callback attached to a declaration is called whenever the value (or\n type, or ...) is used explicitly (lookup_value, ...) or implicitly\n (inclusion test between signatures, cf Includemod.value_descriptions, ...).\n*)\n\nlet value_declarations : unit usage_tbl ref = s_table Types.Uid.Tbl.create 16\nlet type_declarations : unit usage_tbl ref = s_table Types.Uid.Tbl.create 16\nlet module_declarations : unit usage_tbl ref = s_table Types.Uid.Tbl.create 16\n\nlet uid_to_loc : Location.t Types.Uid.Tbl.t ref =\n s_table Types.Uid.Tbl.create 16\n\nlet register_uid uid loc = Types.Uid.Tbl.add !uid_to_loc uid loc\n\nlet get_uid_to_loc_tbl () = !uid_to_loc\n\ntype constructor_usage = Positive | Pattern | Exported_private | Exported\ntype constructor_usages =\n {\n mutable cu_positive: bool;\n mutable cu_pattern: bool;\n mutable cu_exported_private: bool;\n }\nlet add_constructor_usage cu usage =\n match usage with\n | Positive -> cu.cu_positive <- true\n | Pattern -> cu.cu_pattern <- true\n | Exported_private -> cu.cu_exported_private <- true\n | Exported ->\n cu.cu_positive <- true;\n cu.cu_pattern <- true;\n cu.cu_exported_private <- true\n\nlet constructor_usages () =\n {cu_positive = false; cu_pattern = false; cu_exported_private = false}\n\nlet constructor_usage_complaint ~rebind priv cu\n : Warnings.constructor_usage_warning option =\n match priv, rebind with\n | Asttypes.Private, _ | _, true ->\n if cu.cu_positive || cu.cu_pattern || cu.cu_exported_private then None\n else Some Unused\n | Asttypes.Public, false -> begin\n match cu.cu_positive, cu.cu_pattern, cu.cu_exported_private with\n | true, _, _ -> None\n | false, false, false -> Some Unused\n | false, true, _ -> Some Not_constructed\n | false, false, true -> Some Only_exported_private\n end\n\nlet used_constructors : constructor_usage usage_tbl ref =\n s_table Types.Uid.Tbl.create 16\n\ntype label_usage =\n Projection | Mutation | Construct | Exported_private | Exported\ntype label_usages =\n {\n mutable lu_projection: bool;\n mutable lu_mutation: bool;\n mutable lu_construct: bool;\n }\nlet add_label_usage lu usage =\n match usage with\n | Projection -> lu.lu_projection <- true;\n | Mutation -> lu.lu_mutation <- true\n | Construct -> lu.lu_construct <- true\n | Exported_private ->\n lu.lu_projection <- true\n | Exported ->\n lu.lu_projection <- true;\n lu.lu_mutation <- true;\n lu.lu_construct <- true\n\nlet label_usages () =\n {lu_projection = false; lu_mutation = false; lu_construct = false}\n\nlet label_usage_complaint priv mut lu\n : Warnings.field_usage_warning option =\n match priv, mut with\n | Asttypes.Private, _ ->\n if lu.lu_projection then None\n else Some Unused\n | Asttypes.Public, Asttypes.Immutable -> begin\n match lu.lu_projection, lu.lu_construct with\n | true, _ -> None\n | false, false -> Some Unused\n | false, true -> Some Not_read\n end\n | Asttypes.Public, Asttypes.Mutable -> begin\n match lu.lu_projection, lu.lu_mutation, lu.lu_construct with\n | true, true, _ -> None\n | false, false, false -> Some Unused\n | false, _, _ -> Some Not_read\n | true, false, _ -> Some Not_mutated\n end\n\nlet used_labels : label_usage usage_tbl ref =\n s_table Types.Uid.Tbl.create 16\n\n(** Map indexed by the name of module components. *)\nmodule NameMap = String.Map\n\ntype value_unbound_reason =\n | Val_unbound_instance_variable\n | Val_unbound_self\n | Val_unbound_ancestor\n | Val_unbound_ghost_recursive of Location.t\n\ntype module_unbound_reason =\n | Mod_unbound_illegal_recursion\n\ntype summary =\n Env_empty\n | Env_value of summary * Ident.t * value_description\n | Env_type of summary * Ident.t * type_declaration\n | Env_extension of summary * Ident.t * extension_constructor\n | Env_module of summary * Ident.t * module_presence * module_declaration\n | Env_modtype of summary * Ident.t * modtype_declaration\n | Env_class of summary * Ident.t * class_declaration\n | Env_cltype of summary * Ident.t * class_type_declaration\n | Env_open of summary * Path.t\n | Env_functor_arg of summary * Ident.t\n | Env_constraints of summary * type_declaration Path.Map.t\n | Env_copy_types of summary\n | Env_persistent of summary * Ident.t\n | Env_value_unbound of summary * string * value_unbound_reason\n | Env_module_unbound of summary * string * module_unbound_reason\n\nlet map_summary f = function\n Env_empty -> Env_empty\n | Env_value (s, id, d) -> Env_value (f s, id, d)\n | Env_type (s, id, d) -> Env_type (f s, id, d)\n | Env_extension (s, id, d) -> Env_extension (f s, id, d)\n | Env_module (s, id, p, d) -> Env_module (f s, id, p, d)\n | Env_modtype (s, id, d) -> Env_modtype (f s, id, d)\n | Env_class (s, id, d) -> Env_class (f s, id, d)\n | Env_cltype (s, id, d) -> Env_cltype (f s, id, d)\n | Env_open (s, p) -> Env_open (f s, p)\n | Env_functor_arg (s, id) -> Env_functor_arg (f s, id)\n | Env_constraints (s, m) -> Env_constraints (f s, m)\n | Env_copy_types s -> Env_copy_types (f s)\n | Env_persistent (s, id) -> Env_persistent (f s, id)\n | Env_value_unbound (s, u, r) -> Env_value_unbound (f s, u, r)\n | Env_module_unbound (s, u, r) -> Env_module_unbound (f s, u, r)\n\ntype address =\n | Aident of Ident.t\n | Adot of address * int\n\nmodule TycompTbl =\n struct\n (** This module is used to store components of types (i.e. labels\n and constructors). We keep a representation of each nested\n \"open\" and the set of local bindings between each of them. *)\n\n type 'a t = {\n current: 'a Ident.tbl;\n (** Local bindings since the last open. *)\n\n opened: 'a opened option;\n (** Symbolic representation of the last (innermost) open, if any. *)\n }\n\n and 'a opened = {\n components: ('a list) NameMap.t;\n (** Components from the opened module. We keep a list of\n bindings for each name, as in comp_labels and\n comp_constrs. *)\n\n root: Path.t;\n (** Only used to check removal of open *)\n\n using: (string -> ('a * 'a) option -> unit) option;\n (** A callback to be applied when a component is used from this\n \"open\". This is used to detect unused \"opens\". The\n arguments are used to detect shadowing. *)\n\n next: 'a t;\n (** The table before opening the module. *)\n }\n\n let empty = { current = Ident.empty; opened = None }\n\n let add id x tbl =\n {tbl with current = Ident.add id x tbl.current}\n\n let add_open slot wrap root components next =\n let using =\n match slot with\n | None -> None\n | Some f -> Some (fun s x -> f s (wrap x))\n in\n {\n current = Ident.empty;\n opened = Some {using; components; root; next};\n }\n\n let remove_last_open rt tbl =\n match tbl.opened with\n | Some {root; next; _} when Path.same rt root ->\n { next with current =\n Ident.fold_all Ident.add tbl.current next.current }\n | _ ->\n assert false\n\n let rec find_same id tbl =\n try Ident.find_same id tbl.current\n with Not_found as exn ->\n begin match tbl.opened with\n | Some {next; _} -> find_same id next\n | None -> raise exn\n end\n\n let nothing = fun () -> ()\n\n let mk_callback rest name desc using =\n match using with\n | None -> nothing\n | Some f ->\n (fun () ->\n match rest with\n | [] -> f name None\n | (hidden, _) :: _ -> f name (Some (desc, hidden)))\n\n let rec find_all ~mark name tbl =\n List.map (fun (_id, desc) -> desc, nothing)\n (Ident.find_all name tbl.current) @\n match tbl.opened with\n | None -> []\n | Some {using; next; components; root = _} ->\n let rest = find_all ~mark name next in\n let using = if mark then using else None in\n match NameMap.find name components with\n | exception Not_found -> rest\n | opened ->\n List.map\n (fun desc -> desc, mk_callback rest name desc using)\n opened\n @ rest\n\n let rec fold_name f tbl acc =\n let acc = Ident.fold_name (fun _id d -> f d) tbl.current acc in\n match tbl.opened with\n | Some {using = _; next; components; root = _} ->\n acc\n |> NameMap.fold\n (fun _name -> List.fold_right f)\n components\n |> fold_name f next\n | None ->\n acc\n\n let rec local_keys tbl acc =\n let acc = Ident.fold_all (fun k _ accu -> k::accu) tbl.current acc in\n match tbl.opened with\n | Some o -> local_keys o.next acc\n | None -> acc\n\n let diff_keys is_local tbl1 tbl2 =\n let keys2 = local_keys tbl2 [] in\n List.filter\n (fun id ->\n is_local (find_same id tbl2) &&\n try ignore (find_same id tbl1); false\n with Not_found -> true)\n keys2\n\n end\n\n\nmodule IdTbl =\n struct\n (** This module is used to store all kinds of components except\n (labels and constructors) in environments. We keep a\n representation of each nested \"open\" and the set of local\n bindings between each of them. *)\n\n\n type ('a, 'b) t = {\n current: 'a Ident.tbl;\n (** Local bindings since the last open *)\n\n layer: ('a, 'b) layer;\n (** Symbolic representation of the last (innermost) open, if any. *)\n }\n\n and ('a, 'b) layer =\n | Open of {\n root: Path.t;\n (** The path of the opened module, to be prefixed in front of\n its local names to produce a valid path in the current\n environment. *)\n\n components: 'b NameMap.t;\n (** Components from the opened module. *)\n\n using: (string -> ('a * 'a) option -> unit) option;\n (** A callback to be applied when a component is used from this\n \"open\". This is used to detect unused \"opens\". The\n arguments are used to detect shadowing. *)\n\n next: ('a, 'b) t;\n (** The table before opening the module. *)\n }\n\n | Map of {\n f: ('a -> 'a);\n next: ('a, 'b) t;\n }\n\n | Nothing\n\n let empty = { current = Ident.empty; layer = Nothing }\n\n let add id x tbl =\n {tbl with current = Ident.add id x tbl.current}\n\n let remove id tbl =\n {tbl with current = Ident.remove id tbl.current}\n\n let add_open slot wrap root components next =\n let using =\n match slot with\n | None -> None\n | Some f -> Some (fun s x -> f s (wrap x))\n in\n {\n current = Ident.empty;\n layer = Open {using; root; components; next};\n }\n\n let remove_last_open rt tbl =\n match tbl.layer with\n | Open {root; next; _} when Path.same rt root ->\n { next with current =\n Ident.fold_all Ident.add tbl.current next.current }\n | _ ->\n assert false\n\n let map f next =\n {\n current = Ident.empty;\n layer = Map {f; next}\n }\n\n let rec find_same id tbl =\n try Ident.find_same id tbl.current\n with Not_found as exn ->\n begin match tbl.layer with\n | Open {next; _} -> find_same id next\n | Map {f; next} -> f (find_same id next)\n | Nothing -> raise exn\n end\n\n let rec find_name wrap ~mark name tbl =\n try\n let (id, desc) = Ident.find_name name tbl.current in\n Pident id, desc\n with Not_found as exn ->\n begin match tbl.layer with\n | Open {using; root; next; components} ->\n begin try\n let descr = wrap (NameMap.find name components) in\n let res = Pdot (root, name), descr in\n if mark then begin match using with\n | None -> ()\n | Some f -> begin\n match find_name wrap ~mark:false name next with\n | exception Not_found -> f name None\n | _, descr' -> f name (Some (descr', descr))\n end\n end;\n res\n with Not_found ->\n find_name wrap ~mark name next\n end\n | Map {f; next} ->\n let (p, desc) = find_name wrap ~mark name next in\n p, f desc\n | Nothing ->\n raise exn\n end\n\n let rec find_all wrap name tbl =\n List.map\n (fun (id, desc) -> Pident id, desc)\n (Ident.find_all name tbl.current) @\n match tbl.layer with\n | Nothing -> []\n | Open {root; using = _; next; components} ->\n begin try\n let desc = wrap (NameMap.find name components) in\n (Pdot (root, name), desc) :: find_all wrap name next\n with Not_found ->\n find_all wrap name next\n end\n | Map {f; next} ->\n List.map (fun (p, desc) -> (p, f desc))\n (find_all wrap name next)\n\n let rec fold_name wrap f tbl acc =\n let acc =\n Ident.fold_name\n (fun id d -> f (Ident.name id) (Pident id, d))\n tbl.current acc\n in\n match tbl.layer with\n | Open {root; using = _; next; components} ->\n acc\n |> NameMap.fold\n (fun name desc -> f name (Pdot (root, name), wrap desc))\n components\n |> fold_name wrap f next\n | Nothing ->\n acc\n | Map {f=g; next} ->\n acc\n |> fold_name wrap\n (fun name (path, desc) -> f name (path, g desc))\n next\n\n let rec local_keys tbl acc =\n let acc = Ident.fold_all (fun k _ accu -> k::accu) tbl.current acc in\n match tbl.layer with\n | Open {next; _ } | Map {next; _} -> local_keys next acc\n | Nothing -> acc\n\n\n let rec iter wrap f tbl =\n Ident.iter (fun id desc -> f id (Pident id, desc)) tbl.current;\n match tbl.layer with\n | Open {root; using = _; next; components} ->\n NameMap.iter\n (fun s x ->\n let root_scope = Path.scope root in\n f (Ident.create_scoped ~scope:root_scope s)\n (Pdot (root, s), wrap x))\n components;\n iter wrap f next\n | Map {f=g; next} ->\n iter wrap (fun id (path, desc) -> f id (path, g desc)) next\n | Nothing -> ()\n\n let diff_keys tbl1 tbl2 =\n let keys2 = local_keys tbl2 [] in\n List.filter\n (fun id ->\n try ignore (find_same id tbl1); false\n with Not_found -> true)\n keys2\n\n\n end\n\ntype type_descr_kind =\n (label_description, constructor_description) type_kind\n\ntype type_descriptions = type_descr_kind\n\nlet in_signature_flag = 0x01\n\ntype t = {\n values: (value_entry, value_data) IdTbl.t;\n constrs: constructor_data TycompTbl.t;\n labels: label_data TycompTbl.t;\n types: (type_data, type_data) IdTbl.t;\n modules: (module_entry, module_data) IdTbl.t;\n modtypes: (modtype_data, modtype_data) IdTbl.t;\n classes: (class_data, class_data) IdTbl.t;\n cltypes: (cltype_data, cltype_data) IdTbl.t;\n functor_args: unit Ident.tbl;\n summary: summary;\n local_constraints: type_declaration Path.Map.t;\n flags: int;\n}\n\nand module_components =\n {\n alerts: alerts;\n uid: Uid.t;\n comps:\n (components_maker,\n (module_components_repr, module_components_failure) result)\n Lazy_backtrack.t;\n }\n\nand components_maker = {\n cm_env: t;\n cm_prefixing_subst: Subst.t;\n cm_path: Path.t;\n cm_addr: address_lazy;\n cm_mty: Subst.Lazy.modtype;\n cm_shape: Shape.t;\n}\n\nand module_components_repr =\n Structure_comps of structure_components\n | Functor_comps of functor_components\n\nand module_components_failure =\n | No_components_abstract\n | No_components_alias of Path.t\n\nand structure_components = {\n mutable comp_values: value_data NameMap.t;\n mutable comp_constrs: constructor_data list NameMap.t;\n mutable comp_labels: label_data list NameMap.t;\n mutable comp_types: type_data NameMap.t;\n mutable comp_modules: module_data NameMap.t;\n mutable comp_modtypes: modtype_data NameMap.t;\n mutable comp_classes: class_data NameMap.t;\n mutable comp_cltypes: cltype_data NameMap.t;\n}\n\nand functor_components = {\n fcomp_arg: functor_parameter;\n (* Formal parameter and argument signature *)\n fcomp_res: module_type; (* Result signature *)\n fcomp_shape: Shape.t;\n fcomp_cache: (Path.t, module_components) Hashtbl.t; (* For memoization *)\n fcomp_subst_cache: (Path.t, module_type) Hashtbl.t\n}\n\nand address_unforced =\n | Projection of { parent : address_lazy; pos : int; }\n | ModAlias of { env : t; path : Path.t; }\n\nand address_lazy = (address_unforced, address) Lazy_backtrack.t\n\nand value_data =\n { vda_description : value_description;\n vda_address : address_lazy;\n vda_shape : Shape.t }\n\nand value_entry =\n | Val_bound of value_data\n | Val_unbound of value_unbound_reason\n\nand constructor_data =\n { cda_description : constructor_description;\n cda_address : address_lazy option;\n cda_shape: Shape.t; }\n\nand label_data = label_description\n\nand type_data =\n { tda_declaration : type_declaration;\n tda_descriptions : type_descriptions;\n tda_shape : Shape.t; }\n\nand module_data =\n { mda_declaration : Subst.Lazy.module_decl;\n mda_components : module_components;\n mda_address : address_lazy;\n mda_shape: Shape.t; }\n\nand module_entry =\n | Mod_local of module_data\n | Mod_persistent\n | Mod_unbound of module_unbound_reason\n\nand modtype_data =\n { mtda_declaration : Subst.Lazy.modtype_declaration;\n mtda_shape : Shape.t; }\n\nand class_data =\n { clda_declaration : class_declaration;\n clda_address : address_lazy;\n clda_shape : Shape.t }\n\nand cltype_data =\n { cltda_declaration : class_type_declaration;\n cltda_shape : Shape.t }\n\nlet empty_structure =\n Structure_comps {\n comp_values = NameMap.empty;\n comp_constrs = NameMap.empty;\n comp_labels = NameMap.empty;\n comp_types = NameMap.empty;\n comp_modules = NameMap.empty; comp_modtypes = NameMap.empty;\n comp_classes = NameMap.empty;\n comp_cltypes = NameMap.empty }\n\ntype unbound_value_hint =\n | No_hint\n | Missing_rec of Location.t\n\ntype lookup_error =\n | Unbound_value of Longident.t * unbound_value_hint\n | Unbound_type of Longident.t\n | Unbound_constructor of Longident.t\n | Unbound_label of Longident.t\n | Unbound_module of Longident.t\n | Unbound_class of Longident.t\n | Unbound_modtype of Longident.t\n | Unbound_cltype of Longident.t\n | Unbound_instance_variable of string\n | Not_an_instance_variable of string\n | Masked_instance_variable of Longident.t\n | Masked_self_variable of Longident.t\n | Masked_ancestor_variable of Longident.t\n | Structure_used_as_functor of Longident.t\n | Abstract_used_as_functor of Longident.t\n | Functor_used_as_structure of Longident.t\n | Abstract_used_as_structure of Longident.t\n | Generative_used_as_applicative of Longident.t\n | Illegal_reference_to_recursive_module\n | Cannot_scrape_alias of Longident.t * Path.t\n\ntype error =\n | Missing_module of Location.t * Path.t * Path.t\n | Illegal_value_name of Location.t * string\n | Lookup_error of Location.t * t * lookup_error\n\nexception Error of error\n\nlet error err = raise (Error err)\n\nlet lookup_error loc env err =\n error (Lookup_error(loc, env, err))\n\nlet same_constr = ref (fun _ _ _ -> assert false)\n\nlet check_well_formed_module = ref (fun _ -> assert false)\n\n(* Helper to decide whether to report an identifier shadowing\n by some 'open'. For labels and constructors, we do not report\n if the two elements are from the same re-exported declaration.\n\n Later, one could also interpret some attributes on value and\n type declarations to silence the shadowing warnings. *)\n\nlet check_shadowing env = function\n | `Constructor (Some (cda1, cda2))\n when not (!same_constr env\n cda1.cda_description.cstr_res\n cda2.cda_description.cstr_res) ->\n Some \"constructor\"\n | `Label (Some (l1, l2))\n when not (!same_constr env l1.lbl_res l2.lbl_res) ->\n Some \"label\"\n | `Value (Some _) -> Some \"value\"\n | `Type (Some _) -> Some \"type\"\n | `Module (Some _) | `Component (Some _) -> Some \"module\"\n | `Module_type (Some _) -> Some \"module type\"\n | `Class (Some _) -> Some \"class\"\n | `Class_type (Some _) -> Some \"class type\"\n | `Constructor _ | `Label _\n | `Value None | `Type None | `Module None | `Module_type None\n | `Class None | `Class_type None | `Component None ->\n None\n\nlet empty = {\n values = IdTbl.empty; constrs = TycompTbl.empty;\n labels = TycompTbl.empty; types = IdTbl.empty;\n modules = IdTbl.empty; modtypes = IdTbl.empty;\n classes = IdTbl.empty; cltypes = IdTbl.empty;\n summary = Env_empty; local_constraints = Path.Map.empty;\n flags = 0;\n functor_args = Ident.empty;\n }\n\nlet in_signature b env =\n let flags =\n if b then env.flags lor in_signature_flag\n else env.flags land (lnot in_signature_flag)\n in\n {env with flags}\n\nlet is_in_signature env = env.flags land in_signature_flag <> 0\n\nlet has_local_constraints env =\n not (Path.Map.is_empty env.local_constraints)\n\nlet is_ident = function\n Pident _ -> true\n | Pdot _ | Papply _ -> false\n\nlet is_ext cda =\n match cda.cda_description with\n | {cstr_tag = Cstr_extension _} -> true\n | _ -> false\n\nlet is_local_ext cda =\n match cda.cda_description with\n | {cstr_tag = Cstr_extension(p, _)} -> is_ident p\n | _ -> false\n\nlet diff env1 env2 =\n IdTbl.diff_keys env1.values env2.values @\n TycompTbl.diff_keys is_local_ext env1.constrs env2.constrs @\n IdTbl.diff_keys env1.modules env2.modules @\n IdTbl.diff_keys env1.classes env2.classes\n\n(* Functions for use in \"wrap\" parameters in IdTbl *)\nlet wrap_identity x = x\nlet wrap_value vda = Val_bound vda\nlet wrap_module mda = Mod_local mda\n\n(* Forward declarations *)\n\nlet components_of_module_maker' =\n ref ((fun _ -> assert false) :\n components_maker ->\n (module_components_repr, module_components_failure) result)\n\nlet components_of_functor_appl' =\n ref ((fun ~loc:_ ~f_path:_ ~f_comp:_ ~arg:_ _env -> assert false) :\n loc:Location.t -> f_path:Path.t -> f_comp:functor_components ->\n arg:Path.t -> t -> module_components)\nlet check_functor_application =\n (* to be filled by Includemod *)\n ref ((fun ~errors:_ ~loc:_\n ~lid_whole_app:_ ~f0_path:_ ~args:_\n ~arg_path:_ ~arg_mty:_ ~param_mty:_\n _env\n -> assert false) :\n errors:bool -> loc:Location.t ->\n lid_whole_app:Longident.t ->\n f0_path:Path.t -> args:(Path.t * Types.module_type) list ->\n arg_path:Path.t -> arg_mty:module_type -> param_mty:module_type ->\n t -> unit)\nlet strengthen =\n (* to be filled with Mtype.strengthen *)\n ref ((fun ~aliasable:_ _env _mty _path -> assert false) :\n aliasable:bool -> t -> Subst.Lazy.modtype ->\n Path.t -> Subst.Lazy.modtype)\n\nlet md md_type =\n {md_type; md_attributes=[]; md_loc=Location.none\n ;md_uid = Uid.internal_not_actually_unique}\n\n(* Print addresses *)\n\nlet rec print_address ppf = function\n | Aident id -> Format.fprintf ppf \"%s\" (Ident.name id)\n | Adot(a, pos) -> Format.fprintf ppf \"%a.[%i]\" print_address a pos\n\n(* The name of the compilation unit currently compiled.\n \"\" if outside a compilation unit. *)\nmodule Current_unit_name : sig\n val get : unit -> modname\n val set : modname -> unit\n val is : modname -> bool\n val is_ident : Ident.t -> bool\n val is_path : Path.t -> bool\nend = struct\n let current_unit =\n ref \"\"\n let get () =\n !current_unit\n let set name =\n current_unit := name\n let is name =\n !current_unit = name\n let is_ident id =\n Ident.persistent id && is (Ident.name id)\n let is_path = function\n | Pident id -> is_ident id\n | Pdot _ | Papply _ -> false\nend\n\nlet set_unit_name = Current_unit_name.set\nlet get_unit_name = Current_unit_name.get\n\nlet find_same_module id tbl =\n match IdTbl.find_same id tbl with\n | x -> x\n | exception Not_found\n when Ident.persistent id && not (Current_unit_name.is_ident id) ->\n Mod_persistent\n\nlet find_name_module ~mark name tbl =\n match IdTbl.find_name wrap_module ~mark name tbl with\n | x -> x\n | exception Not_found when not (Current_unit_name.is name) ->\n let path = Pident(Ident.create_persistent name) in\n path, Mod_persistent\n\nlet add_persistent_structure id env =\n if not (Ident.persistent id) then invalid_arg \"Env.add_persistent_structure\";\n if Current_unit_name.is_ident id then env\n else begin\n let material =\n (* This addition only observably changes the environment if it shadows a\n non-persistent module already in the environment.\n (See PR#9345) *)\n match\n IdTbl.find_name wrap_module ~mark:false (Ident.name id) env.modules\n with\n | exception Not_found | _, Mod_persistent -> false\n | _ -> true\n in\n let summary =\n if material then Env_persistent (env.summary, id)\n else env.summary\n in\n let modules =\n (* With [-no-alias-deps], non-material additions should not\n affect the environment at all. We should only observe the\n existence of a cmi when accessing components of the module.\n (See #9991). *)\n if material || not !Clflags.transparent_modules then\n IdTbl.add id Mod_persistent env.modules\n else\n env.modules\n in\n { env with modules; summary }\n end\n\nlet components_of_module ~alerts ~uid env ps path addr mty shape =\n {\n alerts;\n uid;\n comps = Lazy_backtrack.create {\n cm_env = env;\n cm_prefixing_subst = ps;\n cm_path = path;\n cm_addr = addr;\n cm_mty = mty;\n cm_shape = shape;\n }\n }\n\nlet sign_of_cmi ~freshen { Persistent_env.Persistent_signature.cmi; _ } =\n let name = cmi.cmi_name in\n let sign = cmi.cmi_sign in\n let flags = cmi.cmi_flags in\n let id = Ident.create_persistent name in\n let path = Pident id in\n let alerts =\n List.fold_left (fun acc -> function Alerts s -> s | _ -> acc)\n Misc.Stdlib.String.Map.empty\n flags\n in\n let md =\n { md_type = Mty_signature sign;\n md_loc = Location.none;\n md_attributes = [];\n md_uid = Uid.of_compilation_unit_id id;\n }\n in\n let mda_address = Lazy_backtrack.create_forced (Aident id) in\n let mda_declaration =\n Subst.(Lazy.module_decl Make_local identity (Lazy.of_module_decl md))\n in\n let mda_shape = Shape.for_persistent_unit name in\n let mda_components =\n let mty = Subst.Lazy.of_modtype (Mty_signature sign) in\n let mty =\n if freshen then\n Subst.Lazy.modtype (Subst.Rescope (Path.scope path))\n Subst.identity mty\n else mty\n in\n components_of_module ~alerts ~uid:md.md_uid\n empty Subst.identity\n path mda_address mty mda_shape\n in\n {\n mda_declaration;\n mda_components;\n mda_address;\n mda_shape;\n }\n\nlet read_sign_of_cmi = sign_of_cmi ~freshen:true\n\nlet save_sign_of_cmi = sign_of_cmi ~freshen:false\n\nlet persistent_env : module_data Persistent_env.t ref =\n s_table Persistent_env.empty ()\n\nlet without_cmis f x =\n Persistent_env.without_cmis !persistent_env f x\n\nlet imports () = Persistent_env.imports !persistent_env\n\nlet import_crcs ~source crcs =\n Persistent_env.import_crcs !persistent_env ~source crcs\n\nlet read_pers_mod modname filename =\n Persistent_env.read !persistent_env read_sign_of_cmi modname filename\n\nlet find_pers_mod name =\n Persistent_env.find !persistent_env read_sign_of_cmi name\n\nlet check_pers_mod ~loc name =\n Persistent_env.check !persistent_env read_sign_of_cmi ~loc name\n\nlet crc_of_unit name =\n Persistent_env.crc_of_unit !persistent_env read_sign_of_cmi name\n\nlet is_imported_opaque modname =\n Persistent_env.is_imported_opaque !persistent_env modname\n\nlet register_import_as_opaque modname =\n Persistent_env.register_import_as_opaque !persistent_env modname\n\nlet reset_declaration_caches () =\n Types.Uid.Tbl.clear !value_declarations;\n Types.Uid.Tbl.clear !type_declarations;\n Types.Uid.Tbl.clear !module_declarations;\n Types.Uid.Tbl.clear !used_constructors;\n Types.Uid.Tbl.clear !used_labels;\n Types.Uid.Tbl.clear !uid_to_loc;\n ()\n\nlet reset_cache () =\n Current_unit_name.set \"\";\n Persistent_env.clear !persistent_env;\n reset_declaration_caches ();\n ()\n\nlet reset_cache_toplevel () =\n Persistent_env.clear_missing !persistent_env;\n reset_declaration_caches ();\n ()\n\n(* get_components *)\n\nlet get_components_res c =\n match Persistent_env.can_load_cmis !persistent_env with\n | Persistent_env.Can_load_cmis ->\n Lazy_backtrack.force !components_of_module_maker' c.comps\n | Persistent_env.Cannot_load_cmis log ->\n Lazy_backtrack.force_logged log !components_of_module_maker' c.comps\n\nlet get_components c =\n match get_components_res c with\n | Error _ -> empty_structure\n | Ok c -> c\n\n(* Module type of functor application *)\n\nlet modtype_of_functor_appl fcomp p1 p2 =\n match fcomp.fcomp_res with\n | Mty_alias _ as mty -> mty\n | mty ->\n try\n Hashtbl.find fcomp.fcomp_subst_cache p2\n with Not_found ->\n let scope = Path.scope (Papply(p1, p2)) in\n let mty =\n let subst =\n match fcomp.fcomp_arg with\n | Unit\n | Named (None, _) -> Subst.identity\n | Named (Some param, _) -> Subst.add_module param p2 Subst.identity\n in\n Subst.modtype (Rescope scope) subst mty\n in\n Hashtbl.add fcomp.fcomp_subst_cache p2 mty;\n mty\n\nlet check_functor_appl\n ~errors ~loc ~lid_whole_app ~f0_path ~args\n ~f_comp\n ~arg_path ~arg_mty ~param_mty\n env =\n if not (Hashtbl.mem f_comp.fcomp_cache arg_path) then\n !check_functor_application\n ~errors ~loc ~lid_whole_app ~f0_path ~args\n ~arg_path ~arg_mty ~param_mty\n env\n\n(* Lookup by identifier *)\n\nlet find_ident_module id env =\n match find_same_module id env.modules with\n | Mod_local data -> data\n | Mod_unbound _ -> raise Not_found\n | Mod_persistent -> find_pers_mod (Ident.name id)\n\nlet rec find_module_components path env =\n match path with\n | Pident id -> (find_ident_module id env).mda_components\n | Pdot(p, s) ->\n let sc = find_structure_components p env in\n (NameMap.find s sc.comp_modules).mda_components\n | Papply(f_path, arg) ->\n let f_comp = find_functor_components f_path env in\n let loc = Location.(in_file !input_name) in\n !components_of_functor_appl' ~loc ~f_path ~f_comp ~arg env\n\nand find_structure_components path env =\n match get_components (find_module_components path env) with\n | Structure_comps c -> c\n | Functor_comps _ -> raise Not_found\n\nand find_functor_components path env =\n match get_components (find_module_components path env) with\n | Functor_comps f -> f\n | Structure_comps _ -> raise Not_found\n\nlet find_module ~alias path env =\n match path with\n | Pident id ->\n let data = find_ident_module id env in\n Subst.Lazy.force_module_decl data.mda_declaration\n | Pdot(p, s) ->\n let sc = find_structure_components p env in\n let data = NameMap.find s sc.comp_modules in\n Subst.Lazy.force_module_decl data.mda_declaration\n | Papply(p1, p2) ->\n let fc = find_functor_components p1 env in\n if alias then md (fc.fcomp_res)\n else md (modtype_of_functor_appl fc p1 p2)\n\nlet find_module_lazy ~alias path env =\n match path with\n | Pident id ->\n let data = find_ident_module id env in\n data.mda_declaration\n | Pdot(p, s) ->\n let sc = find_structure_components p env in\n let data = NameMap.find s sc.comp_modules in\n data.mda_declaration\n | Papply(p1, p2) ->\n let fc = find_functor_components p1 env in\n let md =\n if alias then md (fc.fcomp_res)\n else md (modtype_of_functor_appl fc p1 p2)\n in\n Subst.Lazy.of_module_decl md\n\nlet find_strengthened_module ~aliasable path env =\n let md = find_module_lazy ~alias:true path env in\n let mty = !strengthen ~aliasable env md.mdl_type path in\n Subst.Lazy.force_modtype mty\n\nlet find_value_full path env =\n match path with\n | Pident id -> begin\n match IdTbl.find_same id env.values with\n | Val_bound data -> data\n | Val_unbound _ -> raise Not_found\n end\n | Pdot(p, s) ->\n let sc = find_structure_components p env in\n NameMap.find s sc.comp_values\n | Papply _ -> raise Not_found\n\nlet find_type_full path env =\n match path with\n | Pident id -> IdTbl.find_same id env.types\n | Pdot(p, s) ->\n let sc = find_structure_components p env in\n NameMap.find s sc.comp_types\n | Papply _ -> raise Not_found\n\nlet find_modtype_lazy path env =\n match path with\n | Pident id -> (IdTbl.find_same id env.modtypes).mtda_declaration\n | Pdot(p, s) ->\n let sc = find_structure_components p env in\n (NameMap.find s sc.comp_modtypes).mtda_declaration\n | Papply _ -> raise Not_found\n\nlet find_modtype path env =\n Subst.Lazy.force_modtype_decl (find_modtype_lazy path env)\n\nlet find_class_full path env =\n match path with\n | Pident id -> IdTbl.find_same id env.classes\n | Pdot(p, s) ->\n let sc = find_structure_components p env in\n NameMap.find s sc.comp_classes\n | Papply _ -> raise Not_found\n\nlet find_cltype path env =\n match path with\n | Pident id -> (IdTbl.find_same id env.cltypes).cltda_declaration\n | Pdot(p, s) ->\n let sc = find_structure_components p env in\n (NameMap.find s sc.comp_cltypes).cltda_declaration\n | Papply _ -> raise Not_found\n\nlet find_value path env =\n (find_value_full path env).vda_description\n\nlet find_class path env =\n (find_class_full path env).clda_declaration\n\nlet find_ident_constructor id env =\n (TycompTbl.find_same id env.constrs).cda_description\n\nlet find_ident_label id env =\n TycompTbl.find_same id env.labels\n\nlet type_of_cstr path = function\n | {cstr_inlined = Some decl; _} ->\n let labels =\n List.map snd (Datarepr.labels_of_type path decl)\n in\n begin match decl.type_kind with\n | Type_record (_, repr) ->\n {\n tda_declaration = decl;\n tda_descriptions = Type_record (labels, repr);\n tda_shape = Shape.leaf decl.type_uid;\n }\n | _ -> assert false\n end\n | _ -> assert false\n\nlet find_type_data path env =\n match Path.constructor_typath path with\n | Regular p -> begin\n match Path.Map.find p env.local_constraints with\n | decl ->\n {\n tda_declaration = decl;\n tda_descriptions = Type_abstract;\n tda_shape = Shape.leaf decl.type_uid;\n }\n | exception Not_found -> find_type_full p env\n end\n | Cstr (ty_path, s) ->\n (* This case corresponds to an inlined record *)\n let tda =\n try find_type_full ty_path env\n with Not_found -> assert false\n in\n let cstr =\n begin match tda.tda_descriptions with\n | Type_variant (cstrs, _) -> begin\n try\n List.find (fun cstr -> cstr.cstr_name = s) cstrs\n with Not_found -> assert false\n end\n | Type_record _ | Type_abstract | Type_open -> assert false\n end\n in\n type_of_cstr path cstr\n | LocalExt id ->\n let cstr =\n try (TycompTbl.find_same id env.constrs).cda_description\n with Not_found -> assert false\n in\n type_of_cstr path cstr\n | Ext (mod_path, s) ->\n let comps =\n try find_structure_components mod_path env\n with Not_found -> assert false\n in\n let cstrs =\n try NameMap.find s comps.comp_constrs\n with Not_found -> assert false\n in\n let exts = List.filter is_ext cstrs in\n match exts with\n | [cda] -> type_of_cstr path cda.cda_description\n | _ -> assert false\n\nlet find_type p env =\n (find_type_data p env).tda_declaration\nlet find_type_descrs p env =\n (find_type_data p env).tda_descriptions\n\nlet rec find_module_address path env =\n match path with\n | Pident id -> get_address (find_ident_module id env).mda_address\n | Pdot(p, s) ->\n let c = find_structure_components p env in\n get_address (NameMap.find s c.comp_modules).mda_address\n | Papply _ -> raise Not_found\n\nand force_address = function\n | Projection { parent; pos } -> Adot(get_address parent, pos)\n | ModAlias { env; path } -> find_module_address path env\n\nand get_address a =\n Lazy_backtrack.force force_address a\n\nlet find_value_address path env =\n get_address (find_value_full path env).vda_address\n\nlet find_class_address path env =\n get_address (find_class_full path env).clda_address\n\nlet rec get_constrs_address = function\n | [] -> raise Not_found\n | cda :: rest ->\n match cda.cda_address with\n | None -> get_constrs_address rest\n | Some a -> get_address a\n\nlet find_constructor_address path env =\n match path with\n | Pident id -> begin\n let cda = TycompTbl.find_same id env.constrs in\n match cda.cda_address with\n | None -> raise Not_found\n | Some addr -> get_address addr\n end\n | Pdot(p, s) ->\n let c = find_structure_components p env in\n get_constrs_address (NameMap.find s c.comp_constrs)\n | Papply _ ->\n raise Not_found\n\nlet find_hash_type path env =\n match path with\n | Pident id ->\n let name = \"#\" ^ Ident.name id in\n let _, tda =\n IdTbl.find_name wrap_identity ~mark:false name env.types\n in\n tda.tda_declaration\n | Pdot(p, s) ->\n let c = find_structure_components p env in\n let name = \"#\" ^ s in\n let tda = NameMap.find name c.comp_types in\n tda.tda_declaration\n | Papply _ ->\n raise Not_found\n\nlet find_shape env (ns : Shape.Sig_component_kind.t) id =\n match ns with\n | Type ->\n (IdTbl.find_same id env.types).tda_shape\n | Extension_constructor ->\n (TycompTbl.find_same id env.constrs).cda_shape\n | Value ->\n begin match IdTbl.find_same id env.values with\n | Val_bound x -> x.vda_shape\n | Val_unbound _ -> raise Not_found\n end\n | Module ->\n begin match IdTbl.find_same id env.modules with\n | Mod_local { mda_shape; _ } -> mda_shape\n | Mod_persistent -> Shape.for_persistent_unit (Ident.name id)\n | Mod_unbound _ ->\n (* Only present temporarily while approximating the environment for\n recursive modules.\n [find_shape] is only ever called after the environment gets\n properly populated. *)\n assert false\n | exception Not_found\n when Ident.persistent id && not (Current_unit_name.is_ident id) ->\n Shape.for_persistent_unit (Ident.name id)\n end\n | Module_type ->\n (IdTbl.find_same id env.modtypes).mtda_shape\n | Class ->\n (IdTbl.find_same id env.classes).clda_shape\n | Class_type ->\n (IdTbl.find_same id env.cltypes).cltda_shape\n\nlet shape_of_path ~namespace env =\n Shape.of_path ~namespace ~find_shape:(find_shape env)\n\nlet shape_or_leaf uid = function\n | None -> Shape.leaf uid\n | Some shape -> shape\n\nlet required_globals = s_ref []\nlet reset_required_globals () = required_globals := []\nlet get_required_globals () = !required_globals\nlet add_required_global id =\n if Ident.global id && not !Clflags.transparent_modules\n && not (List.exists (Ident.same id) !required_globals)\n then required_globals := id :: !required_globals\n\nlet rec normalize_module_path lax env = function\n | Pident id as path when lax && Ident.persistent id ->\n path (* fast path (avoids lookup) *)\n | Pdot (p, s) as path ->\n let p' = normalize_module_path lax env p in\n if p == p' then expand_module_path lax env path\n else expand_module_path lax env (Pdot(p', s))\n | Papply (p1, p2) as path ->\n let p1' = normalize_module_path lax env p1 in\n let p2' = normalize_module_path true env p2 in\n if p1 == p1' && p2 == p2' then expand_module_path lax env path\n else expand_module_path lax env (Papply(p1', p2'))\n | Pident _ as path ->\n expand_module_path lax env path\n\nand expand_module_path lax env path =\n try match find_module_lazy ~alias:true path env with\n {mdl_type=MtyL_alias path1} ->\n let path' = normalize_module_path lax env path1 in\n if lax || !Clflags.transparent_modules then path' else\n let id = Path.head path in\n if Ident.global id && not (Ident.same id (Path.head path'))\n then add_required_global id;\n path'\n | _ -> path\n with Not_found when lax\n || (match path with Pident id -> not (Ident.persistent id) | _ -> true) ->\n path\n\nlet normalize_module_path oloc env path =\n try normalize_module_path (oloc = None) env path\n with Not_found ->\n match oloc with None -> assert false\n | Some loc ->\n error (Missing_module(loc, path,\n normalize_module_path true env path))\n\nlet normalize_path_prefix oloc env path =\n match path with\n Pdot(p, s) ->\n let p2 = normalize_module_path oloc env p in\n if p == p2 then path else Pdot(p2, s)\n | Pident _ ->\n path\n | Papply _ ->\n assert false\n\nlet normalize_type_path oloc env path =\n (* Inlined version of Path.is_constructor_typath:\n constructor type paths (i.e. path pointing to an inline\n record argument of a constructpr) are built as a regular\n type path followed by a capitalized constructor name. *)\n match path with\n | Pident _ ->\n path\n | Pdot(p, s) ->\n let p2 =\n if Path.is_uident s && not (Path.is_uident (Path.last p)) then\n (* Cstr M.t.C *)\n normalize_path_prefix oloc env p\n else\n (* Regular M.t, Ext M.C *)\n normalize_module_path oloc env p\n in\n if p == p2 then path else Pdot (p2, s)\n | Papply _ ->\n assert false\n\nlet rec normalize_modtype_path env path =\n let path = normalize_path_prefix None env path in\n expand_modtype_path env path\n\nand expand_modtype_path env path =\n match (find_modtype_lazy path env).mtdl_type with\n | Some (MtyL_ident path) -> normalize_modtype_path env path\n | _ | exception Not_found -> path\n\nlet find_module path env =\n find_module ~alias:false path env\n\nlet find_module_lazy path env =\n find_module_lazy ~alias:false path env\n\n(* Find the manifest type associated to a type when appropriate:\n - the type should be public or should have a private row,\n - the type should have an associated manifest type. *)\nlet find_type_expansion path env =\n let decl = find_type path env in\n match decl.type_manifest with\n | Some body when decl.type_private = Public\n || decl.type_kind <> Type_abstract\n || Btype.has_constr_row body ->\n (decl.type_params, body, decl.type_expansion_scope)\n (* The manifest type of Private abstract data types without\n private row are still considered unknown to the type system.\n Hence, this case is caught by the following clause that also handles\n purely abstract data types without manifest type definition. *)\n | _ -> raise Not_found\n\n(* Find the manifest type information associated to a type, i.e.\n the necessary information for the compiler's type-based optimisations.\n In particular, the manifest type associated to a private abstract type\n is revealed for the sake of compiler's type-based optimisations. *)\nlet find_type_expansion_opt path env =\n let decl = find_type path env in\n match decl.type_manifest with\n (* The manifest type of Private abstract data types can still get\n an approximation using their manifest type. *)\n | Some body ->\n (decl.type_params, body, decl.type_expansion_scope)\n | _ -> raise Not_found\n\nlet find_modtype_expansion_lazy path env =\n match (find_modtype_lazy path env).mtdl_type with\n | None -> raise Not_found\n | Some mty -> mty\n\nlet find_modtype_expansion path env =\n Subst.Lazy.force_modtype (find_modtype_expansion_lazy path env)\n\nlet rec is_functor_arg path env =\n match path with\n Pident id ->\n begin try Ident.find_same id env.functor_args; true\n with Not_found -> false\n end\n | Pdot (p, _s) -> is_functor_arg p env\n | Papply _ -> true\n\n(* Copying types associated with values *)\n\nlet make_copy_of_types env0 =\n let memo = Hashtbl.create 16 in\n let copy t =\n try\n Hashtbl.find memo (get_id t)\n with Not_found ->\n let t2 = Subst.type_expr Subst.identity t in\n Hashtbl.add memo (get_id t) t2;\n t2\n in\n let f = function\n | Val_unbound _ as entry -> entry\n | Val_bound vda ->\n let desc = vda.vda_description in\n let desc = { desc with val_type = copy desc.val_type } in\n Val_bound { vda with vda_description = desc }\n in\n let values =\n IdTbl.map f env0.values\n in\n (fun env ->\n (*if env.values != env0.values then fatal_error \"Env.make_copy_of_types\";*)\n {env with values; summary = Env_copy_types env.summary}\n )\n\n(* Iter on an environment (ignoring the body of functors and\n not yet evaluated structures) *)\n\ntype iter_cont = unit -> unit\nlet iter_env_cont = ref []\n\nlet rec scrape_alias_for_visit env mty =\n let open Subst.Lazy in\n match mty with\n | MtyL_alias path -> begin\n match path with\n | Pident id\n when Ident.persistent id\n && not (Persistent_env.looked_up !persistent_env (Ident.name id)) ->\n false\n | path -> (* PR#6600: find_module may raise Not_found *)\n try\n scrape_alias_for_visit env (find_module_lazy path env).mdl_type\n with Not_found -> false\n end\n | _ -> true\n\nlet iter_env wrap proj1 proj2 f env () =\n IdTbl.iter wrap (fun id x -> f (Pident id) x) (proj1 env);\n let rec iter_components path path' mcomps =\n let cont () =\n let visit =\n match Lazy_backtrack.get_arg mcomps.comps with\n | None -> true\n | Some { cm_mty; _ } ->\n scrape_alias_for_visit env cm_mty\n in\n if not visit then () else\n match get_components mcomps with\n Structure_comps comps ->\n NameMap.iter\n (fun s d -> f (Pdot (path, s)) (Pdot (path', s), d))\n (proj2 comps);\n NameMap.iter\n (fun s mda ->\n iter_components\n (Pdot (path, s)) (Pdot (path', s)) mda.mda_components)\n comps.comp_modules\n | Functor_comps _ -> ()\n in iter_env_cont := (path, cont) :: !iter_env_cont\n in\n IdTbl.iter wrap_module\n (fun id (path, entry) ->\n match entry with\n | Mod_unbound _ -> ()\n | Mod_local data ->\n iter_components (Pident id) path data.mda_components\n | Mod_persistent ->\n let modname = Ident.name id in\n match Persistent_env.find_in_cache !persistent_env modname with\n | None -> ()\n | Some data ->\n iter_components (Pident id) path data.mda_components)\n env.modules\n\nlet run_iter_cont l =\n iter_env_cont := [];\n List.iter (fun c -> c ()) l;\n let cont = List.rev !iter_env_cont in\n iter_env_cont := [];\n cont\n\nlet iter_types f =\n iter_env wrap_identity (fun env -> env.types) (fun sc -> sc.comp_types)\n (fun p1 (p2, tda) -> f p1 (p2, tda.tda_declaration))\n\nlet same_types env1 env2 =\n env1.types == env2.types && env1.modules == env2.modules\n\nlet used_persistent () =\n Persistent_env.fold !persistent_env\n (fun s _m r -> String.Set.add s r)\n String.Set.empty\n\nlet find_all_comps wrap proj s (p, mda) =\n match get_components mda.mda_components with\n Functor_comps _ -> []\n | Structure_comps comps ->\n try\n let c = NameMap.find s (proj comps) in\n [Pdot(p,s), wrap c]\n with Not_found -> []\n\nlet rec find_shadowed_comps path env =\n match path with\n | Pident id ->\n List.filter_map\n (fun (p, data) ->\n match data with\n | Mod_local x -> Some (p, x)\n | Mod_unbound _ | Mod_persistent -> None)\n (IdTbl.find_all wrap_module (Ident.name id) env.modules)\n | Pdot (p, s) ->\n let l = find_shadowed_comps p env in\n let l' =\n List.map\n (find_all_comps wrap_identity\n (fun comps -> comps.comp_modules) s) l\n in\n List.flatten l'\n | Papply _ -> []\n\nlet find_shadowed wrap proj1 proj2 path env =\n match path with\n Pident id ->\n IdTbl.find_all wrap (Ident.name id) (proj1 env)\n | Pdot (p, s) ->\n let l = find_shadowed_comps p env in\n let l' = List.map (find_all_comps wrap proj2 s) l in\n List.flatten l'\n | Papply _ -> []\n\nlet find_shadowed_types path env =\n List.map fst\n (find_shadowed wrap_identity\n (fun env -> env.types) (fun comps -> comps.comp_types) path env)\n\n(* Expand manifest module type names at the top of the given module type *)\n\nlet rec scrape_alias env ?path mty =\n let open Subst.Lazy in\n match mty, path with\n MtyL_ident p, _ ->\n begin try\n scrape_alias env (find_modtype_expansion_lazy p env) ?path\n with Not_found ->\n mty\n end\n | MtyL_alias path, _ ->\n begin try\n scrape_alias env ((find_module_lazy path env).mdl_type) ~path\n with Not_found ->\n (*Location.prerr_warning Location.none\n (Warnings.No_cmi_file (Path.name path));*)\n mty\n end\n | mty, Some path ->\n !strengthen ~aliasable:true env mty path\n | _ -> mty\n\n(* Given a signature and a root path, prefix all idents in the signature\n by the root path and build the corresponding substitution. *)\n\nlet prefix_idents root prefixing_sub sg =\n let open Subst.Lazy in\n let rec prefix_idents root items_and_paths prefixing_sub =\n function\n | [] -> (List.rev items_and_paths, prefixing_sub)\n | SigL_value(id, _, _) as item :: rem ->\n let p = Pdot(root, Ident.name id) in\n prefix_idents root\n ((item, p) :: items_and_paths) prefixing_sub rem\n | SigL_type(id, td, rs, vis) :: rem ->\n let p = Pdot(root, Ident.name id) in\n prefix_idents root\n ((SigL_type(id, td, rs, vis), p) :: items_and_paths)\n (Subst.add_type id p prefixing_sub)\n rem\n | SigL_typext(id, ec, es, vis) :: rem ->\n let p = Pdot(root, Ident.name id) in\n (* we extend the substitution in case of an inlined record *)\n prefix_idents root\n ((SigL_typext(id, ec, es, vis), p) :: items_and_paths)\n (Subst.add_type id p prefixing_sub)\n rem\n | SigL_module(id, pres, md, rs, vis) :: rem ->\n let p = Pdot(root, Ident.name id) in\n prefix_idents root\n ((SigL_module(id, pres, md, rs, vis), p) :: items_and_paths)\n (Subst.add_module id p prefixing_sub)\n rem\n | SigL_modtype(id, mtd, vis) :: rem ->\n let p = Pdot(root, Ident.name id) in\n prefix_idents root\n ((SigL_modtype(id, mtd, vis), p) :: items_and_paths)\n (Subst.add_modtype id (Mty_ident p) prefixing_sub)\n rem\n | SigL_class(id, cd, rs, vis) :: rem ->\n (* pretend this is a type, cf. PR#6650 *)\n let p = Pdot(root, Ident.name id) in\n prefix_idents root\n ((SigL_class(id, cd, rs, vis), p) :: items_and_paths)\n (Subst.add_type id p prefixing_sub)\n rem\n | SigL_class_type(id, ctd, rs, vis) :: rem ->\n let p = Pdot(root, Ident.name id) in\n prefix_idents root\n ((SigL_class_type(id, ctd, rs, vis), p) :: items_and_paths)\n (Subst.add_type id p prefixing_sub)\n rem\n in\n let sg = Subst.Lazy.force_signature_once sg in\n prefix_idents root [] prefixing_sub sg\n\n(* Compute structure descriptions *)\n\nlet add_to_tbl id decl tbl =\n let decls = try NameMap.find id tbl with Not_found -> [] in\n NameMap.add id (decl :: decls) tbl\n\nlet value_declaration_address (_ : t) id decl =\n match decl.val_kind with\n | Val_prim _ -> Lazy_backtrack.create_failed Not_found\n | _ -> Lazy_backtrack.create_forced (Aident id)\n\nlet extension_declaration_address (_ : t) id (_ : extension_constructor) =\n Lazy_backtrack.create_forced (Aident id)\n\nlet class_declaration_address (_ : t) id (_ : class_declaration) =\n Lazy_backtrack.create_forced (Aident id)\n\nlet module_declaration_address env id presence md =\n match presence with\n | Mp_absent -> begin\n let open Subst.Lazy in\n match md.mdl_type with\n | MtyL_alias path -> Lazy_backtrack.create (ModAlias {env; path})\n | _ -> assert false\n end\n | Mp_present ->\n Lazy_backtrack.create_forced (Aident id)\n\nlet is_identchar c =\n (* This should be kept in sync with the [identchar_latin1] character class\n in [lexer.mll] *)\n match c with\n | 'A'..'Z' | 'a'..'z' | '_' | '\\192'..'\\214'\n | '\\216'..'\\246' | '\\248'..'\\255' | '\\'' | '0'..'9' ->\n true\n | _ ->\n false\n\nlet rec components_of_module_maker\n {cm_env; cm_prefixing_subst;\n cm_path; cm_addr; cm_mty; cm_shape} : _ result =\n match scrape_alias cm_env cm_mty with\n MtyL_signature sg ->\n let c =\n { comp_values = NameMap.empty;\n comp_constrs = NameMap.empty;\n comp_labels = NameMap.empty; comp_types = NameMap.empty;\n comp_modules = NameMap.empty; comp_modtypes = NameMap.empty;\n comp_classes = NameMap.empty; comp_cltypes = NameMap.empty }\n in\n let items_and_paths, sub =\n prefix_idents cm_path cm_prefixing_subst sg\n in\n let env = ref cm_env in\n let pos = ref 0 in\n let next_address () =\n let addr : address_unforced =\n Projection { parent = cm_addr; pos = !pos }\n in\n incr pos;\n Lazy_backtrack.create addr\n in\n List.iter (fun ((item : Subst.Lazy.signature_item), path) ->\n match item with\n SigL_value(id, decl, _) ->\n let decl' = Subst.value_description sub decl in\n let addr =\n match decl.val_kind with\n | Val_prim _ -> Lazy_backtrack.create_failed Not_found\n | _ -> next_address ()\n in\n let vda_shape = Shape.proj cm_shape (Shape.Item.value id) in\n let vda =\n { vda_description = decl'; vda_address = addr; vda_shape }\n in\n c.comp_values <- NameMap.add (Ident.name id) vda c.comp_values;\n | SigL_type(id, decl, _, _) ->\n let final_decl = Subst.type_declaration sub decl in\n Btype.set_static_row_name final_decl\n (Subst.type_path sub (Path.Pident id));\n let descrs =\n match decl.type_kind with\n | Type_variant (_,repr) ->\n let cstrs = List.map snd\n (Datarepr.constructors_of_type path final_decl\n ~current_unit:(get_unit_name ()))\n in\n List.iter\n (fun descr ->\n let cda_shape = Shape.leaf descr.cstr_uid in\n let cda = {\n cda_description = descr;\n cda_address = None;\n cda_shape }\n in\n c.comp_constrs <-\n add_to_tbl descr.cstr_name cda c.comp_constrs\n ) cstrs;\n Type_variant (cstrs, repr)\n | Type_record (_, repr) ->\n let lbls = List.map snd\n (Datarepr.labels_of_type path final_decl)\n in\n List.iter\n (fun descr ->\n c.comp_labels <-\n add_to_tbl descr.lbl_name descr c.comp_labels)\n lbls;\n Type_record (lbls, repr)\n | Type_abstract -> Type_abstract\n | Type_open -> Type_open\n in\n let shape = Shape.proj cm_shape (Shape.Item.type_ id) in\n let tda =\n { tda_declaration = final_decl;\n tda_descriptions = descrs;\n tda_shape = shape; }\n in\n c.comp_types <- NameMap.add (Ident.name id) tda c.comp_types;\n env := store_type_infos ~tda_shape:shape id decl !env\n | SigL_typext(id, ext, _, _) ->\n let ext' = Subst.extension_constructor sub ext in\n let descr =\n Datarepr.extension_descr ~current_unit:(get_unit_name ()) path\n ext'\n in\n let addr = next_address () in\n let cda_shape =\n Shape.proj cm_shape (Shape.Item.extension_constructor id)\n in\n let cda =\n { cda_description = descr; cda_address = Some addr; cda_shape }\n in\n c.comp_constrs <- add_to_tbl (Ident.name id) cda c.comp_constrs\n | SigL_module(id, pres, md, _, _) ->\n let md' =\n (* The prefixed items get the same scope as [cm_path], which is\n the prefix. *)\n Subst.Lazy.module_decl\n (Subst.Rescope (Path.scope cm_path)) sub md\n in\n let addr =\n match pres with\n | Mp_absent -> begin\n match md.mdl_type with\n | MtyL_alias path ->\n Lazy_backtrack.create (ModAlias {env = !env; path})\n | _ -> assert false\n end\n | Mp_present -> next_address ()\n in\n let alerts =\n Builtin_attributes.alerts_of_attrs md.mdl_attributes\n in\n let shape = Shape.proj cm_shape (Shape.Item.module_ id) in\n let comps =\n components_of_module ~alerts ~uid:md.mdl_uid !env\n sub path addr md.mdl_type shape\n in\n let mda =\n { mda_declaration = md';\n mda_components = comps;\n mda_address = addr;\n mda_shape = shape; }\n in\n c.comp_modules <-\n NameMap.add (Ident.name id) mda c.comp_modules;\n env :=\n store_module ~update_summary:false ~check:None\n id addr pres md shape !env\n | SigL_modtype(id, decl, _) ->\n let final_decl =\n (* The prefixed items get the same scope as [cm_path], which is\n the prefix. *)\n Subst.Lazy.modtype_decl (Rescope (Path.scope cm_path))\n sub decl\n in\n let shape = Shape.proj cm_shape (Shape.Item.module_type id) in\n let mtda =\n { mtda_declaration = final_decl;\n mtda_shape = shape; }\n in\n c.comp_modtypes <-\n NameMap.add (Ident.name id) mtda c.comp_modtypes;\n env := store_modtype ~update_summary:false id decl shape !env\n | SigL_class(id, decl, _, _) ->\n let decl' = Subst.class_declaration sub decl in\n let addr = next_address () in\n let shape = Shape.proj cm_shape (Shape.Item.class_ id) in\n let clda =\n { clda_declaration = decl';\n clda_address = addr;\n clda_shape = shape; }\n in\n c.comp_classes <- NameMap.add (Ident.name id) clda c.comp_classes\n | SigL_class_type(id, decl, _, _) ->\n let decl' = Subst.cltype_declaration sub decl in\n let shape = Shape.proj cm_shape (Shape.Item.class_type id) in\n let cltda = { cltda_declaration = decl'; cltda_shape = shape } in\n c.comp_cltypes <-\n NameMap.add (Ident.name id) cltda c.comp_cltypes)\n items_and_paths;\n Ok (Structure_comps c)\n | MtyL_functor(arg, ty_res) ->\n let sub = cm_prefixing_subst in\n let scoping = Subst.Rescope (Path.scope cm_path) in\n let open Subst.Lazy in\n Ok (Functor_comps {\n (* fcomp_arg and fcomp_res must be prefixed eagerly, because\n they are interpreted in the outer environment *)\n fcomp_arg =\n (match arg with\n | Unit -> Unit\n | Named (param, ty_arg) ->\n Named (param, force_modtype (modtype scoping sub ty_arg)));\n fcomp_res = force_modtype (modtype scoping sub ty_res);\n fcomp_shape = cm_shape;\n fcomp_cache = Hashtbl.create 17;\n fcomp_subst_cache = Hashtbl.create 17 })\n | MtyL_ident _ -> Error No_components_abstract\n | MtyL_alias p -> Error (No_components_alias p)\n\n(* Insertion of bindings by identifier + path *)\n\nand check_usage loc id uid warn tbl =\n if not loc.Location.loc_ghost &&\n Uid.for_actual_declaration uid &&\n Warnings.is_active (warn \"\")\n then begin\n let name = Ident.name id in\n if Types.Uid.Tbl.mem tbl uid then ()\n else let used = ref false in\n Types.Uid.Tbl.add tbl uid (fun () -> used := true);\n if not (name = \"\" || name.[0] = '_' || name.[0] = '#')\n then\n !add_delayed_check_forward\n (fun () -> if not !used then Location.prerr_warning loc (warn name))\n end;\n\nand check_value_name name loc =\n (* Note: we could also check here general validity of the\n identifier, to protect against bad identifiers forged by -pp or\n -ppx preprocessors. *)\n if String.length name > 0 && not (is_identchar name.[0]) then\n for i = 1 to String.length name - 1 do\n if name.[i] = '#' then\n error (Illegal_value_name(loc, name))\n done\n\nand store_value ?check id addr decl shape env =\n check_value_name (Ident.name id) decl.val_loc;\n Option.iter\n (fun f -> check_usage decl.val_loc id decl.val_uid f !value_declarations)\n check;\n let vda =\n { vda_description = decl;\n vda_address = addr;\n vda_shape = shape }\n in\n { env with\n values = IdTbl.add id (Val_bound vda) env.values;\n summary = Env_value(env.summary, id, decl) }\n\nand store_constructor ~check type_decl type_id cstr_id cstr env =\n if check && not type_decl.type_loc.Location.loc_ghost\n && Warnings.is_active (Warnings.Unused_constructor (\"\", Unused))\n then begin\n let ty_name = Ident.name type_id in\n let name = cstr.cstr_name in\n let loc = cstr.cstr_loc in\n let k = cstr.cstr_uid in\n let priv = type_decl.type_private in\n if not (Types.Uid.Tbl.mem !used_constructors k) then begin\n let used = constructor_usages () in\n Types.Uid.Tbl.add !used_constructors k\n (add_constructor_usage used);\n if not (ty_name = \"\" || ty_name.[0] = '_')\n then\n !add_delayed_check_forward\n (fun () ->\n Option.iter\n (fun complaint ->\n if not (is_in_signature env) then\n Location.prerr_warning loc\n (Warnings.Unused_constructor(name, complaint)))\n (constructor_usage_complaint ~rebind:false priv used));\n end;\n end;\n let cda_shape = Shape.leaf cstr.cstr_uid in\n { env with\n constrs =\n TycompTbl.add cstr_id\n { cda_description = cstr; cda_address = None; cda_shape } env.constrs;\n }\n\nand store_label ~check type_decl type_id lbl_id lbl env =\n if check && not type_decl.type_loc.Location.loc_ghost\n && Warnings.is_active (Warnings.Unused_field (\"\", Unused))\n then begin\n let ty_name = Ident.name type_id in\n let priv = type_decl.type_private in\n let name = lbl.lbl_name in\n let loc = lbl.lbl_loc in\n let mut = lbl.lbl_mut in\n let k = lbl.lbl_uid in\n if not (Types.Uid.Tbl.mem !used_labels k) then\n let used = label_usages () in\n Types.Uid.Tbl.add !used_labels k\n (add_label_usage used);\n if not (ty_name = \"\" || ty_name.[0] = '_' || name.[0] = '_')\n then !add_delayed_check_forward\n (fun () ->\n Option.iter\n (fun complaint ->\n if not (is_in_signature env) then\n Location.prerr_warning\n loc (Warnings.Unused_field(name, complaint)))\n (label_usage_complaint priv mut used))\n end;\n { env with\n labels = TycompTbl.add lbl_id lbl env.labels;\n }\n\nand store_type ~check id info shape env =\n let loc = info.type_loc in\n if check then\n check_usage loc id info.type_uid\n (fun s -> Warnings.Unused_type_declaration s)\n !type_declarations;\n let descrs, env =\n let path = Pident id in\n match info.type_kind with\n | Type_variant (_,repr) ->\n let constructors = Datarepr.constructors_of_type path info\n ~current_unit:(get_unit_name ())\n in\n Type_variant (List.map snd constructors, repr),\n List.fold_left\n (fun env (cstr_id, cstr) ->\n store_constructor ~check info id cstr_id cstr env)\n env constructors\n | Type_record (_, repr) ->\n let labels = Datarepr.labels_of_type path info in\n Type_record (List.map snd labels, repr),\n List.fold_left\n (fun env (lbl_id, lbl) ->\n store_label ~check info id lbl_id lbl env)\n env labels\n | Type_abstract -> Type_abstract, env\n | Type_open -> Type_open, env\n in\n let tda =\n { tda_declaration = info;\n tda_descriptions = descrs;\n tda_shape = shape }\n in\n { env with\n types = IdTbl.add id tda env.types;\n summary = Env_type(env.summary, id, info) }\n\nand store_type_infos ~tda_shape id info env =\n (* Simplified version of store_type that doesn't compute and store\n constructor and label infos, but simply record the arity and\n manifest-ness of the type. Used in components_of_module to\n keep track of type abbreviations (e.g. type t = float) in the\n computation of label representations. *)\n let tda =\n {\n tda_declaration = info;\n tda_descriptions = Type_abstract;\n tda_shape\n }\n in\n { env with\n types = IdTbl.add id tda env.types;\n summary = Env_type(env.summary, id, info) }\n\nand store_extension ~check ~rebind id addr ext shape env =\n let loc = ext.ext_loc in\n let cstr =\n Datarepr.extension_descr ~current_unit:(get_unit_name ()) (Pident id) ext\n in\n let cda =\n { cda_description = cstr;\n cda_address = Some addr;\n cda_shape = shape }\n in\n if check && not loc.Location.loc_ghost &&\n Warnings.is_active (Warnings.Unused_extension (\"\", false, Unused))\n then begin\n let priv = ext.ext_private in\n let is_exception = Path.same ext.ext_type_path Predef.path_exn in\n let name = cstr.cstr_name in\n let k = cstr.cstr_uid in\n if not (Types.Uid.Tbl.mem !used_constructors k) then begin\n let used = constructor_usages () in\n Types.Uid.Tbl.add !used_constructors k\n (add_constructor_usage used);\n !add_delayed_check_forward\n (fun () ->\n Option.iter\n (fun complaint ->\n if not (is_in_signature env) then\n Location.prerr_warning loc\n (Warnings.Unused_extension\n (name, is_exception, complaint)))\n (constructor_usage_complaint ~rebind priv used))\n end;\n end;\n { env with\n constrs = TycompTbl.add id cda env.constrs;\n summary = Env_extension(env.summary, id, ext) }\n\nand store_module ?(update_summary=true) ~check\n id addr presence md shape env =\n let open Subst.Lazy in\n let loc = md.mdl_loc in\n Option.iter\n (fun f -> check_usage loc id md.mdl_uid f !module_declarations) check;\n let alerts = Builtin_attributes.alerts_of_attrs md.mdl_attributes in\n let comps =\n components_of_module ~alerts ~uid:md.mdl_uid\n env Subst.identity (Pident id) addr md.mdl_type shape\n in\n let mda =\n { mda_declaration = md;\n mda_components = comps;\n mda_address = addr;\n mda_shape = shape }\n in\n let summary =\n if not update_summary then env.summary\n else Env_module (env.summary, id, presence, force_module_decl md) in\n { env with\n modules = IdTbl.add id (Mod_local mda) env.modules;\n summary }\n\nand store_modtype ?(update_summary=true) id info shape env =\n let mtda = { mtda_declaration = info; mtda_shape = shape } in\n let summary =\n if not update_summary then env.summary\n else Env_modtype (env.summary, id, Subst.Lazy.force_modtype_decl info) in\n { env with\n modtypes = IdTbl.add id mtda env.modtypes;\n summary }\n\nand store_class id addr desc shape env =\n let clda =\n { clda_declaration = desc;\n clda_address = addr;\n clda_shape = shape; }\n in\n { env with\n classes = IdTbl.add id clda env.classes;\n summary = Env_class(env.summary, id, desc) }\n\nand store_cltype id desc shape env =\n let cltda = { cltda_declaration = desc; cltda_shape = shape } in\n { env with\n cltypes = IdTbl.add id cltda env.cltypes;\n summary = Env_cltype(env.summary, id, desc) }\n\nlet scrape_alias env mty = scrape_alias env mty\n\n(* Compute the components of a functor application in a path. *)\n\nlet components_of_functor_appl ~loc ~f_path ~f_comp ~arg env =\n try\n let c = Hashtbl.find f_comp.fcomp_cache arg in\n c\n with Not_found ->\n let p = Papply(f_path, arg) in\n let sub =\n match f_comp.fcomp_arg with\n | Unit\n | Named (None, _) -> Subst.identity\n | Named (Some param, _) -> Subst.add_module param arg Subst.identity\n in\n (* we have to apply eagerly instead of passing sub to [components_of_module]\n because of the call to [check_well_formed_module]. *)\n let mty = Subst.modtype (Rescope (Path.scope p)) sub f_comp.fcomp_res in\n let addr = Lazy_backtrack.create_failed Not_found in\n !check_well_formed_module env loc\n (\"the signature of \" ^ Path.name p) mty;\n let shape_arg =\n shape_of_path ~namespace:Shape.Sig_component_kind.Module env arg\n in\n let shape = Shape.app f_comp.fcomp_shape ~arg:shape_arg in\n let comps =\n components_of_module ~alerts:Misc.Stdlib.String.Map.empty\n ~uid:Uid.internal_not_actually_unique\n (*???*)\n env Subst.identity p addr (Subst.Lazy.of_modtype mty) shape\n in\n Hashtbl.add f_comp.fcomp_cache arg comps;\n comps\n\n(* Define forward functions *)\n\nlet _ =\n components_of_functor_appl' := components_of_functor_appl;\n components_of_module_maker' := components_of_module_maker\n\n(* Insertion of bindings by identifier *)\n\nlet add_functor_arg id env =\n {env with\n functor_args = Ident.add id () env.functor_args;\n summary = Env_functor_arg (env.summary, id)}\n\nlet add_value ?check ?shape id desc env =\n let addr = value_declaration_address env id desc in\n let shape = shape_or_leaf desc.val_uid shape in\n store_value ?check id addr desc shape env\n\nlet add_type ~check ?shape id info env =\n let shape = shape_or_leaf info.type_uid shape in\n store_type ~check id info shape env\n\nand add_extension ~check ?shape ~rebind id ext env =\n let addr = extension_declaration_address env id ext in\n let shape = shape_or_leaf ext.ext_uid shape in\n store_extension ~check ~rebind id addr ext shape env\n\nand add_module_declaration ?(arg=false) ?shape ~check id presence md env =\n let check =\n if not check then\n None\n else if arg && is_in_signature env then\n Some (fun s -> Warnings.Unused_functor_parameter s)\n else\n Some (fun s -> Warnings.Unused_module s)\n in\n let md = Subst.Lazy.of_module_decl md in\n let addr = module_declaration_address env id presence md in\n let shape = shape_or_leaf md.mdl_uid shape in\n let env = store_module ~check id addr presence md shape env in\n if arg then add_functor_arg id env else env\n\nand add_module_declaration_lazy ~update_summary id presence md env =\n let addr = module_declaration_address env id presence md in\n let shape = Shape.leaf md.Subst.Lazy.mdl_uid in\n let env =\n store_module ~update_summary ~check:None id addr presence md shape env\n in\n env\n\nand add_modtype ?shape id info env =\n let shape = shape_or_leaf info.mtd_uid shape in\n store_modtype id (Subst.Lazy.of_modtype_decl info) shape env\n\nand add_modtype_lazy ~update_summary id info env =\n let shape = Shape.leaf info.Subst.Lazy.mtdl_uid in\n store_modtype ~update_summary id info shape env\n\nand add_class ?shape id ty env =\n let addr = class_declaration_address env id ty in\n let shape = shape_or_leaf ty.cty_uid shape in\n store_class id addr ty shape env\n\nand add_cltype ?shape id ty env =\n let shape = shape_or_leaf ty.clty_uid shape in\n store_cltype id ty shape env\n\nlet add_module ?arg ?shape id presence mty env =\n add_module_declaration ~check:false ?arg ?shape id presence (md mty) env\n\nlet add_local_type path info env =\n { env with\n local_constraints = Path.Map.add path info env.local_constraints }\n\n(* Non-lazy version of scrape_alias *)\nlet scrape_alias t mty =\n mty |> Subst.Lazy.of_modtype |> scrape_alias t |> Subst.Lazy.force_modtype\n\n(* Insertion of bindings by name *)\n\nlet enter_value ?check name desc env =\n let id = Ident.create_local name in\n let addr = value_declaration_address env id desc in\n let env = store_value ?check id addr desc (Shape.leaf desc.val_uid) env in\n (id, env)\n\nlet enter_type ~scope name info env =\n let id = Ident.create_scoped ~scope name in\n let env = store_type ~check:true id info (Shape.leaf info.type_uid) env in\n (id, env)\n\nlet enter_extension ~scope ~rebind name ext env =\n let id = Ident.create_scoped ~scope name in\n let addr = extension_declaration_address env id ext in\n let shape = Shape.leaf ext.ext_uid in\n let env = store_extension ~check:true ~rebind id addr ext shape env in\n (id, env)\n\nlet enter_module_declaration ~scope ?arg ?shape s presence md env =\n let id = Ident.create_scoped ~scope s in\n (id, add_module_declaration ?arg ?shape ~check:true id presence md env)\n\nlet enter_modtype ~scope name mtd env =\n let id = Ident.create_scoped ~scope name in\n let shape = Shape.leaf mtd.mtd_uid in\n let env = store_modtype id (Subst.Lazy.of_modtype_decl mtd) shape env in\n (id, env)\n\nlet enter_class ~scope name desc env =\n let id = Ident.create_scoped ~scope name in\n let addr = class_declaration_address env id desc in\n let env = store_class id addr desc (Shape.leaf desc.cty_uid) env in\n (id, env)\n\nlet enter_cltype ~scope name desc env =\n let id = Ident.create_scoped ~scope name in\n let env = store_cltype id desc (Shape.leaf desc.clty_uid) env in\n (id, env)\n\nlet enter_module ~scope ?arg s presence mty env =\n enter_module_declaration ~scope ?arg s presence (md mty) env\n\n(* Insertion of all components of a signature *)\n\nlet add_item (map, mod_shape) comp env =\n let proj_shape item =\n match mod_shape with\n | None -> map, None\n | Some mod_shape ->\n let shape = Shape.proj mod_shape item in\n Shape.Map.add map item shape, Some shape\n in\n match comp with\n | Sig_value(id, decl, _) ->\n let map, shape = proj_shape (Shape.Item.value id) in\n map, add_value ?shape id decl env\n | Sig_type(id, decl, _, _) ->\n let map, shape = proj_shape (Shape.Item.type_ id) in\n map, add_type ~check:false ?shape id decl env\n | Sig_typext(id, ext, _, _) ->\n let map, shape = proj_shape (Shape.Item.extension_constructor id) in\n map, add_extension ~check:false ?shape ~rebind:false id ext env\n | Sig_module(id, presence, md, _, _) ->\n let map, shape = proj_shape (Shape.Item.module_ id) in\n map, add_module_declaration ~check:false ?shape id presence md env\n | Sig_modtype(id, decl, _) ->\n let map, shape = proj_shape (Shape.Item.module_type id) in\n map, add_modtype ?shape id decl env\n | Sig_class(id, decl, _, _) ->\n let map, shape = proj_shape (Shape.Item.class_ id) in\n map, add_class ?shape id decl env\n | Sig_class_type(id, decl, _, _) ->\n let map, shape = proj_shape (Shape.Item.class_type id) in\n map, add_cltype ?shape id decl env\n\nlet rec add_signature (map, mod_shape) sg env =\n match sg with\n [] -> map, env\n | comp :: rem ->\n let map, env = add_item (map, mod_shape) comp env in\n add_signature (map, mod_shape) rem env\n\nlet enter_signature_and_shape ~scope ~parent_shape mod_shape sg env =\n let sg = Subst.signature (Rescope scope) Subst.identity sg in\n let shape, env = add_signature (parent_shape, mod_shape) sg env in\n sg, shape, env\n\nlet enter_signature ?mod_shape ~scope sg env =\n let sg, _, env =\n enter_signature_and_shape ~scope ~parent_shape:Shape.Map.empty\n mod_shape sg env\n in\n sg, env\n\nlet enter_signature_and_shape ~scope ~parent_shape mod_shape sg env =\n enter_signature_and_shape ~scope ~parent_shape (Some mod_shape) sg env\n\nlet add_value = add_value ?shape:None\nlet add_type = add_type ?shape:None\nlet add_extension = add_extension ?shape:None\nlet add_class = add_class ?shape:None\nlet add_cltype = add_cltype ?shape:None\nlet add_modtype = add_modtype ?shape:None\nlet add_signature sg env =\n let _, env = add_signature (Shape.Map.empty, None) sg env in\n env\n\n(* Add \"unbound\" bindings *)\n\nlet enter_unbound_value name reason env =\n let id = Ident.create_local name in\n { env with\n values = IdTbl.add id (Val_unbound reason) env.values;\n summary = Env_value_unbound(env.summary, name, reason) }\n\nlet enter_unbound_module name reason env =\n let id = Ident.create_local name in\n { env with\n modules = IdTbl.add id (Mod_unbound reason) env.modules;\n summary = Env_module_unbound(env.summary, name, reason) }\n\n(* Open a signature path *)\n\nlet add_components slot root env0 comps =\n let add_l w comps env0 =\n TycompTbl.add_open slot w root comps env0\n in\n let add w comps env0 = IdTbl.add_open slot w root comps env0 in\n let constrs =\n add_l (fun x -> `Constructor x) comps.comp_constrs env0.constrs\n in\n let labels =\n add_l (fun x -> `Label x) comps.comp_labels env0.labels\n in\n let values =\n add (fun x -> `Value x) comps.comp_values env0.values\n in\n let types =\n add (fun x -> `Type x) comps.comp_types env0.types\n in\n let modtypes =\n add (fun x -> `Module_type x) comps.comp_modtypes env0.modtypes\n in\n let classes =\n add (fun x -> `Class x) comps.comp_classes env0.classes\n in\n let cltypes =\n add (fun x -> `Class_type x) comps.comp_cltypes env0.cltypes\n in\n let modules =\n add (fun x -> `Module x) comps.comp_modules env0.modules\n in\n { env0 with\n summary = Env_open(env0.summary, root);\n constrs;\n labels;\n values;\n types;\n modtypes;\n classes;\n cltypes;\n modules;\n }\n\nlet open_signature slot root env0 : (_,_) result =\n match get_components_res (find_module_components root env0) with\n | Error _ -> Error `Not_found\n | exception Not_found -> Error `Not_found\n | Ok (Functor_comps _) -> Error `Functor\n | Ok (Structure_comps comps) ->\n Ok (add_components slot root env0 comps)\n\nlet remove_last_open root env0 =\n let rec filter_summary summary =\n match summary with\n Env_empty -> raise Exit\n | Env_open (s, p) ->\n if Path.same p root then s else raise Exit\n | Env_value _\n | Env_type _\n | Env_extension _\n | Env_module _\n | Env_modtype _\n | Env_class _\n | Env_cltype _\n | Env_functor_arg _\n | Env_constraints _\n | Env_persistent _\n | Env_copy_types _\n | Env_value_unbound _\n | Env_module_unbound _ ->\n map_summary filter_summary summary\n in\n match filter_summary env0.summary with\n | summary ->\n let rem_l tbl = TycompTbl.remove_last_open root tbl\n and rem tbl = IdTbl.remove_last_open root tbl in\n Some { env0 with\n summary;\n constrs = rem_l env0.constrs;\n labels = rem_l env0.labels;\n values = rem env0.values;\n types = rem env0.types;\n modtypes = rem env0.modtypes;\n classes = rem env0.classes;\n cltypes = rem env0.cltypes;\n modules = rem env0.modules; }\n | exception Exit ->\n None\n\n(* Open a signature from a file *)\n\nlet open_pers_signature name env =\n match open_signature None (Pident(Ident.create_persistent name)) env with\n | (Ok _ | Error `Not_found as res) -> res\n | Error `Functor -> assert false\n (* a compilation unit cannot refer to a functor *)\n\nlet open_signature\n ?(used_slot = ref false)\n ?(loc = Location.none) ?(toplevel = false)\n ovf root env =\n let unused =\n match ovf with\n | Asttypes.Fresh -> Warnings.Unused_open (Path.name root)\n | Asttypes.Override -> Warnings.Unused_open_bang (Path.name root)\n in\n let warn_unused =\n Warnings.is_active unused\n and warn_shadow_id =\n Warnings.is_active (Warnings.Open_shadow_identifier (\"\", \"\"))\n and warn_shadow_lc =\n Warnings.is_active (Warnings.Open_shadow_label_constructor (\"\",\"\"))\n in\n if not toplevel && not loc.Location.loc_ghost\n && (warn_unused || warn_shadow_id || warn_shadow_lc)\n then begin\n let used = used_slot in\n if warn_unused then\n !add_delayed_check_forward\n (fun () ->\n if not !used then begin\n used := true;\n Location.prerr_warning loc unused\n end\n );\n let shadowed = ref [] in\n let slot s b =\n begin match check_shadowing env b with\n | Some kind when\n ovf = Asttypes.Fresh && not (List.mem (kind, s) !shadowed) ->\n shadowed := (kind, s) :: !shadowed;\n let w =\n match kind with\n | \"label\" | \"constructor\" ->\n Warnings.Open_shadow_label_constructor (kind, s)\n | _ -> Warnings.Open_shadow_identifier (kind, s)\n in\n Location.prerr_warning loc w\n | _ -> ()\n end;\n used := true\n in\n open_signature (Some slot) root env\n end\n else open_signature None root env\n\n(* Read a signature from a file *)\nlet read_signature modname filename =\n let mda = read_pers_mod modname filename in\n let md = Subst.Lazy.force_module_decl mda.mda_declaration in\n match md.md_type with\n | Mty_signature sg -> sg\n | Mty_ident _ | Mty_functor _ | Mty_alias _ -> assert false\n\nlet is_identchar_latin1 = function\n | 'A'..'Z' | 'a'..'z' | '_' | '\\192'..'\\214' | '\\216'..'\\246'\n | '\\248'..'\\255' | '\\'' | '0'..'9' -> true\n | _ -> false\n\nlet unit_name_of_filename fn =\n match Filename.extension fn with\n | \".cmi\" -> begin\n let unit =\n String.capitalize_ascii (Filename.remove_extension fn)\n in\n if String.for_all is_identchar_latin1 unit then\n Some unit\n else\n None\n end\n | _ -> None\n\nlet persistent_structures_of_dir dir =\n Load_path.Dir.files dir\n |> List.to_seq\n |> Seq.filter_map unit_name_of_filename\n |> String.Set.of_seq\n\n(* Save a signature to a file *)\nlet save_signature_with_transform cmi_transform ~alerts sg modname filename =\n Btype.cleanup_abbrev ();\n Subst.reset_for_saving ();\n let sg = Subst.signature Make_local (Subst.for_saving Subst.identity) sg in\n let cmi =\n Persistent_env.make_cmi !persistent_env modname sg alerts\n |> cmi_transform in\n let pm = save_sign_of_cmi\n { Persistent_env.Persistent_signature.cmi; filename } in\n Persistent_env.save_cmi !persistent_env\n { Persistent_env.Persistent_signature.filename; cmi } pm;\n cmi\n\nlet save_signature ~alerts sg modname filename =\n save_signature_with_transform (fun cmi -> cmi)\n ~alerts sg modname filename\n\nlet save_signature_with_imports ~alerts sg modname filename imports =\n let with_imports cmi = { cmi with cmi_crcs = imports } in\n save_signature_with_transform with_imports\n ~alerts sg modname filename\n\n(* Make the initial environment *)\nlet (initial_safe_string, initial_unsafe_string) =\n Predef.build_initial_env\n (add_type ~check:false)\n (add_extension ~check:false ~rebind:false)\n empty\n\n(* Tracking usage *)\n\nlet mark_module_used uid =\n match Types.Uid.Tbl.find !module_declarations uid with\n | mark -> mark ()\n | exception Not_found -> ()\n\nlet mark_modtype_used _uid = ()\n\nlet mark_value_used uid =\n match Types.Uid.Tbl.find !value_declarations uid with\n | mark -> mark ()\n | exception Not_found -> ()\n\nlet mark_type_used uid =\n match Types.Uid.Tbl.find !type_declarations uid with\n | mark -> mark ()\n | exception Not_found -> ()\n\nlet mark_type_path_used env path =\n match find_type path env with\n | decl -> mark_type_used decl.type_uid\n | exception Not_found -> ()\n\nlet mark_constructor_used usage cd =\n match Types.Uid.Tbl.find !used_constructors cd.cd_uid with\n | mark -> mark usage\n | exception Not_found -> ()\n\nlet mark_extension_used usage ext =\n match Types.Uid.Tbl.find !used_constructors ext.ext_uid with\n | mark -> mark usage\n | exception Not_found -> ()\n\nlet mark_label_used usage ld =\n match Types.Uid.Tbl.find !used_labels ld.ld_uid with\n | mark -> mark usage\n | exception Not_found -> ()\n\nlet mark_constructor_description_used usage env cstr =\n let ty_path = Btype.cstr_type_path cstr in\n mark_type_path_used env ty_path;\n match Types.Uid.Tbl.find !used_constructors cstr.cstr_uid with\n | mark -> mark usage\n | exception Not_found -> ()\n\nlet mark_label_description_used usage env lbl =\n let ty_path =\n match get_desc lbl.lbl_res with\n | Tconstr(path, _, _) -> path\n | _ -> assert false\n in\n mark_type_path_used env ty_path;\n match Types.Uid.Tbl.find !used_labels lbl.lbl_uid with\n | mark -> mark usage\n | exception Not_found -> ()\n\nlet mark_class_used uid =\n match Types.Uid.Tbl.find !type_declarations uid with\n | mark -> mark ()\n | exception Not_found -> ()\n\nlet mark_cltype_used uid =\n match Types.Uid.Tbl.find !type_declarations uid with\n | mark -> mark ()\n | exception Not_found -> ()\n\nlet set_value_used_callback vd callback =\n Types.Uid.Tbl.add !value_declarations vd.val_uid callback\n\nlet set_type_used_callback td callback =\n if Uid.for_actual_declaration td.type_uid then\n let old =\n try Types.Uid.Tbl.find !type_declarations td.type_uid\n with Not_found -> ignore\n in\n Types.Uid.Tbl.replace !type_declarations td.type_uid\n (fun () -> callback old)\n\n(* Lookup by name *)\n\nlet may_lookup_error report_errors loc env err =\n if report_errors then lookup_error loc env err\n else raise Not_found\n\nlet report_module_unbound ~errors ~loc env reason =\n match reason with\n | Mod_unbound_illegal_recursion ->\n (* see #5965 *)\n may_lookup_error errors loc env Illegal_reference_to_recursive_module\n\nlet report_value_unbound ~errors ~loc env reason lid =\n match reason with\n | Val_unbound_instance_variable ->\n may_lookup_error errors loc env (Masked_instance_variable lid)\n | Val_unbound_self ->\n may_lookup_error errors loc env (Masked_self_variable lid)\n | Val_unbound_ancestor ->\n may_lookup_error errors loc env (Masked_ancestor_variable lid)\n | Val_unbound_ghost_recursive rloc ->\n let show_hint =\n (* Only display the \"missing rec\" hint for non-ghost code *)\n not loc.Location.loc_ghost\n && not rloc.Location.loc_ghost\n in\n let hint =\n if show_hint then Missing_rec rloc else No_hint\n in\n may_lookup_error errors loc env (Unbound_value(lid, hint))\n\nlet use_module ~use ~loc path mda =\n if use then begin\n let comps = mda.mda_components in\n mark_module_used comps.uid;\n Misc.Stdlib.String.Map.iter\n (fun kind message ->\n let message = if message = \"\" then \"\" else \"\\n\" ^ message in\n Location.alert ~kind loc\n (Printf.sprintf \"module %s%s\" (Path.name path) message)\n )\n comps.alerts\n end\n\nlet use_value ~use ~loc path vda =\n if use then begin\n let desc = vda.vda_description in\n mark_value_used desc.val_uid;\n Builtin_attributes.check_alerts loc desc.val_attributes\n (Path.name path)\n end\n\nlet use_type ~use ~loc path tda =\n if use then begin\n let decl = tda.tda_declaration in\n mark_type_used decl.type_uid;\n Builtin_attributes.check_alerts loc decl.type_attributes\n (Path.name path)\n end\n\nlet use_modtype ~use ~loc path desc =\n let open Subst.Lazy in\n if use then begin\n mark_modtype_used desc.mtdl_uid;\n Builtin_attributes.check_alerts loc desc.mtdl_attributes\n (Path.name path)\n end\n\nlet use_class ~use ~loc path clda =\n if use then begin\n let desc = clda.clda_declaration in\n mark_class_used desc.cty_uid;\n Builtin_attributes.check_alerts loc desc.cty_attributes\n (Path.name path)\n end\n\nlet use_cltype ~use ~loc path desc =\n if use then begin\n mark_cltype_used desc.clty_uid;\n Builtin_attributes.check_alerts loc desc.clty_attributes\n (Path.name path)\n end\n\nlet use_label ~use ~loc usage env lbl =\n if use then begin\n mark_label_description_used usage env lbl;\n Builtin_attributes.check_alerts loc lbl.lbl_attributes lbl.lbl_name\n end\n\nlet use_constructor_desc ~use ~loc usage env cstr =\n if use then begin\n mark_constructor_description_used usage env cstr;\n Builtin_attributes.check_alerts loc cstr.cstr_attributes cstr.cstr_name\n end\n\nlet use_constructor ~use ~loc usage env cda =\n use_constructor_desc ~use ~loc usage env cda.cda_description\n\ntype _ load =\n | Load : module_data load\n | Don't_load : unit load\n\nlet lookup_ident_module (type a) (load : a load) ~errors ~use ~loc s env =\n let path, data =\n match find_name_module ~mark:use s env.modules with\n | res -> res\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_module (Lident s))\n in\n match data with\n | Mod_local mda -> begin\n use_module ~use ~loc path mda;\n match load with\n | Load -> path, (mda : a)\n | Don't_load -> path, (() : a)\n end\n | Mod_unbound reason ->\n report_module_unbound ~errors ~loc env reason\n | Mod_persistent -> begin\n match load with\n | Don't_load ->\n check_pers_mod ~loc s;\n path, (() : a)\n | Load -> begin\n match find_pers_mod s with\n | mda ->\n use_module ~use ~loc path mda;\n path, (mda : a)\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_module (Lident s))\n end\n end\n\nlet lookup_ident_value ~errors ~use ~loc name env =\n match IdTbl.find_name wrap_value ~mark:use name env.values with\n | (path, Val_bound vda) ->\n use_value ~use ~loc path vda;\n path, vda.vda_description\n | (_, Val_unbound reason) ->\n report_value_unbound ~errors ~loc env reason (Lident name)\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_value (Lident name, No_hint))\n\nlet lookup_ident_type ~errors ~use ~loc s env =\n match IdTbl.find_name wrap_identity ~mark:use s env.types with\n | (path, data) as res ->\n use_type ~use ~loc path data;\n res\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_type (Lident s))\n\nlet lookup_ident_modtype ~errors ~use ~loc s env =\n match IdTbl.find_name wrap_identity ~mark:use s env.modtypes with\n | (path, data) ->\n use_modtype ~use ~loc path data.mtda_declaration;\n (path, data.mtda_declaration)\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_modtype (Lident s))\n\nlet lookup_ident_class ~errors ~use ~loc s env =\n match IdTbl.find_name wrap_identity ~mark:use s env.classes with\n | (path, clda) ->\n use_class ~use ~loc path clda;\n path, clda.clda_declaration\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_class (Lident s))\n\nlet lookup_ident_cltype ~errors ~use ~loc s env =\n match IdTbl.find_name wrap_identity ~mark:use s env.cltypes with\n | path, cltda ->\n use_cltype ~use ~loc path cltda.cltda_declaration;\n path, cltda.cltda_declaration\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_cltype (Lident s))\n\nlet lookup_all_ident_labels ~errors ~use ~loc usage s env =\n match TycompTbl.find_all ~mark:use s env.labels with\n | [] -> may_lookup_error errors loc env (Unbound_label (Lident s))\n | lbls -> begin\n List.map\n (fun (lbl, use_fn) ->\n let use_fn () =\n use_label ~use ~loc usage env lbl;\n use_fn ()\n in\n (lbl, use_fn))\n lbls\n end\n\nlet lookup_all_ident_constructors ~errors ~use ~loc usage s env =\n match TycompTbl.find_all ~mark:use s env.constrs with\n | [] -> may_lookup_error errors loc env (Unbound_constructor (Lident s))\n | cstrs ->\n List.map\n (fun (cda, use_fn) ->\n let use_fn () =\n use_constructor ~use ~loc usage env cda;\n use_fn ()\n in\n (cda.cda_description, use_fn))\n cstrs\n\nlet rec lookup_module_components ~errors ~use ~loc lid env =\n match lid with\n | Lident s ->\n let path, data = lookup_ident_module Load ~errors ~use ~loc s env in\n path, data.mda_components\n | Ldot(l, s) ->\n let path, data = lookup_dot_module ~errors ~use ~loc l s env in\n path, data.mda_components\n | Lapply _ as lid ->\n let f_path, f_comp, arg = lookup_apply ~errors ~use ~loc lid env in\n let comps =\n !components_of_functor_appl' ~loc ~f_path ~f_comp ~arg env in\n Papply (f_path, arg), comps\n\nand lookup_structure_components ~errors ~use ~loc lid env =\n let path, comps = lookup_module_components ~errors ~use ~loc lid env in\n match get_components_res comps with\n | Ok (Structure_comps comps) -> path, comps\n | Ok (Functor_comps _) ->\n may_lookup_error errors loc env (Functor_used_as_structure lid)\n | Error No_components_abstract ->\n may_lookup_error errors loc env (Abstract_used_as_structure lid)\n | Error (No_components_alias p) ->\n may_lookup_error errors loc env (Cannot_scrape_alias(lid, p))\n\nand get_functor_components ~errors ~loc lid env comps =\n match get_components_res comps with\n | Ok (Functor_comps fcomps) -> begin\n match fcomps.fcomp_arg with\n | Unit -> (* PR#7611 *)\n may_lookup_error errors loc env (Generative_used_as_applicative lid)\n | Named (_, arg) -> fcomps, arg\n end\n | Ok (Structure_comps _) ->\n may_lookup_error errors loc env (Structure_used_as_functor lid)\n | Error No_components_abstract ->\n may_lookup_error errors loc env (Abstract_used_as_functor lid)\n | Error (No_components_alias p) ->\n may_lookup_error errors loc env (Cannot_scrape_alias(lid, p))\n\nand lookup_all_args ~errors ~use ~loc lid0 env =\n let rec loop_lid_arg args = function\n | Lident _ | Ldot _ as f_lid ->\n (f_lid, args)\n | Lapply (f_lid, arg_lid) ->\n let arg_path, arg_md = lookup_module ~errors ~use ~loc arg_lid env in\n loop_lid_arg ((f_lid,arg_path,arg_md.md_type)::args) f_lid\n in\n loop_lid_arg [] lid0\n\nand lookup_apply ~errors ~use ~loc lid0 env =\n let f0_lid, args0 = lookup_all_args ~errors ~use ~loc lid0 env in\n let args_for_errors = List.map (fun (_,p,mty) -> (p,mty)) args0 in\n let f0_path, f0_comp =\n lookup_module_components ~errors ~use ~loc f0_lid env\n in\n let check_one_apply ~errors ~loc ~f_lid ~f_comp ~arg_path ~arg_mty env =\n let f_comp, param_mty =\n get_functor_components ~errors ~loc f_lid env f_comp\n in\n check_functor_appl\n ~errors ~loc ~lid_whole_app:lid0\n ~f0_path ~args:args_for_errors ~f_comp\n ~arg_path ~arg_mty ~param_mty\n env;\n arg_path, f_comp\n in\n let rec check_apply ~path:f_path ~comp:f_comp = function\n | [] -> invalid_arg \"Env.lookup_apply: empty argument list\"\n | [ f_lid, arg_path, arg_mty ] ->\n let arg_path, comps =\n check_one_apply ~errors ~loc ~f_lid ~f_comp\n ~arg_path ~arg_mty env\n in\n f_path, comps, arg_path\n | (f_lid, arg_path, arg_mty) :: args ->\n let arg_path, f_comp =\n check_one_apply ~errors ~loc ~f_lid ~f_comp\n ~arg_path ~arg_mty env\n in\n let comp =\n !components_of_functor_appl' ~loc ~f_path ~f_comp ~arg:arg_path env\n in\n let path = Papply (f_path, arg_path) in\n check_apply ~path ~comp args\n in\n check_apply ~path:f0_path ~comp:f0_comp args0\n\nand lookup_module ~errors ~use ~loc lid env =\n match lid with\n | Lident s ->\n let path, data = lookup_ident_module Load ~errors ~use ~loc s env in\n let md = Subst.Lazy.force_module_decl data.mda_declaration in\n path, md\n | Ldot(l, s) ->\n let path, data = lookup_dot_module ~errors ~use ~loc l s env in\n let md = Subst.Lazy.force_module_decl data.mda_declaration in\n path, md\n | Lapply _ as lid ->\n let path_f, comp_f, path_arg = lookup_apply ~errors ~use ~loc lid env in\n let md = md (modtype_of_functor_appl comp_f path_f path_arg) in\n Papply(path_f, path_arg), md\n\nand lookup_dot_module ~errors ~use ~loc l s env =\n let p, comps = lookup_structure_components ~errors ~use ~loc l env in\n match NameMap.find s comps.comp_modules with\n | mda ->\n let path = Pdot(p, s) in\n use_module ~use ~loc path mda;\n (path, mda)\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_module (Ldot(l, s)))\n\nlet lookup_dot_value ~errors ~use ~loc l s env =\n let (path, comps) =\n lookup_structure_components ~errors ~use ~loc l env\n in\n match NameMap.find s comps.comp_values with\n | vda ->\n let path = Pdot(path, s) in\n use_value ~use ~loc path vda;\n (path, vda.vda_description)\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_value (Ldot(l, s), No_hint))\n\nlet lookup_dot_type ~errors ~use ~loc l s env =\n let (p, comps) = lookup_structure_components ~errors ~use ~loc l env in\n match NameMap.find s comps.comp_types with\n | tda ->\n let path = Pdot(p, s) in\n use_type ~use ~loc path tda;\n (path, tda)\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_type (Ldot(l, s)))\n\nlet lookup_dot_modtype ~errors ~use ~loc l s env =\n let (p, comps) = lookup_structure_components ~errors ~use ~loc l env in\n match NameMap.find s comps.comp_modtypes with\n | mta ->\n let path = Pdot(p, s) in\n use_modtype ~use ~loc path mta.mtda_declaration;\n (path, mta.mtda_declaration)\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_modtype (Ldot(l, s)))\n\nlet lookup_dot_class ~errors ~use ~loc l s env =\n let (p, comps) = lookup_structure_components ~errors ~use ~loc l env in\n match NameMap.find s comps.comp_classes with\n | clda ->\n let path = Pdot(p, s) in\n use_class ~use ~loc path clda;\n (path, clda.clda_declaration)\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_class (Ldot(l, s)))\n\nlet lookup_dot_cltype ~errors ~use ~loc l s env =\n let (p, comps) = lookup_structure_components ~errors ~use ~loc l env in\n match NameMap.find s comps.comp_cltypes with\n | cltda ->\n let path = Pdot(p, s) in\n use_cltype ~use ~loc path cltda.cltda_declaration;\n (path, cltda.cltda_declaration)\n | exception Not_found ->\n may_lookup_error errors loc env (Unbound_cltype (Ldot(l, s)))\n\nlet lookup_all_dot_labels ~errors ~use ~loc usage l s env =\n let (_, comps) = lookup_structure_components ~errors ~use ~loc l env in\n match NameMap.find s comps.comp_labels with\n | [] | exception Not_found ->\n may_lookup_error errors loc env (Unbound_label (Ldot(l, s)))\n | lbls ->\n List.map\n (fun lbl ->\n let use_fun () = use_label ~use ~loc usage env lbl in\n (lbl, use_fun))\n lbls\n\nlet lookup_all_dot_constructors ~errors ~use ~loc usage l s env =\n match l with\n | Longident.Lident \"*predef*\" ->\n (* Hack to support compilation of default arguments *)\n lookup_all_ident_constructors\n ~errors ~use ~loc usage s initial_safe_string\n | _ ->\n let (_, comps) = lookup_structure_components ~errors ~use ~loc l env in\n match NameMap.find s comps.comp_constrs with\n | [] | exception Not_found ->\n may_lookup_error errors loc env (Unbound_constructor (Ldot(l, s)))\n | cstrs ->\n List.map\n (fun cda ->\n let use_fun () = use_constructor ~use ~loc usage env cda in\n (cda.cda_description, use_fun))\n cstrs\n\n(* General forms of the lookup functions *)\n\nlet lookup_module_path ~errors ~use ~loc ~load lid env : Path.t =\n match lid with\n | Lident s ->\n if !Clflags.transparent_modules && not load then\n fst (lookup_ident_module Don't_load ~errors ~use ~loc s env)\n else\n fst (lookup_ident_module Load ~errors ~use ~loc s env)\n | Ldot(l, s) -> fst (lookup_dot_module ~errors ~use ~loc l s env)\n | Lapply _ as lid ->\n let path_f, _comp_f, path_arg = lookup_apply ~errors ~use ~loc lid env in\n Papply(path_f, path_arg)\n\nlet lookup_value ~errors ~use ~loc lid env =\n match lid with\n | Lident s -> lookup_ident_value ~errors ~use ~loc s env\n | Ldot(l, s) -> lookup_dot_value ~errors ~use ~loc l s env\n | Lapply _ -> assert false\n\nlet lookup_type_full ~errors ~use ~loc lid env =\n match lid with\n | Lident s -> lookup_ident_type ~errors ~use ~loc s env\n | Ldot(l, s) -> lookup_dot_type ~errors ~use ~loc l s env\n | Lapply _ -> assert false\n\nlet lookup_type ~errors ~use ~loc lid env =\n let (path, tda) = lookup_type_full ~errors ~use ~loc lid env in\n path, tda.tda_declaration\n\nlet lookup_modtype_lazy ~errors ~use ~loc lid env =\n match lid with\n | Lident s -> lookup_ident_modtype ~errors ~use ~loc s env\n | Ldot(l, s) -> lookup_dot_modtype ~errors ~use ~loc l s env\n | Lapply _ -> assert false\n\nlet lookup_modtype ~errors ~use ~loc lid env =\n let (path, mt) = lookup_modtype_lazy ~errors ~use ~loc lid env in\n path, Subst.Lazy.force_modtype_decl mt\n\nlet lookup_class ~errors ~use ~loc lid env =\n match lid with\n | Lident s -> lookup_ident_class ~errors ~use ~loc s env\n | Ldot(l, s) -> lookup_dot_class ~errors ~use ~loc l s env\n | Lapply _ -> assert false\n\nlet lookup_cltype ~errors ~use ~loc lid env =\n match lid with\n | Lident s -> lookup_ident_cltype ~errors ~use ~loc s env\n | Ldot(l, s) -> lookup_dot_cltype ~errors ~use ~loc l s env\n | Lapply _ -> assert false\n\nlet lookup_all_labels ~errors ~use ~loc usage lid env =\n match lid with\n | Lident s -> lookup_all_ident_labels ~errors ~use ~loc usage s env\n | Ldot(l, s) -> lookup_all_dot_labels ~errors ~use ~loc usage l s env\n | Lapply _ -> assert false\n\nlet lookup_label ~errors ~use ~loc usage lid env =\n match lookup_all_labels ~errors ~use ~loc usage lid env with\n | [] -> assert false\n | (desc, use) :: _ -> use (); desc\n\nlet lookup_all_labels_from_type ~use ~loc usage ty_path env =\n match find_type_descrs ty_path env with\n | exception Not_found -> []\n | Type_variant _ | Type_abstract | Type_open -> []\n | Type_record (lbls, _) ->\n List.map\n (fun lbl ->\n let use_fun () = use_label ~use ~loc usage env lbl in\n (lbl, use_fun))\n lbls\n\nlet lookup_all_constructors ~errors ~use ~loc usage lid env =\n match lid with\n | Lident s -> lookup_all_ident_constructors ~errors ~use ~loc usage s env\n | Ldot(l, s) -> lookup_all_dot_constructors ~errors ~use ~loc usage l s env\n | Lapply _ -> assert false\n\nlet lookup_constructor ~errors ~use ~loc usage lid env =\n match lookup_all_constructors ~errors ~use ~loc usage lid env with\n | [] -> assert false\n | (desc, use) :: _ -> use (); desc\n\nlet lookup_all_constructors_from_type ~use ~loc usage ty_path env =\n match find_type_descrs ty_path env with\n | exception Not_found -> []\n | Type_record _ | Type_abstract | Type_open -> []\n | Type_variant (cstrs, _) ->\n List.map\n (fun cstr ->\n let use_fun () =\n use_constructor_desc ~use ~loc usage env cstr\n in\n (cstr, use_fun))\n cstrs\n\n(* Lookup functions that do not mark the item as used or\n warn if it has alerts, and raise [Not_found] rather\n than report errors *)\n\nlet find_module_by_name lid env =\n let loc = Location.(in_file !input_name) in\n lookup_module ~errors:false ~use:false ~loc lid env\n\nlet find_value_by_name lid env =\n let loc = Location.(in_file !input_name) in\n lookup_value ~errors:false ~use:false ~loc lid env\n\nlet find_type_by_name lid env =\n let loc = Location.(in_file !input_name) in\n lookup_type ~errors:false ~use:false ~loc lid env\n\nlet find_modtype_by_name lid env =\n let loc = Location.(in_file !input_name) in\n lookup_modtype ~errors:false ~use:false ~loc lid env\n\nlet find_class_by_name lid env =\n let loc = Location.(in_file !input_name) in\n lookup_class ~errors:false ~use:false ~loc lid env\n\nlet find_cltype_by_name lid env =\n let loc = Location.(in_file !input_name) in\n lookup_cltype ~errors:false ~use:false ~loc lid env\n\nlet find_constructor_by_name lid env =\n let loc = Location.(in_file !input_name) in\n lookup_constructor ~errors:false ~use:false ~loc Positive lid env\n\nlet find_label_by_name lid env =\n let loc = Location.(in_file !input_name) in\n lookup_label ~errors:false ~use:false ~loc Projection lid env\n\n(* Ordinary lookup functions *)\n\nlet lookup_module_path ?(use=true) ~loc ~load lid env =\n lookup_module_path ~errors:true ~use ~loc ~load lid env\n\nlet lookup_module ?(use=true) ~loc lid env =\n lookup_module ~errors:true ~use ~loc lid env\n\nlet lookup_value ?(use=true) ~loc lid env =\n check_value_name (Longident.last lid) loc;\n lookup_value ~errors:true ~use ~loc lid env\n\nlet lookup_type ?(use=true) ~loc lid env =\n lookup_type ~errors:true ~use ~loc lid env\n\nlet lookup_modtype ?(use=true) ~loc lid env =\n lookup_modtype ~errors:true ~use ~loc lid env\n\nlet lookup_modtype_path ?(use=true) ~loc lid env =\n fst (lookup_modtype_lazy ~errors:true ~use ~loc lid env)\n\nlet lookup_class ?(use=true) ~loc lid env =\n lookup_class ~errors:true ~use ~loc lid env\n\nlet lookup_cltype ?(use=true) ~loc lid env =\n lookup_cltype ~errors:true ~use ~loc lid env\n\nlet lookup_all_constructors ?(use=true) ~loc usage lid env =\n match lookup_all_constructors ~errors:true ~use ~loc usage lid env with\n | exception Error(Lookup_error(loc', env', err)) ->\n (Error(loc', env', err) : _ result)\n | cstrs -> Ok cstrs\n\nlet lookup_constructor ?(use=true) ~loc lid env =\n lookup_constructor ~errors:true ~use ~loc lid env\n\nlet lookup_all_constructors_from_type ?(use=true) ~loc usage ty_path env =\n lookup_all_constructors_from_type ~use ~loc usage ty_path env\n\nlet lookup_all_labels ?(use=true) ~loc usage lid env =\n match lookup_all_labels ~errors:true ~use ~loc usage lid env with\n | exception Error(Lookup_error(loc', env', err)) ->\n (Error(loc', env', err) : _ result)\n | lbls -> Ok lbls\n\nlet lookup_label ?(use=true) ~loc lid env =\n lookup_label ~errors:true ~use ~loc lid env\n\nlet lookup_all_labels_from_type ?(use=true) ~loc usage ty_path env =\n lookup_all_labels_from_type ~use ~loc usage ty_path env\n\nlet lookup_instance_variable ?(use=true) ~loc name env =\n match IdTbl.find_name wrap_value ~mark:use name env.values with\n | (path, Val_bound vda) -> begin\n let desc = vda.vda_description in\n match desc.val_kind with\n | Val_ivar(mut, cl_num) ->\n use_value ~use ~loc path vda;\n path, mut, cl_num, desc.val_type\n | _ ->\n lookup_error loc env (Not_an_instance_variable name)\n end\n | (_, Val_unbound Val_unbound_instance_variable) ->\n lookup_error loc env (Masked_instance_variable (Lident name))\n | (_, Val_unbound Val_unbound_self) ->\n lookup_error loc env (Not_an_instance_variable name)\n | (_, Val_unbound Val_unbound_ancestor) ->\n lookup_error loc env (Not_an_instance_variable name)\n | (_, Val_unbound Val_unbound_ghost_recursive _) ->\n lookup_error loc env (Unbound_instance_variable name)\n | exception Not_found ->\n lookup_error loc env (Unbound_instance_variable name)\n\n(* Checking if a name is bound *)\n\nlet bound_module name env =\n match IdTbl.find_name wrap_module ~mark:false name env.modules with\n | _ -> true\n | exception Not_found ->\n if Current_unit_name.is name then false\n else begin\n match find_pers_mod name with\n | _ -> true\n | exception Not_found -> false\n end\n\nlet bound wrap proj name env =\n match IdTbl.find_name wrap ~mark:false name (proj env) with\n | _ -> true\n | exception Not_found -> false\n\nlet bound_value name env =\n bound wrap_value (fun env -> env.values) name env\n\nlet bound_type name env =\n bound wrap_identity (fun env -> env.types) name env\n\nlet bound_modtype name env =\n bound wrap_identity (fun env -> env.modtypes) name env\n\nlet bound_class name env =\n bound wrap_identity (fun env -> env.classes) name env\n\nlet bound_cltype name env =\n bound wrap_identity (fun env -> env.cltypes) name env\n\n(* Folding on environments *)\n\nlet find_all wrap proj1 proj2 f lid env acc =\n match lid with\n | None ->\n IdTbl.fold_name wrap\n (fun name (p, data) acc -> f name p data acc)\n (proj1 env) acc\n | Some l ->\n let p, desc =\n lookup_module_components\n ~errors:false ~use:false ~loc:Location.none l env\n in\n begin match get_components desc with\n | Structure_comps c ->\n NameMap.fold\n (fun s data acc -> f s (Pdot (p, s)) (wrap data) acc)\n (proj2 c) acc\n | Functor_comps _ ->\n acc\n end\n\nlet find_all_simple_list proj1 proj2 f lid env acc =\n match lid with\n | None ->\n TycompTbl.fold_name\n (fun data acc -> f data acc)\n (proj1 env) acc\n | Some l ->\n let (_p, desc) =\n lookup_module_components\n ~errors:false ~use:false ~loc:Location.none l env\n in\n begin match get_components desc with\n | Structure_comps c ->\n NameMap.fold\n (fun _s comps acc ->\n match comps with\n | [] -> acc\n | data :: _ -> f data acc)\n (proj2 c) acc\n | Functor_comps _ ->\n acc\n end\n\nlet fold_modules f lid env acc =\n match lid with\n | None ->\n IdTbl.fold_name wrap_module\n (fun name (p, entry) acc ->\n match entry with\n | Mod_unbound _ -> acc\n | Mod_local mda ->\n let md =\n Subst.Lazy.force_module_decl mda.mda_declaration\n in\n f name p md acc\n | Mod_persistent ->\n match Persistent_env.find_in_cache !persistent_env name with\n | None -> acc\n | Some mda ->\n let md =\n Subst.Lazy.force_module_decl mda.mda_declaration\n in\n f name p md acc)\n env.modules\n acc\n | Some l ->\n let p, desc =\n lookup_module_components\n ~errors:false ~use:false ~loc:Location.none l env\n in\n begin match get_components desc with\n | Structure_comps c ->\n NameMap.fold\n (fun s mda acc ->\n let md =\n Subst.Lazy.force_module_decl mda.mda_declaration\n in\n f s (Pdot (p, s)) md acc)\n c.comp_modules\n acc\n | Functor_comps _ ->\n acc\n end\n\nlet fold_values f =\n find_all wrap_value (fun env -> env.values) (fun sc -> sc.comp_values)\n (fun k p ve acc ->\n match ve with\n | Val_unbound _ -> acc\n | Val_bound vda -> f k p vda.vda_description acc)\nand fold_constructors f =\n find_all_simple_list (fun env -> env.constrs) (fun sc -> sc.comp_constrs)\n (fun cda acc -> f cda.cda_description acc)\nand fold_labels f =\n find_all_simple_list (fun env -> env.labels) (fun sc -> sc.comp_labels) f\nand fold_types f =\n find_all wrap_identity\n (fun env -> env.types) (fun sc -> sc.comp_types)\n (fun k p tda acc -> f k p tda.tda_declaration acc)\nand fold_modtypes f =\n let f l path data acc = f l path (Subst.Lazy.force_modtype_decl data) acc in\n find_all wrap_identity\n (fun env -> env.modtypes) (fun sc -> sc.comp_modtypes)\n (fun k p mta acc -> f k p mta.mtda_declaration acc)\nand fold_classes f =\n find_all wrap_identity (fun env -> env.classes) (fun sc -> sc.comp_classes)\n (fun k p clda acc -> f k p clda.clda_declaration acc)\nand fold_cltypes f =\n find_all wrap_identity\n (fun env -> env.cltypes) (fun sc -> sc.comp_cltypes)\n (fun k p cltda acc -> f k p cltda.cltda_declaration acc)\n\nlet filter_non_loaded_persistent f env =\n let to_remove =\n IdTbl.fold_name wrap_module\n (fun name (_, entry) acc ->\n match entry with\n | Mod_local _ -> acc\n | Mod_unbound _ -> acc\n | Mod_persistent ->\n match Persistent_env.find_in_cache !persistent_env name with\n | Some _ -> acc\n | None ->\n if f (Ident.create_persistent name) then\n acc\n else\n String.Set.add name acc)\n env.modules\n String.Set.empty\n in\n let remove_ids tbl ids =\n String.Set.fold\n (fun name tbl -> IdTbl.remove (Ident.create_persistent name) tbl)\n ids\n tbl\n in\n let rec filter_summary summary ids =\n if String.Set.is_empty ids then\n summary\n else\n match summary with\n Env_persistent (s, id) when String.Set.mem (Ident.name id) ids ->\n filter_summary s (String.Set.remove (Ident.name id) ids)\n | Env_empty\n | Env_value _\n | Env_type _\n | Env_extension _\n | Env_module _\n | Env_modtype _\n | Env_class _\n | Env_cltype _\n | Env_open _\n | Env_functor_arg _\n | Env_constraints _\n | Env_copy_types _\n | Env_persistent _\n | Env_value_unbound _\n | Env_module_unbound _ ->\n map_summary (fun s -> filter_summary s ids) summary\n in\n { env with\n modules = remove_ids env.modules to_remove;\n summary = filter_summary env.summary to_remove;\n }\n\n(* Return the environment summary *)\n\nlet summary env =\n if Path.Map.is_empty env.local_constraints then env.summary\n else Env_constraints (env.summary, env.local_constraints)\n\nlet last_env = s_ref empty\nlet last_reduced_env = s_ref empty\n\nlet keep_only_summary env =\n if !last_env == env then !last_reduced_env\n else begin\n let new_env =\n {\n empty with\n summary = env.summary;\n local_constraints = env.local_constraints;\n flags = env.flags;\n }\n in\n last_env := env;\n last_reduced_env := new_env;\n new_env\n end\n\n\nlet env_of_only_summary env_from_summary env =\n let new_env = env_from_summary env.summary Subst.identity in\n { new_env with\n local_constraints = env.local_constraints;\n flags = env.flags;\n }\n\n(* Error report *)\n\nopen Format\n\n(* Forward declarations *)\n\nlet print_longident =\n ref ((fun _ _ -> assert false) : formatter -> Longident.t -> unit)\n\nlet print_path =\n ref ((fun _ _ -> assert false) : formatter -> Path.t -> unit)\n\nlet spellcheck ppf extract env lid =\n let choices ~path name = Misc.spellcheck (extract path env) name in\n match lid with\n | Longident.Lapply _ -> ()\n | Longident.Lident s ->\n Misc.did_you_mean ppf (fun () -> choices ~path:None s)\n | Longident.Ldot (r, s) ->\n Misc.did_you_mean ppf (fun () -> choices ~path:(Some r) s)\n\nlet spellcheck_name ppf extract env name =\n Misc.did_you_mean ppf\n (fun () -> Misc.spellcheck (extract env) name)\n\nlet extract_values path env =\n fold_values (fun name _ _ acc -> name :: acc) path env []\nlet extract_types path env =\n fold_types (fun name _ _ acc -> name :: acc) path env []\nlet extract_modules path env =\n fold_modules (fun name _ _ acc -> name :: acc) path env []\nlet extract_constructors path env =\n fold_constructors (fun desc acc -> desc.cstr_name :: acc) path env []\nlet extract_labels path env =\n fold_labels (fun desc acc -> desc.lbl_name :: acc) path env []\nlet extract_classes path env =\n fold_classes (fun name _ _ acc -> name :: acc) path env []\nlet extract_modtypes path env =\n fold_modtypes (fun name _ _ acc -> name :: acc) path env []\nlet extract_cltypes path env =\n fold_cltypes (fun name _ _ acc -> name :: acc) path env []\nlet extract_instance_variables env =\n fold_values\n (fun name _ descr acc ->\n match descr.val_kind with\n | Val_ivar _ -> name :: acc\n | _ -> acc) None env []\n\nlet report_lookup_error _loc env ppf = function\n | Unbound_value(lid, hint) -> begin\n fprintf ppf \"Unbound value %a\" !print_longident lid;\n spellcheck ppf extract_values env lid;\n match hint with\n | No_hint -> ()\n | Missing_rec def_loc ->\n let (_, line, _) =\n Location.get_pos_info def_loc.Location.loc_start\n in\n fprintf ppf\n \"@.@[%s@ %s %i@]\"\n \"Hint: If this is a recursive definition,\"\n \"you should add the 'rec' keyword on line\"\n line\n end\n | Unbound_type lid ->\n fprintf ppf \"Unbound type constructor %a\" !print_longident lid;\n spellcheck ppf extract_types env lid;\n | Unbound_module lid -> begin\n fprintf ppf \"Unbound module %a\" !print_longident lid;\n match find_modtype_by_name lid env with\n | exception Not_found -> spellcheck ppf extract_modules env lid;\n | _ ->\n fprintf ppf\n \"@.@[%s %a, %s@]\"\n \"Hint: There is a module type named\"\n !print_longident lid\n \"but module types are not modules\"\n end\n | Unbound_constructor lid ->\n fprintf ppf \"Unbound constructor %a\" !print_longident lid;\n spellcheck ppf extract_constructors env lid;\n | Unbound_label lid ->\n fprintf ppf \"Unbound record field %a\" !print_longident lid;\n spellcheck ppf extract_labels env lid;\n | Unbound_class lid -> begin\n fprintf ppf \"Unbound class %a\" !print_longident lid;\n match find_cltype_by_name lid env with\n | exception Not_found -> spellcheck ppf extract_classes env lid;\n | _ ->\n fprintf ppf\n \"@.@[%s %a, %s@]\"\n \"Hint: There is a class type named\"\n !print_longident lid\n \"but classes are not class types\"\n end\n | Unbound_modtype lid -> begin\n fprintf ppf \"Unbound module type %a\" !print_longident lid;\n match find_module_by_name lid env with\n | exception Not_found -> spellcheck ppf extract_modtypes env lid;\n | _ ->\n fprintf ppf\n \"@.@[%s %a, %s@]\"\n \"Hint: There is a module named\"\n !print_longident lid\n \"but modules are not module types\"\n end\n | Unbound_cltype lid ->\n fprintf ppf \"Unbound class type %a\" !print_longident lid;\n spellcheck ppf extract_cltypes env lid;\n | Unbound_instance_variable s ->\n fprintf ppf \"Unbound instance variable %s\" s;\n spellcheck_name ppf extract_instance_variables env s;\n | Not_an_instance_variable s ->\n fprintf ppf \"The value %s is not an instance variable\" s;\n spellcheck_name ppf extract_instance_variables env s;\n | Masked_instance_variable lid ->\n fprintf ppf\n \"The instance variable %a@ \\\n cannot be accessed from the definition of another instance variable\"\n !print_longident lid\n | Masked_self_variable lid ->\n fprintf ppf\n \"The self variable %a@ \\\n cannot be accessed from the definition of an instance variable\"\n !print_longident lid\n | Masked_ancestor_variable lid ->\n fprintf ppf\n \"The ancestor variable %a@ \\\n cannot be accessed from the definition of an instance variable\"\n !print_longident lid\n | Illegal_reference_to_recursive_module ->\n fprintf ppf \"Illegal recursive module reference\"\n | Structure_used_as_functor lid ->\n fprintf ppf \"@[The module %a is a structure, it cannot be applied@]\"\n !print_longident lid\n | Abstract_used_as_functor lid ->\n fprintf ppf \"@[The module %a is abstract, it cannot be applied@]\"\n !print_longident lid\n | Functor_used_as_structure lid ->\n fprintf ppf \"@[The module %a is a functor, \\\n it cannot have any components@]\" !print_longident lid\n | Abstract_used_as_structure lid ->\n fprintf ppf \"@[The module %a is abstract, \\\n it cannot have any components@]\" !print_longident lid\n | Generative_used_as_applicative lid ->\n fprintf ppf \"@[The functor %a is generative,@ it@ cannot@ be@ \\\n applied@ in@ type@ expressions@]\" !print_longident lid\n | Cannot_scrape_alias(lid, p) ->\n let cause =\n if Current_unit_name.is_path p then \"is the current compilation unit\"\n else \"is missing\"\n in\n fprintf ppf\n \"The module %a is an alias for module %a, which %s\"\n !print_longident lid !print_path p cause\n\nlet report_error ppf = function\n | Missing_module(_, path1, path2) ->\n fprintf ppf \"@[@[\";\n if Path.same path1 path2 then\n fprintf ppf \"Internal path@ %s@ is dangling.\" (Path.name path1)\n else\n fprintf ppf \"Internal path@ %s@ expands to@ %s@ which is dangling.\"\n (Path.name path1) (Path.name path2);\n fprintf ppf \"@]@ @[%s@ %s@ %s.@]@]\"\n \"The compiled interface for module\" (Ident.name (Path.head path2))\n \"was not found\"\n | Illegal_value_name(_loc, name) ->\n fprintf ppf \"'%s' is not a valid value identifier.\"\n name\n | Lookup_error(loc, t, err) -> report_lookup_error loc t ppf err\n\nlet () =\n Location.register_error_of_exn\n (function\n | Error err ->\n let loc =\n match err with\n | Missing_module (loc, _, _)\n | Illegal_value_name (loc, _)\n | Lookup_error(loc, _, _) -> loc\n in\n let error_of_printer =\n if loc = Location.none\n then Location.error_of_printer_file\n else Location.error_of_printer ~loc ?sub:None\n in\n Some (error_of_printer report_error err)\n | _ ->\n None\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\nopen Misc\nopen Longident\nopen Path\nopen Asttypes\nopen Parsetree\nopen Types\nopen Format\n\nlet () = Includemod_errorprinter.register ()\n\nmodule Sig_component_kind = Shape.Sig_component_kind\nmodule String = Misc.Stdlib.String\n\ntype hiding_error =\n | Illegal_shadowing of {\n shadowed_item_id: Ident.t;\n shadowed_item_kind: Sig_component_kind.t;\n shadowed_item_loc: Location.t;\n shadower_id: Ident.t;\n user_id: Ident.t;\n user_kind: Sig_component_kind.t;\n user_loc: Location.t;\n }\n | Appears_in_signature of {\n opened_item_id: Ident.t;\n opened_item_kind: Sig_component_kind.t;\n user_id: Ident.t;\n user_kind: Sig_component_kind.t;\n user_loc: Location.t;\n }\n\ntype error =\n Cannot_apply of module_type\n | Not_included of Includemod.explanation\n | Cannot_eliminate_dependency of module_type\n | Signature_expected\n | Structure_expected of module_type\n | With_no_component of Longident.t\n | With_mismatch of Longident.t * Includemod.explanation\n | With_makes_applicative_functor_ill_typed of\n Longident.t * Path.t * Includemod.explanation\n | With_changes_module_alias of Longident.t * Ident.t * Path.t\n | With_cannot_remove_constrained_type\n | Repeated_name of Sig_component_kind.t * string\n | Non_generalizable of type_expr\n | Non_generalizable_module of module_type\n | Implementation_is_required of string\n | Interface_not_compiled of string\n | Not_allowed_in_functor_body\n | Not_a_packed_module of type_expr\n | Incomplete_packed_module of type_expr\n | Scoping_pack of Longident.t * type_expr\n | Recursive_module_require_explicit_type\n | Apply_generative\n | Cannot_scrape_alias of Path.t\n | Cannot_scrape_package_type of Path.t\n | Badly_formed_signature of string * Typedecl.error\n | Cannot_hide_id of hiding_error\n | Invalid_type_subst_rhs\n | Unpackable_local_modtype_subst of Path.t\n | With_cannot_remove_packed_modtype of Path.t * module_type\n\nexception Error of Location.t * Env.t * error\nexception Error_forward of Location.error\n\nopen Typedtree\n\nlet rec path_concat head p =\n match p with\n Pident tail -> Pdot (Pident head, Ident.name tail)\n | Pdot (pre, s) -> Pdot (path_concat head pre, s)\n | Papply _ -> assert false\n\n(* Extract a signature from a module type *)\n\nlet extract_sig env loc mty =\n match Env.scrape_alias env mty with\n Mty_signature sg -> sg\n | Mty_alias path ->\n raise(Error(loc, env, Cannot_scrape_alias path))\n | _ -> raise(Error(loc, env, Signature_expected))\n\nlet extract_sig_open env loc mty =\n match Env.scrape_alias env mty with\n Mty_signature sg -> sg\n | Mty_alias path ->\n raise(Error(loc, env, Cannot_scrape_alias path))\n | mty -> raise(Error(loc, env, Structure_expected mty))\n\n(* Compute the environment after opening a module *)\n\nlet type_open_ ?used_slot ?toplevel ovf env loc lid =\n let path = Env.lookup_module_path ~load:true ~loc:lid.loc lid.txt env in\n match Env.open_signature ~loc ?used_slot ?toplevel ovf path env with\n | Ok env -> path, env\n | Error _ ->\n let md = Env.find_module path env in\n ignore (extract_sig_open env lid.loc md.md_type);\n assert false\n\nlet initial_env ~loc ~safe_string ~initially_opened_module\n ~open_implicit_modules =\n let env =\n if safe_string then\n Env.initial_safe_string\n else\n Env.initial_unsafe_string\n in\n let open_module env m =\n let open Asttypes in\n let lexbuf = Lexing.from_string m in\n let txt =\n Location.init lexbuf (Printf.sprintf \"command line argument: -open %S\" m);\n Parse.simple_module_path lexbuf in\n snd (type_open_ Override env loc {txt;loc})\n in\n let add_units env units =\n String.Set.fold\n (fun name env ->\n Env.add_persistent_structure (Ident.create_persistent name) env)\n units\n env\n in\n let units =\n List.map Env.persistent_structures_of_dir (Load_path.get ())\n in\n let env, units =\n match initially_opened_module with\n | None -> (env, units)\n | Some m ->\n (* Locate the directory that contains [m], adds the units it\n contains to the environment and open [m] in the resulting\n environment. *)\n let rec loop before after =\n match after with\n | [] -> None\n | units :: after ->\n if String.Set.mem m units then\n Some (units, List.rev_append before after)\n else\n loop (units :: before) after\n in\n let env, units =\n match loop [] units with\n | None ->\n (env, units)\n | Some (units_containing_m, other_units) ->\n (add_units env units_containing_m, other_units)\n in\n (open_module env m, units)\n in\n let env = List.fold_left add_units env units in\n List.fold_left open_module env open_implicit_modules\n\nlet type_open_descr ?used_slot ?toplevel env sod =\n let (path, newenv) =\n Builtin_attributes.warning_scope sod.popen_attributes\n (fun () ->\n type_open_ ?used_slot ?toplevel sod.popen_override env sod.popen_loc\n sod.popen_expr\n )\n in\n let od =\n {\n open_expr = (path, sod.popen_expr);\n open_bound_items = [];\n open_override = sod.popen_override;\n open_env = newenv;\n open_attributes = sod.popen_attributes;\n open_loc = sod.popen_loc;\n }\n in\n (od, newenv)\n\n(* Forward declaration, to be filled in by type_module_type_of *)\nlet type_module_type_of_fwd :\n (Env.t -> Parsetree.module_expr ->\n Typedtree.module_expr * Types.module_type) ref\n = ref (fun _env _m -> assert false)\n\n(* Additional validity checks on type definitions arising from\n recursive modules *)\n\nlet check_recmod_typedecls env decls =\n let recmod_ids = List.map fst decls in\n List.iter\n (fun (id, md) ->\n List.iter\n (fun path ->\n Typedecl.check_recmod_typedecl env md.Types.md_loc recmod_ids\n path (Env.find_type path env))\n (Mtype.type_paths env (Pident id) md.Types.md_type))\n decls\n\n(* Merge one \"with\" constraint in a signature *)\n\nlet check_type_decl env sg loc id row_id newdecl decl =\n let fresh_id = Ident.rename id in\n let path = Pident fresh_id in\n let sub = Subst.add_type id path Subst.identity in\n let fresh_row_id, sub =\n match row_id with\n | None -> None, sub\n | Some id ->\n let fresh_row_id = Some (Ident.rename id) in\n let sub = Subst.add_type id (Pident fresh_id) sub in\n fresh_row_id, sub\n in\n let newdecl = Subst.type_declaration sub newdecl in\n let decl = Subst.type_declaration sub decl in\n let sg = List.map (Subst.signature_item Keep sub) sg in\n let env = Env.add_type ~check:false fresh_id newdecl env in\n let env =\n match fresh_row_id with\n | None -> env\n | Some fresh_row_id -> Env.add_type ~check:false fresh_row_id newdecl env\n in\n let env = Env.add_signature sg env in\n Includemod.type_declarations ~mark:Mark_both ~loc env fresh_id newdecl decl;\n Typedecl.check_coherence env loc path newdecl\n\nlet make_variance p n i =\n let open Variance in\n set May_pos p (set May_neg n (set May_weak n (set Inj i null)))\n\nlet rec iter_path_apply p ~f =\n match p with\n | Pident _ -> ()\n | Pdot (p, _) -> iter_path_apply p ~f\n | Papply (p1, p2) ->\n iter_path_apply p1 ~f;\n iter_path_apply p2 ~f;\n f p1 p2 (* after recursing, so we know both paths are well typed *)\n\nlet path_is_strict_prefix =\n let rec list_is_strict_prefix l ~prefix =\n match l, prefix with\n | [], [] -> false\n | _ :: _, [] -> true\n | [], _ :: _ -> false\n | s1 :: t1, s2 :: t2 ->\n String.equal s1 s2 && list_is_strict_prefix t1 ~prefix:t2\n in\n fun path ~prefix ->\n match Path.flatten path, Path.flatten prefix with\n | `Contains_apply, _ | _, `Contains_apply -> false\n | `Ok (ident1, l1), `Ok (ident2, l2) ->\n Ident.same ident1 ident2\n && list_is_strict_prefix l1 ~prefix:l2\n\nlet iterator_with_env env =\n let env = ref (lazy env) in\n let super = Btype.type_iterators in\n env, { super with\n Btype.it_signature = (fun self sg ->\n (* add all items to the env before recursing down, to handle recursive\n definitions *)\n let env_before = !env in\n env := lazy (Env.add_signature sg (Lazy.force env_before));\n super.Btype.it_signature self sg;\n env := env_before\n );\n Btype.it_module_type = (fun self -> function\n | Mty_functor (param, mty_body) ->\n let env_before = !env in\n begin match param with\n | Unit -> ()\n | Named (param, mty_arg) ->\n self.Btype.it_module_type self mty_arg;\n match param with\n | None -> ()\n | Some id ->\n env := lazy (Env.add_module ~arg:true id Mp_present\n mty_arg (Lazy.force env_before))\n end;\n self.Btype.it_module_type self mty_body;\n env := env_before;\n | mty ->\n super.Btype.it_module_type self mty\n )\n }\n\nlet retype_applicative_functor_type ~loc env funct arg =\n let mty_functor = (Env.find_module funct env).md_type in\n let mty_arg = (Env.find_module arg env).md_type in\n let mty_param =\n match Env.scrape_alias env mty_functor with\n | Mty_functor (Named (_, mty_param), _) -> mty_param\n | _ -> assert false (* could trigger due to MPR#7611 *)\n in\n Includemod.check_modtype_inclusion ~loc env mty_arg arg mty_param\n\n(* When doing a deep destructive substitution with type M.N.t := .., we change M\n and M.N and so we have to check that uses of the modules other than just\n extracting components from them still make sense. There are only two such\n kinds of uses:\n - applicative functor types: F(M).t might not be well typed anymore\n - aliases: module A = M still makes sense but it doesn't mean the same thing\n anymore, so it's forbidden until it's clear what we should do with it.\n This function would be called with M.N.t and N.t to check for these uses. *)\nlet check_usage_of_path_of_substituted_item paths ~loc ~lid env super =\n { super with\n Btype.it_signature_item = (fun self -> function\n | Sig_module (id, _, { md_type = Mty_alias aliased_path; _ }, _, _)\n when List.exists\n (fun path -> path_is_strict_prefix path ~prefix:aliased_path)\n paths\n ->\n let e = With_changes_module_alias (lid.txt, id, aliased_path) in\n raise(Error(loc, Lazy.force !env, e))\n | sig_item ->\n super.Btype.it_signature_item self sig_item\n );\n Btype.it_path = (fun referenced_path ->\n iter_path_apply referenced_path ~f:(fun funct arg ->\n if List.exists\n (fun path -> path_is_strict_prefix path ~prefix:arg)\n paths\n then\n let env = Lazy.force !env in\n match retype_applicative_functor_type ~loc env funct arg with\n | None -> ()\n | Some explanation ->\n raise(Error(loc, env,\n With_makes_applicative_functor_ill_typed\n (lid.txt, referenced_path, explanation)))\n )\n );\n }\n\n(* When doing a module type destructive substitution [with module type T = RHS]\n where RHS is not a module type path, we need to check that the module type\n T was not used as a path for a packed module\n*)\nlet check_usage_of_module_types ~error ~paths ~loc env super =\n let it_do_type_expr it ty = match get_desc ty with\n | Tpackage (p, _) ->\n begin match List.find_opt (Path.same p) paths with\n | Some p -> raise (Error(loc,Lazy.force !env,error p))\n | _ -> super.Btype.it_do_type_expr it ty\n end\n | _ -> super.Btype.it_do_type_expr it ty in\n { super with Btype.it_do_type_expr }\n\nlet do_check_after_substitution env ~loc ~lid paths unpackable_modtype sg =\n let env, iterator = iterator_with_env env in\n let last, rest = match List.rev paths with\n | [] -> assert false\n | last :: rest -> last, rest\n in\n (* The last item is the one that's removed. We don't need to check how\n it's used since it's replaced by a more specific type/module. *)\n assert (match last with Pident _ -> true | _ -> false);\n let iterator = match rest with\n | [] -> iterator\n | _ :: _ ->\n check_usage_of_path_of_substituted_item rest ~loc ~lid env iterator\n in\n let iterator = match unpackable_modtype with\n | None -> iterator\n | Some mty ->\n let error p = With_cannot_remove_packed_modtype(p,mty) in\n check_usage_of_module_types ~error ~paths ~loc env iterator\n in\n iterator.Btype.it_signature iterator sg;\n Btype.(unmark_iterators.it_signature unmark_iterators) sg\n\nlet check_usage_after_substitution env ~loc ~lid paths unpackable_modtype sg =\n match paths, unpackable_modtype with\n | [_], None -> ()\n | _ -> do_check_after_substitution env ~loc ~lid paths unpackable_modtype sg\n\n(* After substitution one also needs to re-check the well-foundedness\n of type declarations in recursive modules *)\nlet rec extract_next_modules = function\n | Sig_module (id, _, mty, Trec_next, _) :: rem ->\n let (id_mty_l, rem) = extract_next_modules rem in\n ((id, mty) :: id_mty_l, rem)\n | sg -> ([], sg)\n\nlet check_well_formed_module env loc context mty =\n (* Format.eprintf \"@[check_well_formed_module@ %a@]@.\"\n Printtyp.modtype mty; *)\n let open Btype in\n let iterator =\n let rec check_signature env = function\n | [] -> ()\n | Sig_module (id, _, mty, Trec_first, _) :: rem ->\n let (id_mty_l, rem) = extract_next_modules rem in\n begin try\n check_recmod_typedecls (Lazy.force env) ((id, mty) :: id_mty_l)\n with Typedecl.Error (_, err) ->\n raise (Error (loc, Lazy.force env,\n Badly_formed_signature(context, err)))\n end;\n check_signature env rem\n | _ :: rem ->\n check_signature env rem\n in\n let env, super = iterator_with_env env in\n { super with\n it_type_expr = (fun _self _ty -> ());\n it_signature = (fun self sg ->\n let env_before = !env in\n let env = lazy (Env.add_signature sg (Lazy.force env_before)) in\n check_signature env sg;\n super.it_signature self sg);\n }\n in\n iterator.it_module_type iterator mty\n\nlet () = Env.check_well_formed_module := check_well_formed_module\n\nlet type_decl_is_alias sdecl = (* assuming no explicit constraint *)\n match sdecl.ptype_manifest with\n | Some {ptyp_desc = Ptyp_constr (lid, stl)}\n when List.length stl = List.length sdecl.ptype_params ->\n begin\n match\n List.iter2 (fun x (y, _) ->\n match x, y with\n {ptyp_desc=Ptyp_var sx}, {ptyp_desc=Ptyp_var sy}\n when sx = sy -> ()\n | _, _ -> raise Exit)\n stl sdecl.ptype_params;\n with\n | exception Exit -> None\n | () -> Some lid\n end\n | _ -> None\n;;\n\nlet params_are_constrained =\n let rec loop = function\n | [] -> false\n | hd :: tl ->\n match get_desc hd with\n | Tvar _ -> List.memq hd tl || loop tl\n | _ -> true\n in\n loop\n;;\n\ntype with_info =\n | With_type of Parsetree.type_declaration\n | With_typesubst of Parsetree.type_declaration\n | With_module of {\n lid:Longident.t loc;\n path:Path.t;\n md:Types.module_declaration;\n remove_aliases:bool\n }\n | With_modsubst of Longident.t loc * Path.t * Types.module_declaration\n | With_modtype of Typedtree.module_type\n | With_modtypesubst of Typedtree.module_type\n\nlet merge_constraint initial_env loc sg lid constr =\n let destructive_substitution =\n match constr with\n | With_type _ | With_module _ | With_modtype _ -> false\n | With_typesubst _ | With_modsubst _ | With_modtypesubst _ -> true\n in\n let real_ids = ref [] in\n let unpackable_modtype = ref None in\n let split_row_id s ghosts =\n let srow = s ^ \"#row\" in\n let rec split before = function\n | Sig_type(id,_,_,_) :: rest when Ident.name id = srow ->\n before, Some id, rest\n | a :: rest -> split (a::before) rest\n | [] -> before, None, []\n in\n split [] ghosts\n in\n let rec patch_item constr namelist outer_sig_env sg_for_env ~ghosts item =\n let return ?(ghosts=ghosts) ~replace_by info =\n Some (info, {Signature_group.ghosts; replace_by})\n in\n match item, namelist, constr with\n | Sig_type(id, decl, rs, priv), [s],\n With_type ({ptype_kind = Ptype_abstract} as sdecl)\n when Ident.name id = s && Typedecl.is_fixed_type sdecl ->\n let decl_row =\n let arity = List.length sdecl.ptype_params in\n {\n type_params =\n List.map (fun _ -> Btype.newgenvar()) sdecl.ptype_params;\n type_arity = arity;\n type_kind = Type_abstract;\n type_private = Private;\n type_manifest = None;\n type_variance =\n List.map\n (fun (_, (v, i)) ->\n let (c, n) =\n match v with\n | Covariant -> true, false\n | Contravariant -> false, true\n | NoVariance -> false, false\n in\n make_variance (not n) (not c) (i = Injective)\n )\n sdecl.ptype_params;\n type_separability =\n Types.Separability.default_signature ~arity;\n type_loc = sdecl.ptype_loc;\n type_is_newtype = false;\n type_expansion_scope = Btype.lowest_level;\n type_attributes = [];\n type_immediate = Unknown;\n type_unboxed_default = false;\n type_uid = Uid.mk ~current_unit:(Env.get_unit_name ());\n }\n and id_row = Ident.create_local (s^\"#row\") in\n let initial_env =\n Env.add_type ~check:false id_row decl_row initial_env\n in\n let sig_env = Env.add_signature sg_for_env outer_sig_env in\n let tdecl =\n Typedecl.transl_with_constraint id ~fixed_row_path:(Pident id_row)\n ~sig_env ~sig_decl:decl ~outer_env:initial_env sdecl in\n let newdecl = tdecl.typ_type in\n let before_ghosts, row_id, after_ghosts = split_row_id s ghosts in\n check_type_decl outer_sig_env sg_for_env sdecl.ptype_loc\n id row_id newdecl decl;\n let decl_row = {decl_row with type_params = newdecl.type_params} in\n let rs' = if rs = Trec_first then Trec_not else rs in\n let ghosts =\n List.rev_append before_ghosts\n (Sig_type(id_row, decl_row, rs', priv)::after_ghosts)\n in\n return ~ghosts\n ~replace_by:(Some (Sig_type(id, newdecl, rs, priv)))\n (Pident id, lid, Twith_type tdecl)\n | Sig_type(id, sig_decl, rs, priv) , [s],\n (With_type sdecl | With_typesubst sdecl as constr)\n when Ident.name id = s ->\n let sig_env = Env.add_signature sg_for_env outer_sig_env in\n let tdecl =\n Typedecl.transl_with_constraint id\n ~sig_env ~sig_decl ~outer_env:initial_env sdecl in\n let newdecl = tdecl.typ_type and loc = sdecl.ptype_loc in\n let before_ghosts, row_id, after_ghosts = split_row_id s ghosts in\n let ghosts = List.rev_append before_ghosts after_ghosts in\n check_type_decl outer_sig_env sg_for_env loc\n id row_id newdecl sig_decl;\n begin match constr with\n With_type _ ->\n return ~ghosts\n ~replace_by:(Some(Sig_type(id, newdecl, rs, priv)))\n (Pident id, lid, Twith_type tdecl)\n | (* With_typesubst *) _ ->\n real_ids := [Pident id];\n return ~ghosts ~replace_by:None\n (Pident id, lid, Twith_typesubst tdecl)\n end\n | Sig_modtype(id, mtd, priv), [s],\n (With_modtype mty | With_modtypesubst mty)\n when Ident.name id = s ->\n let sig_env = Env.add_signature sg_for_env outer_sig_env in\n let () = match mtd.mtd_type with\n | None -> ()\n | Some previous_mty ->\n Includemod.check_modtype_equiv ~loc sig_env\n id previous_mty mty.mty_type\n in\n if not destructive_substitution then\n let mtd': modtype_declaration =\n {\n mtd_uid = Uid.mk ~current_unit:(Env.get_unit_name ());\n mtd_type = Some mty.mty_type;\n mtd_attributes = [];\n mtd_loc = loc;\n }\n in\n return\n ~replace_by:(Some(Sig_modtype(id, mtd', priv)))\n (Pident id, lid, Twith_modtype mty)\n else begin\n let path = Pident id in\n real_ids := [path];\n begin match mty.mty_type with\n | Mty_ident _ -> ()\n | mty -> unpackable_modtype := Some mty\n end;\n return ~replace_by:None (Pident id, lid, Twith_modtypesubst mty)\n end\n | Sig_module(id, pres, md, rs, priv), [s],\n With_module {lid=lid'; md=md'; path; remove_aliases}\n when Ident.name id = s ->\n let sig_env = Env.add_signature sg_for_env outer_sig_env in\n let mty = md'.md_type in\n let mty = Mtype.scrape_for_type_of ~remove_aliases sig_env mty in\n let md'' = { md' with md_type = mty } in\n let newmd = Mtype.strengthen_decl ~aliasable:false sig_env md'' path in\n ignore(Includemod.modtypes ~mark:Mark_both ~loc sig_env\n newmd.md_type md.md_type);\n return\n ~replace_by:(Some(Sig_module(id, pres, newmd, rs, priv)))\n (Pident id, lid, Twith_module (path, lid'))\n | Sig_module(id, _, md, _rs, _), [s], With_modsubst (lid',path,md')\n when Ident.name id = s ->\n let sig_env = Env.add_signature sg_for_env outer_sig_env in\n let aliasable = not (Env.is_functor_arg path sig_env) in\n ignore\n (Includemod.strengthened_module_decl ~loc ~mark:Mark_both\n ~aliasable sig_env md' path md);\n real_ids := [Pident id];\n return ~replace_by:None (Pident id, lid, Twith_modsubst (path, lid'))\n | Sig_module(id, _, md, rs, priv) as item, s :: namelist, constr\n when Ident.name id = s ->\n let sig_env = Env.add_signature sg_for_env outer_sig_env in\n let sg = extract_sig sig_env loc md.md_type in\n let ((path, _, tcstr), newsg) = merge_signature sig_env sg namelist in\n let path = path_concat id path in\n real_ids := path :: !real_ids;\n let item =\n match md.md_type, constr with\n Mty_alias _, (With_module _ | With_type _) ->\n (* A module alias cannot be refined, so keep it\n and just check that the constraint is correct *)\n item\n | _ ->\n let newmd = {md with md_type = Mty_signature newsg} in\n Sig_module(id, Mp_present, newmd, rs, priv)\n in\n return ~replace_by:(Some item) (path, lid, tcstr)\n | _ -> None\n and merge_signature env sg namelist =\n match\n Signature_group.replace_in_place (patch_item constr namelist env sg) sg\n with\n | Some (x,sg) -> x, sg\n | None -> raise(Error(loc, env, With_no_component lid.txt))\n in\n try\n let names = Longident.flatten lid.txt in\n let (tcstr, sg) = merge_signature initial_env sg names in\n if destructive_substitution then\n check_usage_after_substitution ~loc ~lid initial_env !real_ids\n !unpackable_modtype sg;\n let sg =\n match tcstr with\n | (_, _, Twith_typesubst tdecl) ->\n let how_to_extend_subst =\n let sdecl =\n match constr with\n | With_typesubst sdecl -> sdecl\n | _ -> assert false\n in\n match type_decl_is_alias sdecl with\n | Some lid ->\n let replacement, _ =\n try Env.find_type_by_name lid.txt initial_env\n with Not_found -> assert false\n in\n fun s path -> Subst.add_type_path path replacement s\n | None ->\n let body = Option.get tdecl.typ_type.type_manifest in\n let params = tdecl.typ_type.type_params in\n if params_are_constrained params\n then raise(Error(loc, initial_env,\n With_cannot_remove_constrained_type));\n fun s path -> Subst.add_type_function path ~params ~body s\n in\n let sub = Subst.change_locs Subst.identity loc in\n let sub = List.fold_left how_to_extend_subst sub !real_ids in\n (* This signature will not be used directly, it will always be freshened\n by the caller. So what we do with the scope doesn't really matter. But\n making it local makes it unlikely that we will ever use the result of\n this function unfreshened without issue. *)\n Subst.signature Make_local sub sg\n | (_, _, Twith_modsubst (real_path, _)) ->\n let sub = Subst.change_locs Subst.identity loc in\n let sub =\n List.fold_left\n (fun s path -> Subst.add_module_path path real_path s)\n sub\n !real_ids\n in\n (* See explanation in the [Twith_typesubst] case above. *)\n Subst.signature Make_local sub sg\n | (_, _, Twith_modtypesubst tmty) ->\n let add s p = Subst.add_modtype_path p tmty.mty_type s in\n let sub = Subst.change_locs Subst.identity loc in\n let sub = List.fold_left add sub !real_ids in\n Subst.signature Make_local sub sg\n | _ ->\n sg\n in\n check_well_formed_module initial_env loc \"this instantiated signature\"\n (Mty_signature sg);\n (tcstr, sg)\n with Includemod.Error explanation ->\n raise(Error(loc, initial_env, With_mismatch(lid.txt, explanation)))\n\n(* Add recursion flags on declarations arising from a mutually recursive\n block. *)\n\nlet map_rec fn decls rem =\n match decls with\n | [] -> rem\n | d1 :: dl -> fn Trec_first d1 :: map_end (fn Trec_next) dl rem\n\nlet map_rec_type ~rec_flag fn decls rem =\n match decls with\n | [] -> rem\n | d1 :: dl ->\n let first =\n match rec_flag with\n | Recursive -> Trec_first\n | Nonrecursive -> Trec_not\n in\n fn first d1 :: map_end (fn Trec_next) dl rem\n\nlet rec map_rec_type_with_row_types ~rec_flag fn decls rem =\n match decls with\n | [] -> rem\n | d1 :: dl ->\n if Btype.is_row_name (Ident.name d1.typ_id) then\n fn Trec_not d1 :: map_rec_type_with_row_types ~rec_flag fn dl rem\n else\n map_rec_type ~rec_flag fn decls rem\n\n(* Add type extension flags to extension constructors *)\nlet map_ext fn exts rem =\n match exts with\n | [] -> rem\n | d1 :: dl -> fn Text_first d1 :: map_end (fn Text_next) dl rem\n\n(* Auxiliary for translating recursively-defined module types.\n Return a module type that approximates the shape of the given module\n type AST. Retain only module, type, and module type\n components of signatures. For types, retain only their arity,\n making them abstract otherwise. *)\n\nlet rec approx_modtype env smty =\n match smty.pmty_desc with\n Pmty_ident lid ->\n let path =\n Env.lookup_modtype_path ~use:false ~loc:smty.pmty_loc lid.txt env\n in\n Mty_ident path\n | Pmty_alias lid ->\n let path =\n Env.lookup_module_path ~use:false ~load:false\n ~loc:smty.pmty_loc lid.txt env\n in\n Mty_alias(path)\n | Pmty_signature ssg ->\n Mty_signature(approx_sig env ssg)\n | Pmty_functor(param, sres) ->\n let (param, newenv) =\n match param with\n | Unit -> Types.Unit, env\n | Named (param, sarg) ->\n let arg = approx_modtype env sarg in\n match param.txt with\n | None -> Types.Named (None, arg), env\n | Some name ->\n let rarg = Mtype.scrape_for_functor_arg env arg in\n let scope = Ctype.create_scope () in\n let (id, newenv) =\n Env.enter_module ~scope ~arg:true name Mp_present rarg env\n in\n Types.Named (Some id, arg), newenv\n in\n let res = approx_modtype newenv sres in\n Mty_functor(param, res)\n | Pmty_with(sbody, constraints) ->\n let body = approx_modtype env sbody in\n List.iter\n (fun sdecl ->\n match sdecl with\n | Pwith_type _\n | Pwith_typesubst _\n | Pwith_modtype _\n | Pwith_modtypesubst _ -> ()\n | Pwith_module (_, lid') ->\n (* Lookup the module to make sure that it is not recursive.\n (GPR#1626) *)\n ignore (Env.lookup_module_path ~use:false ~load:false\n ~loc:lid'.loc lid'.txt env)\n | Pwith_modsubst (_, lid') ->\n ignore (Env.lookup_module_path ~use:false ~load:false\n ~loc:lid'.loc lid'.txt env))\n constraints;\n body\n | Pmty_typeof smod ->\n let (_, mty) = !type_module_type_of_fwd env smod in\n mty\n | Pmty_extension ext ->\n raise (Error_forward (Builtin_attributes.error_of_extension ext))\n\nand approx_module_declaration env pmd =\n {\n Types.md_type = approx_modtype env pmd.pmd_type;\n md_attributes = pmd.pmd_attributes;\n md_loc = pmd.pmd_loc;\n md_uid = Uid.internal_not_actually_unique;\n }\n\nand approx_sig env ssg =\n match ssg with\n [] -> []\n | item :: srem ->\n match item.psig_desc with\n | Psig_type (rec_flag, sdecls) ->\n let decls = Typedecl.approx_type_decl sdecls in\n let rem = approx_sig env srem in\n map_rec_type ~rec_flag\n (fun rs (id, info) -> Sig_type(id, info, rs, Exported)) decls rem\n | Psig_typesubst _ -> approx_sig env srem\n | Psig_module { pmd_name = { txt = None; _ }; _ } ->\n approx_sig env srem\n | Psig_module pmd ->\n let scope = Ctype.create_scope () in\n let md = approx_module_declaration env pmd in\n let pres =\n match md.Types.md_type with\n | Mty_alias _ -> Mp_absent\n | _ -> Mp_present\n in\n let id, newenv =\n Env.enter_module_declaration ~scope (Option.get pmd.pmd_name.txt)\n pres md env\n in\n Sig_module(id, pres, md, Trec_not, Exported) :: approx_sig newenv srem\n | Psig_modsubst pms ->\n let scope = Ctype.create_scope () in\n let _, md =\n Env.lookup_module ~use:false ~loc:pms.pms_manifest.loc\n pms.pms_manifest.txt env\n in\n let pres =\n match md.Types.md_type with\n | Mty_alias _ -> Mp_absent\n | _ -> Mp_present\n in\n let _, newenv =\n Env.enter_module_declaration ~scope pms.pms_name.txt pres md env\n in\n approx_sig newenv srem\n | Psig_recmodule sdecls ->\n let scope = Ctype.create_scope () in\n let decls =\n List.filter_map\n (fun pmd ->\n Option.map (fun name ->\n Ident.create_scoped ~scope name,\n approx_module_declaration env pmd\n ) pmd.pmd_name.txt\n )\n sdecls\n in\n let newenv =\n List.fold_left\n (fun env (id, md) -> Env.add_module_declaration ~check:false\n id Mp_present md env)\n env decls\n in\n map_rec\n (fun rs (id, md) -> Sig_module(id, Mp_present, md, rs, Exported))\n decls\n (approx_sig newenv srem)\n | Psig_modtype d ->\n let info = approx_modtype_info env d in\n let scope = Ctype.create_scope () in\n let (id, newenv) =\n Env.enter_modtype ~scope d.pmtd_name.txt info env\n in\n Sig_modtype(id, info, Exported) :: approx_sig newenv srem\n | Psig_modtypesubst d ->\n let info = approx_modtype_info env d in\n let scope = Ctype.create_scope () in\n let (_id, newenv) =\n Env.enter_modtype ~scope d.pmtd_name.txt info env\n in\n approx_sig newenv srem\n | Psig_open sod ->\n let _, env = type_open_descr env sod in\n approx_sig env srem\n | Psig_include sincl ->\n let smty = sincl.pincl_mod in\n let mty = approx_modtype env smty in\n let scope = Ctype.create_scope () in\n let sg, newenv = Env.enter_signature ~scope\n (extract_sig env smty.pmty_loc mty) env in\n sg @ approx_sig newenv srem\n | Psig_class sdecls | Psig_class_type sdecls ->\n let decls = Typeclass.approx_class_declarations env sdecls in\n let rem = approx_sig env srem in\n map_rec (fun rs decl ->\n let open Typeclass in [\n Sig_class_type(decl.clsty_ty_id, decl.clsty_ty_decl, rs,\n Exported);\n Sig_type(decl.clsty_obj_id, decl.clsty_obj_abbr, rs, Exported);\n Sig_type(decl.clsty_typesharp_id, decl.clsty_abbr, rs, Exported);\n ]\n ) decls [rem]\n |> List.flatten\n | _ ->\n approx_sig env srem\n\nand approx_modtype_info env sinfo =\n {\n mtd_type = Option.map (approx_modtype env) sinfo.pmtd_type;\n mtd_attributes = sinfo.pmtd_attributes;\n mtd_loc = sinfo.pmtd_loc;\n mtd_uid = Uid.internal_not_actually_unique;\n }\n\nlet approx_modtype env smty =\n Warnings.without_warnings\n (fun () -> approx_modtype env smty)\n\n(* Auxiliaries for checking the validity of name shadowing in signatures and\n structures.\n If a shadowing is valid, we also record some information (its ident,\n location where it first appears, etc) about the item that gets shadowed. *)\nmodule Signature_names : sig\n type t\n\n type shadowable =\n {\n self: Ident.t;\n group: Ident.t list;\n (** group includes the element itself and all elements\n that should be removed at the same time\n *)\n loc:Location.t;\n }\n\n type info = [\n | `Exported\n | `From_open\n | `Shadowable of shadowable\n | `Substituted_away of Subst.t\n | `Unpackable_modtype_substituted_away of Ident.t * Subst.t\n ]\n\n val create : unit -> t\n\n val check_value : ?info:info -> t -> Location.t -> Ident.t -> unit\n val check_type : ?info:info -> t -> Location.t -> Ident.t -> unit\n val check_typext : ?info:info -> t -> Location.t -> Ident.t -> unit\n val check_module : ?info:info -> t -> Location.t -> Ident.t -> unit\n val check_modtype : ?info:info -> t -> Location.t -> Ident.t -> unit\n val check_class : ?info:info -> t -> Location.t -> Ident.t -> unit\n val check_class_type: ?info:info -> t -> Location.t -> Ident.t -> unit\n\n val check_sig_item:\n ?info:info -> t -> Location.t -> Signature_group.rec_group -> unit\n\n val simplify: Env.t -> t -> Types.signature -> Types.signature\nend = struct\n\n type shadowable =\n {\n self: Ident.t;\n group: Ident.t list;\n (** group includes the element itself and all elements\n that should be removed at the same time\n *)\n loc:Location.t;\n }\n\n type bound_info = [\n | `Exported\n | `Shadowable of shadowable\n ]\n\n type info = [\n | `From_open\n | `Substituted_away of Subst.t\n | `Unpackable_modtype_substituted_away of Ident.t * Subst.t\n | bound_info\n ]\n\n type hide_reason =\n | From_open\n | Shadowed_by of Ident.t * Location.t\n\n type to_be_removed = {\n mutable subst: Subst.t;\n mutable hide: (Sig_component_kind.t * Location.t * hide_reason) Ident.Map.t;\n mutable unpackable_modtypes: Ident.Set.t;\n }\n\n type names_infos = (string, bound_info) Hashtbl.t\n\n type names = {\n values: names_infos;\n types: names_infos;\n modules: names_infos;\n modtypes: names_infos;\n typexts: names_infos;\n classes: names_infos;\n class_types: names_infos;\n }\n\n let new_names () = {\n values = Hashtbl.create 16;\n types = Hashtbl.create 16;\n modules = Hashtbl.create 16;\n modtypes = Hashtbl.create 16;\n typexts = Hashtbl.create 16;\n classes = Hashtbl.create 16;\n class_types = Hashtbl.create 16;\n }\n\n type t = {\n bound: names;\n to_be_removed: to_be_removed;\n }\n\n let create () = {\n bound = new_names ();\n to_be_removed = {\n subst = Subst.identity;\n hide = Ident.Map.empty;\n unpackable_modtypes = Ident.Set.empty;\n };\n }\n\n let table_for component names =\n let open Sig_component_kind in\n match component with\n | Value -> names.values\n | Type -> names.types\n | Module -> names.modules\n | Module_type -> names.modtypes\n | Extension_constructor -> names.typexts\n | Class -> names.classes\n | Class_type -> names.class_types\n\n let check cl t loc id (info : info) =\n let to_be_removed = t.to_be_removed in\n match info with\n | `Substituted_away s ->\n to_be_removed.subst <- Subst.compose s to_be_removed.subst;\n | `Unpackable_modtype_substituted_away (id,s) ->\n to_be_removed.subst <- Subst.compose s to_be_removed.subst;\n to_be_removed.unpackable_modtypes <-\n Ident.Set.add id to_be_removed.unpackable_modtypes\n | `From_open ->\n to_be_removed.hide <-\n Ident.Map.add id (cl, loc, From_open) to_be_removed.hide\n | #bound_info as bound_info ->\n let tbl = table_for cl t.bound in\n let name = Ident.name id in\n match Hashtbl.find_opt tbl name with\n | None -> Hashtbl.add tbl name bound_info\n | Some (`Shadowable s) ->\n Hashtbl.replace tbl name bound_info;\n let reason = Shadowed_by (id, loc) in\n List.iter (fun shadowed_id ->\n to_be_removed.hide <-\n Ident.Map.add shadowed_id (cl, s.loc, reason)\n to_be_removed.hide\n ) s.group\n | Some `Exported ->\n raise(Error(loc, Env.empty, Repeated_name(cl, name)))\n\n let check_value ?info t loc id =\n let info =\n match info with\n | Some i -> i\n | None -> `Shadowable {self=id; group=[id]; loc}\n in\n check Sig_component_kind.Value t loc id info\n let check_type ?(info=`Exported) t loc id =\n check Sig_component_kind.Type t loc id info\n let check_module ?(info=`Exported) t loc id =\n check Sig_component_kind.Module t loc id info\n let check_modtype ?(info=`Exported) t loc id =\n check Sig_component_kind.Module_type t loc id info\n let check_typext ?(info=`Exported) t loc id =\n check Sig_component_kind.Extension_constructor t loc id info\n let check_class ?(info=`Exported) t loc id =\n check Sig_component_kind.Class t loc id info\n let check_class_type ?(info=`Exported) t loc id =\n check Sig_component_kind.Class_type t loc id info\n\n let classify =\n let open Sig_component_kind in\n function\n | Sig_type(id, _, _, _) -> Type, id\n | Sig_module(id, _, _, _, _) -> Module, id\n | Sig_modtype(id, _, _) -> Module_type, id\n | Sig_typext(id, _, _, _) -> Extension_constructor, id\n | Sig_value (id, _, _) -> Value, id\n | Sig_class (id, _, _, _) -> Class, id\n | Sig_class_type (id, _, _, _) -> Class_type, id\n\n let check_item ?info names loc kind id ids =\n let info =\n match info with\n | None -> `Shadowable {self=id; group=ids; loc}\n | Some i -> i\n in\n check kind names loc id info\n\n let check_sig_item ?info names loc (item:Signature_group.rec_group) =\n let check ?info names loc item =\n let all = List.map classify (Signature_group.flatten item) in\n let group = List.map snd all in\n List.iter (fun (kind,id) -> check_item ?info names loc kind id group)\n all\n in\n (* we can ignore x.pre_ghosts: they are eliminated by strengthening, and\n thus never appear in includes *)\n List.iter (check ?info names loc) (Signature_group.rec_items item.group)\n\n (*\n Before applying local module type substitutions where the\n right-hand side is not a path, we need to check that those module types\n where never used to pack modules. For instance\n {[\n module type T := sig end\n val x: (module T)\n ]}\n should raise an error.\n *)\n let check_unpackable_modtypes ~loc ~env to_remove component =\n if not (Ident.Set.is_empty to_remove.unpackable_modtypes) then begin\n let iterator =\n let error p = Unpackable_local_modtype_subst p in\n let paths =\n List.map (fun id -> Pident id)\n (Ident.Set.elements to_remove.unpackable_modtypes)\n in\n check_usage_of_module_types ~loc ~error ~paths\n (ref (lazy env)) Btype.type_iterators\n in\n iterator.Btype.it_signature_item iterator component;\n Btype.(unmark_iterators.it_signature_item unmark_iterators) component\n end\n\n (* We usually require name uniqueness of signature components (e.g. types,\n modules, etc), however in some situation reusing the name is allowed: if\n the component is a value or an extension, or if the name is introduced by\n an include.\n When there are multiple specifications of a component with the same name,\n we try to keep only the last (rightmost) one, removing all references to\n the previous ones from the signature.\n If some reference cannot be removed, then we error out with\n [Cannot_hide_id].\n *)\n\n let simplify env t sg =\n let to_remove = t.to_be_removed in\n let ids_to_remove =\n Ident.Map.fold (fun id (kind, _, _) lst ->\n if Sig_component_kind.can_appear_in_types kind then\n id :: lst\n else\n lst\n ) to_remove.hide []\n in\n let simplify_item (component: Types.signature_item) =\n let user_kind, user_id, user_loc =\n let open Sig_component_kind in\n match component with\n | Sig_value(id, v, _) -> Value, id, v.val_loc\n | Sig_type (id, td, _, _) -> Type, id, td.type_loc\n | Sig_typext (id, te, _, _) -> Extension_constructor, id, te.ext_loc\n | Sig_module (id, _, md, _, _) -> Module, id, md.md_loc\n | Sig_modtype (id, mtd, _) -> Module_type, id, mtd.mtd_loc\n | Sig_class (id, c, _, _) -> Class, id, c.cty_loc\n | Sig_class_type (id, ct, _, _) -> Class_type, id, ct.clty_loc\n in\n if Ident.Map.mem user_id to_remove.hide then\n None\n else begin\n let component =\n if to_remove.subst == Subst.identity then\n component\n else\n begin\n check_unpackable_modtypes ~loc:user_loc ~env to_remove component;\n Subst.signature_item Keep to_remove.subst component\n end\n in\n let component =\n match ids_to_remove with\n | [] -> component\n | ids ->\n try Mtype.nondep_sig_item env ids component with\n | Ctype.Nondep_cannot_erase removed_item_id ->\n let (removed_item_kind, removed_item_loc, reason) =\n Ident.Map.find removed_item_id to_remove.hide\n in\n let err_loc, hiding_error =\n match reason with\n | From_open ->\n removed_item_loc,\n Appears_in_signature {\n opened_item_kind = removed_item_kind;\n opened_item_id = removed_item_id;\n user_id;\n user_kind;\n user_loc;\n }\n | Shadowed_by (shadower_id, shadower_loc) ->\n shadower_loc,\n Illegal_shadowing {\n shadowed_item_kind = removed_item_kind;\n shadowed_item_id = removed_item_id;\n shadowed_item_loc = removed_item_loc;\n shadower_id;\n user_id;\n user_kind;\n user_loc;\n }\n in\n raise (Error(err_loc, env, Cannot_hide_id hiding_error))\n in\n Some component\n end\n in\n List.filter_map simplify_item sg\nend\n\nlet has_remove_aliases_attribute attr =\n let remove_aliases =\n Attr_helper.get_no_payload_attribute\n [\"remove_aliases\"; \"ocaml.remove_aliases\"] attr\n in\n match remove_aliases with\n | None -> false\n | Some _ -> true\n\n(* Check and translate a module type expression *)\n\nlet transl_modtype_longident loc env lid =\n Env.lookup_modtype_path ~loc lid env\n\nlet transl_module_alias loc env lid =\n Env.lookup_module_path ~load:false ~loc lid env\n\nlet mkmty desc typ env loc attrs =\n let mty = {\n mty_desc = desc;\n mty_type = typ;\n mty_loc = loc;\n mty_env = env;\n mty_attributes = attrs;\n } in\n Cmt_format.add_saved_type (Cmt_format.Partial_module_type mty);\n mty\n\nlet mksig desc env loc =\n let sg = { sig_desc = desc; sig_loc = loc; sig_env = env } in\n Cmt_format.add_saved_type (Cmt_format.Partial_signature_item sg);\n sg\n\n(* let signature sg = List.map (fun item -> item.sig_type) sg *)\n\nlet rec transl_modtype env smty =\n Builtin_attributes.warning_scope smty.pmty_attributes\n (fun () -> transl_modtype_aux env smty)\n\nand transl_modtype_functor_arg env sarg =\n let mty = transl_modtype env sarg in\n {mty with mty_type = Mtype.scrape_for_functor_arg env mty.mty_type}\n\nand transl_modtype_aux env smty =\n let loc = smty.pmty_loc in\n match smty.pmty_desc with\n Pmty_ident lid ->\n let path = transl_modtype_longident loc env lid.txt in\n mkmty (Tmty_ident (path, lid)) (Mty_ident path) env loc\n smty.pmty_attributes\n | Pmty_alias lid ->\n let path = transl_module_alias loc env lid.txt in\n mkmty (Tmty_alias (path, lid)) (Mty_alias path) env loc\n smty.pmty_attributes\n | Pmty_signature ssg ->\n let sg = transl_signature env ssg in\n mkmty (Tmty_signature sg) (Mty_signature sg.sig_type) env loc\n smty.pmty_attributes\n | Pmty_functor(sarg_opt, sres) ->\n let t_arg, ty_arg, newenv =\n match sarg_opt with\n | Unit -> Unit, Types.Unit, env\n | Named (param, sarg) ->\n let arg = transl_modtype_functor_arg env sarg in\n let (id, newenv) =\n match param.txt with\n | None -> None, env\n | Some name ->\n let scope = Ctype.create_scope () in\n let id, newenv =\n let arg_md =\n { md_type = arg.mty_type;\n md_attributes = [];\n md_loc = param.loc;\n md_uid = Uid.mk ~current_unit:(Env.get_unit_name ());\n }\n in\n Env.enter_module_declaration ~scope ~arg:true name Mp_present\n arg_md env\n in\n Some id, newenv\n in\n Named (id, param, arg), Types.Named (id, arg.mty_type), newenv\n in\n let res = transl_modtype newenv sres in\n mkmty (Tmty_functor (t_arg, res))\n (Mty_functor(ty_arg, res.mty_type)) env loc\n smty.pmty_attributes\n | Pmty_with(sbody, constraints) ->\n let body = transl_modtype env sbody in\n let init_sg = extract_sig env sbody.pmty_loc body.mty_type in\n let remove_aliases = has_remove_aliases_attribute smty.pmty_attributes in\n let (rev_tcstrs, final_sg) =\n List.fold_left (transl_with ~loc:smty.pmty_loc env remove_aliases)\n ([],init_sg) constraints in\n let scope = Ctype.create_scope () in\n mkmty (Tmty_with ( body, List.rev rev_tcstrs))\n (Mtype.freshen ~scope (Mty_signature final_sg)) env loc\n smty.pmty_attributes\n | Pmty_typeof smod ->\n let env = Env.in_signature false env in\n let tmty, mty = !type_module_type_of_fwd env smod in\n mkmty (Tmty_typeof tmty) mty env loc smty.pmty_attributes\n | Pmty_extension ext ->\n raise (Error_forward (Builtin_attributes.error_of_extension ext))\n\nand transl_with ~loc env remove_aliases (rev_tcstrs,sg) constr =\n let lid, with_info = match constr with\n | Pwith_type (l,decl) ->l , With_type decl\n | Pwith_typesubst (l,decl) ->l , With_typesubst decl\n | Pwith_module (l,l') ->\n let path, md = Env.lookup_module ~loc l'.txt env in\n l , With_module {lid=l';path;md; remove_aliases}\n | Pwith_modsubst (l,l') ->\n let path, md' = Env.lookup_module ~loc l'.txt env in\n l , With_modsubst (l',path,md')\n | Pwith_modtype (l,smty) ->\n let mty = transl_modtype env smty in\n l, With_modtype mty\n | Pwith_modtypesubst (l,smty) ->\n let mty = transl_modtype env smty in\n l, With_modtypesubst mty\n in\n let (tcstr, sg) = merge_constraint env loc sg lid with_info in\n (tcstr :: rev_tcstrs, sg)\n\n\n\nand transl_signature env sg =\n let names = Signature_names.create () in\n let rec transl_sig env sg =\n match sg with\n [] -> [], [], env\n | item :: srem ->\n let loc = item.psig_loc in\n match item.psig_desc with\n | Psig_value sdesc ->\n let (tdesc, newenv) =\n Typedecl.transl_value_decl env item.psig_loc sdesc\n in\n Signature_names.check_value names tdesc.val_loc tdesc.val_id;\n Env.register_uid tdesc.val_val.val_uid tdesc.val_loc;\n let (trem,rem, final_env) = transl_sig newenv srem in\n mksig (Tsig_value tdesc) env loc :: trem,\n Sig_value(tdesc.val_id, tdesc.val_val, Exported) :: rem,\n final_env\n | Psig_type (rec_flag, sdecls) ->\n let (decls, newenv) =\n Typedecl.transl_type_decl env rec_flag sdecls\n in\n List.iter (fun td ->\n Signature_names.check_type names td.typ_loc td.typ_id;\n if not (Btype.is_row_name (Ident.name td.typ_id)) then\n Env.register_uid td.typ_type.type_uid td.typ_loc\n ) decls;\n let (trem, rem, final_env) = transl_sig newenv srem in\n let sg =\n map_rec_type_with_row_types ~rec_flag\n (fun rs td -> Sig_type(td.typ_id, td.typ_type, rs, Exported))\n decls rem\n in\n mksig (Tsig_type (rec_flag, decls)) env loc :: trem,\n sg,\n final_env\n | Psig_typesubst sdecls ->\n let (decls, newenv) =\n Typedecl.transl_type_decl env Nonrecursive sdecls\n in\n List.iter (fun td ->\n if td.typ_kind <> Ttype_abstract || td.typ_manifest = None ||\n td.typ_private = Private\n then\n raise (Error (td.typ_loc, env, Invalid_type_subst_rhs));\n let params = td.typ_type.type_params in\n if params_are_constrained params\n then raise(Error(loc, env, With_cannot_remove_constrained_type));\n let info =\n let subst =\n Subst.add_type_function (Pident td.typ_id)\n ~params\n ~body:(Option.get td.typ_type.type_manifest)\n Subst.identity\n in\n Some (`Substituted_away subst)\n in\n Signature_names.check_type ?info names td.typ_loc td.typ_id;\n Env.register_uid td.typ_type.type_uid td.typ_loc\n ) decls;\n let (trem, rem, final_env) = transl_sig newenv srem in\n let sg = rem\n in\n mksig (Tsig_typesubst decls) env loc :: trem,\n sg,\n final_env\n | Psig_typext styext ->\n let (tyext, newenv) =\n Typedecl.transl_type_extension false env item.psig_loc styext\n in\n let constructors = tyext.tyext_constructors in\n List.iter (fun ext ->\n Signature_names.check_typext names ext.ext_loc ext.ext_id;\n Env.register_uid ext.ext_type.ext_uid ext.ext_loc\n ) constructors;\n let (trem, rem, final_env) = transl_sig newenv srem in\n mksig (Tsig_typext tyext) env loc :: trem,\n map_ext (fun es ext ->\n Sig_typext(ext.ext_id, ext.ext_type, es, Exported)\n ) constructors rem,\n final_env\n | Psig_exception sext ->\n let (ext, newenv) = Typedecl.transl_type_exception env sext in\n let constructor = ext.tyexn_constructor in\n Signature_names.check_typext names constructor.ext_loc\n constructor.ext_id;\n Env.register_uid\n constructor.ext_type.ext_uid\n constructor.ext_loc;\n let (trem, rem, final_env) = transl_sig newenv srem in\n mksig (Tsig_exception ext) env loc :: trem,\n Sig_typext(constructor.ext_id,\n constructor.ext_type,\n Text_exception,\n Exported) :: rem,\n final_env\n | Psig_module pmd ->\n let scope = Ctype.create_scope () in\n let tmty =\n Builtin_attributes.warning_scope pmd.pmd_attributes\n (fun () -> transl_modtype env pmd.pmd_type)\n in\n let pres =\n match tmty.mty_type with\n | Mty_alias _ -> Mp_absent\n | _ -> Mp_present\n in\n let md = {\n md_type=tmty.mty_type;\n md_attributes=pmd.pmd_attributes;\n md_loc=pmd.pmd_loc;\n md_uid = Uid.mk ~current_unit:(Env.get_unit_name ());\n }\n in\n let id, newenv =\n match pmd.pmd_name.txt with\n | None -> None, env\n | Some name ->\n let id, newenv =\n Env.enter_module_declaration ~scope name pres md env\n in\n Signature_names.check_module names pmd.pmd_name.loc id;\n Some id, newenv\n in\n Env.register_uid md.md_uid md.md_loc;\n let (trem, rem, final_env) = transl_sig newenv srem in\n mksig (Tsig_module {md_id=id; md_name=pmd.pmd_name;\n md_presence=pres; md_type=tmty;\n md_loc=pmd.pmd_loc;\n md_attributes=pmd.pmd_attributes})\n env loc :: trem,\n (match id with\n | None -> rem\n | Some id -> Sig_module(id, pres, md, Trec_not, Exported) :: rem),\n final_env\n | Psig_modsubst pms ->\n let scope = Ctype.create_scope () in\n let path, md =\n Env.lookup_module ~loc:pms.pms_manifest.loc\n pms.pms_manifest.txt env\n in\n let aliasable = not (Env.is_functor_arg path env) in\n let md =\n if not aliasable then\n md\n else\n { md_type = Mty_alias path;\n md_attributes = pms.pms_attributes;\n md_loc = pms.pms_loc;\n md_uid = Uid.mk ~current_unit:(Env.get_unit_name ());\n }\n in\n let pres =\n match md.md_type with\n | Mty_alias _ -> Mp_absent\n | _ -> Mp_present\n in\n let id, newenv =\n Env.enter_module_declaration ~scope pms.pms_name.txt pres md env\n in\n let info =\n `Substituted_away (Subst.add_module id path Subst.identity)\n in\n Signature_names.check_module ~info names pms.pms_name.loc id;\n Env.register_uid md.md_uid md.md_loc;\n let (trem, rem, final_env) = transl_sig newenv srem in\n mksig (Tsig_modsubst {ms_id=id; ms_name=pms.pms_name;\n ms_manifest=path; ms_txt=pms.pms_manifest;\n ms_loc=pms.pms_loc;\n ms_attributes=pms.pms_attributes})\n env loc :: trem,\n rem,\n final_env\n | Psig_recmodule sdecls ->\n let (tdecls, newenv) =\n transl_recmodule_modtypes env sdecls in\n let decls =\n List.filter_map (fun (md, uid, _) ->\n match md.md_id with\n | None -> None\n | Some id -> Some (id, md, uid)\n ) tdecls\n in\n List.iter (fun (id, md, uid) ->\n Signature_names.check_module names md.md_loc id;\n Env.register_uid uid md.md_loc\n ) decls;\n let (trem, rem, final_env) = transl_sig newenv srem in\n mksig (Tsig_recmodule (List.map (fun (md, _, _) -> md) tdecls))\n env loc :: trem,\n map_rec (fun rs (id, md, uid) ->\n let d = {Types.md_type = md.md_type.mty_type;\n md_attributes = md.md_attributes;\n md_loc = md.md_loc;\n md_uid = uid;\n } in\n Sig_module(id, Mp_present, d, rs, Exported))\n decls rem,\n final_env\n | Psig_modtype pmtd ->\n let newenv, mtd, decl = transl_modtype_decl env pmtd in\n Signature_names.check_modtype names pmtd.pmtd_loc mtd.mtd_id;\n Env.register_uid decl.mtd_uid mtd.mtd_loc;\n let (trem, rem, final_env) = transl_sig newenv srem in\n mksig (Tsig_modtype mtd) env loc :: trem,\n Sig_modtype (mtd.mtd_id, decl, Exported) :: rem,\n final_env\n | Psig_modtypesubst pmtd ->\n let newenv, mtd, decl = transl_modtype_decl env pmtd in\n let info =\n let mty = match mtd.mtd_type with\n | Some tmty -> tmty.mty_type\n | None ->\n (* parsetree invariant, see Ast_invariants *)\n assert false\n in\n let subst = Subst.add_modtype mtd.mtd_id mty Subst.identity in\n match mty with\n | Mty_ident _ -> `Substituted_away subst\n | _ -> `Unpackable_modtype_substituted_away (mtd.mtd_id,subst)\n in\n Signature_names.check_modtype ~info names pmtd.pmtd_loc mtd.mtd_id;\n Env.register_uid decl.mtd_uid mtd.mtd_loc;\n let (trem, rem, final_env) = transl_sig newenv srem in\n mksig (Tsig_modtypesubst mtd) env loc :: trem,\n rem,\n final_env\n | Psig_open sod ->\n let (od, newenv) = type_open_descr env sod in\n let (trem, rem, final_env) = transl_sig newenv srem in\n mksig (Tsig_open od) env loc :: trem,\n rem, final_env\n | Psig_include sincl ->\n let smty = sincl.pincl_mod in\n let tmty =\n Builtin_attributes.warning_scope sincl.pincl_attributes\n (fun () -> transl_modtype env smty)\n in\n let mty = tmty.mty_type in\n let scope = Ctype.create_scope () in\n let sg, newenv = Env.enter_signature ~scope\n (extract_sig env smty.pmty_loc mty) env in\n Signature_group.iter\n (Signature_names.check_sig_item names item.psig_loc)\n sg;\n let incl =\n { incl_mod = tmty;\n incl_type = sg;\n incl_attributes = sincl.pincl_attributes;\n incl_loc = sincl.pincl_loc;\n }\n in\n let (trem, rem, final_env) = transl_sig newenv srem in\n mksig (Tsig_include incl) env loc :: trem,\n sg @ rem,\n final_env\n | Psig_class cl ->\n let (classes, newenv) = Typeclass.class_descriptions env cl in\n List.iter (fun cls ->\n let open Typeclass in\n let loc = cls.cls_id_loc.Location.loc in\n Signature_names.check_type names loc cls.cls_obj_id;\n Signature_names.check_class names loc cls.cls_id;\n Signature_names.check_class_type names loc cls.cls_ty_id;\n Signature_names.check_type names loc cls.cls_typesharp_id;\n Env.register_uid cls.cls_decl.cty_uid cls.cls_decl.cty_loc;\n ) classes;\n let (trem, rem, final_env) = transl_sig newenv srem in\n let sg =\n map_rec (fun rs cls ->\n let open Typeclass in\n [Sig_class(cls.cls_id, cls.cls_decl, rs, Exported);\n Sig_class_type(cls.cls_ty_id, cls.cls_ty_decl, rs, Exported);\n Sig_type(cls.cls_obj_id, cls.cls_obj_abbr, rs, Exported);\n Sig_type(cls.cls_typesharp_id, cls.cls_abbr, rs, Exported)]\n ) classes [rem]\n |> List.flatten\n in\n let typedtree =\n mksig (Tsig_class\n (List.map (fun decr ->\n decr.Typeclass.cls_info) classes)) env loc\n :: trem\n in\n typedtree, sg, final_env\n | Psig_class_type cl ->\n let (classes, newenv) = Typeclass.class_type_declarations env cl in\n List.iter (fun decl ->\n let open Typeclass in\n let loc = decl.clsty_id_loc.Location.loc in\n Signature_names.check_class_type names loc decl.clsty_ty_id;\n Signature_names.check_type names loc decl.clsty_obj_id;\n Signature_names.check_type names loc decl.clsty_typesharp_id;\n Env.register_uid\n decl.clsty_ty_decl.clty_uid\n decl.clsty_ty_decl.clty_loc;\n ) classes;\n let (trem,rem, final_env) = transl_sig newenv srem in\n let sg =\n map_rec (fun rs decl ->\n let open Typeclass in\n [Sig_class_type(decl.clsty_ty_id, decl.clsty_ty_decl, rs,\n Exported);\n Sig_type(decl.clsty_obj_id, decl.clsty_obj_abbr, rs, Exported);\n Sig_type(decl.clsty_typesharp_id, decl.clsty_abbr, rs,\n Exported)\n ]\n ) classes [rem]\n |> List.flatten\n in\n let typedtree =\n mksig\n (Tsig_class_type\n (List.map (fun decl -> decl.Typeclass.clsty_info) classes))\n env loc\n :: trem\n in\n typedtree, sg, final_env\n | Psig_attribute x ->\n Builtin_attributes.warning_attribute x;\n let (trem,rem, final_env) = transl_sig env srem in\n mksig (Tsig_attribute x) env loc :: trem, rem, final_env\n | Psig_extension (ext, _attrs) ->\n raise (Error_forward (Builtin_attributes.error_of_extension ext))\n in\n let previous_saved_types = Cmt_format.get_saved_types () in\n Builtin_attributes.warning_scope []\n (fun () ->\n let (trem, rem, final_env) = transl_sig (Env.in_signature true env) sg in\n let rem = Signature_names.simplify final_env names rem in\n let sg =\n { sig_items = trem; sig_type = rem; sig_final_env = final_env }\n in\n Cmt_format.set_saved_types\n ((Cmt_format.Partial_signature sg) :: previous_saved_types);\n sg\n )\n\nand transl_modtype_decl env pmtd =\n Builtin_attributes.warning_scope pmtd.pmtd_attributes\n (fun () -> transl_modtype_decl_aux env pmtd)\n\nand transl_modtype_decl_aux env\n {pmtd_name; pmtd_type; pmtd_attributes; pmtd_loc} =\n let tmty =\n Option.map (transl_modtype (Env.in_signature true env)) pmtd_type\n in\n let decl =\n {\n Types.mtd_type=Option.map (fun t -> t.mty_type) tmty;\n mtd_attributes=pmtd_attributes;\n mtd_loc=pmtd_loc;\n mtd_uid = Uid.mk ~current_unit:(Env.get_unit_name ());\n }\n in\n let scope = Ctype.create_scope () in\n let (id, newenv) = Env.enter_modtype ~scope pmtd_name.txt decl env in\n let mtd =\n {\n mtd_id=id;\n mtd_name=pmtd_name;\n mtd_type=tmty;\n mtd_attributes=pmtd_attributes;\n mtd_loc=pmtd_loc;\n }\n in\n newenv, mtd, decl\n\nand transl_recmodule_modtypes env sdecls =\n let make_env curr =\n List.fold_left (fun env (id_shape, _, md, _) ->\n Option.fold ~none:env ~some:(fun (id, shape) ->\n Env.add_module_declaration ~check:true ~shape ~arg:true\n id Mp_present md env\n ) id_shape\n ) env curr\n in\n let transition env_c curr =\n List.map2\n (fun pmd (id_shape, id_loc, md, _) ->\n let tmty =\n Builtin_attributes.warning_scope pmd.pmd_attributes\n (fun () -> transl_modtype env_c pmd.pmd_type)\n in\n let md = { md with Types.md_type = tmty.mty_type } in\n (id_shape, id_loc, md, tmty))\n sdecls curr in\n let map_mtys curr =\n List.filter_map\n (fun (id_shape, _, md, _) ->\n Option.map (fun (id, _) -> (id, md)) id_shape)\n curr\n in\n let scope = Ctype.create_scope () in\n let ids =\n List.map (fun x -> Option.map (Ident.create_scoped ~scope) x.pmd_name.txt)\n sdecls\n in\n let approx_env =\n List.fold_left\n (fun env ->\n Option.fold ~none:env ~some:(fun id -> (* cf #5965 *)\n Env.enter_unbound_module (Ident.name id)\n Mod_unbound_illegal_recursion env\n ))\n env ids\n in\n let init =\n List.map2\n (fun id pmd ->\n let md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in\n let md =\n { md_type = approx_modtype approx_env pmd.pmd_type;\n md_loc = pmd.pmd_loc;\n md_attributes = pmd.pmd_attributes;\n md_uid }\n in\n let id_shape =\n Option.map (fun id -> id, Shape.var md_uid id) id\n in\n (id_shape, pmd.pmd_name, md, ()))\n ids sdecls\n in\n let env0 = make_env init in\n let dcl1 =\n Warnings.without_warnings\n (fun () -> transition env0 init)\n in\n let env1 = make_env dcl1 in\n check_recmod_typedecls env1 (map_mtys dcl1);\n let dcl2 = transition env1 dcl1 in\n(*\n List.iter\n (fun (id, mty) ->\n Format.printf \"%a: %a@.\" Printtyp.ident id Printtyp.modtype mty)\n dcl2;\n*)\n let env2 = make_env dcl2 in\n check_recmod_typedecls env2 (map_mtys dcl2);\n let dcl2 =\n List.map2 (fun pmd (id_shape, id_loc, md, mty) ->\n let tmd =\n {md_id=Option.map fst id_shape; md_name=id_loc; md_type=mty;\n md_presence=Mp_present;\n md_loc=pmd.pmd_loc;\n md_attributes=pmd.pmd_attributes}\n in\n tmd, md.md_uid, Option.map snd id_shape\n ) sdecls dcl2\n in\n (dcl2, env2)\n\n(* Try to convert a module expression to a module path. *)\n\nexception Not_a_path\n\nlet rec path_of_module mexp =\n match mexp.mod_desc with\n | Tmod_ident (p,_) -> p\n | Tmod_apply(funct, arg, _coercion) when !Clflags.applicative_functors ->\n Papply(path_of_module funct, path_of_module arg)\n | Tmod_constraint (mexp, _, _, _) ->\n path_of_module mexp\n | _ -> raise Not_a_path\n\nlet path_of_module mexp =\n try Some (path_of_module mexp) with Not_a_path -> None\n\n(* Check that all core type schemes in a structure\n do not contain non-generalized type variable *)\n\nlet rec nongen_modtype env = function\n Mty_ident _ -> false\n | Mty_alias _ -> false\n | Mty_signature sg ->\n let env = Env.add_signature sg env in\n List.exists (nongen_signature_item env) sg\n | Mty_functor(arg_opt, body) ->\n let env =\n match arg_opt with\n | Unit\n | Named (None, _) -> env\n | Named (Some id, param) ->\n Env.add_module ~arg:true id Mp_present param env\n in\n nongen_modtype env body\n\nand nongen_signature_item env = function\n Sig_value(_id, desc, _) -> Ctype.nongen_schema env desc.val_type\n | Sig_module(_id, _, md, _, _) -> nongen_modtype env md.md_type\n | _ -> false\n\nlet check_nongen_signature_item env sig_item =\n match sig_item with\n Sig_value(_id, vd, _) ->\n if Ctype.nongen_schema env vd.val_type then\n raise (Error (vd.val_loc, env, Non_generalizable vd.val_type))\n | Sig_module (_id, _, md, _, _) ->\n if nongen_modtype env md.md_type then\n raise(Error(md.md_loc, env, Non_generalizable_module md.md_type))\n | _ -> ()\n\nlet check_nongen_signature env sg =\n List.iter (check_nongen_signature_item env) sg\n\n(* Helpers for typing recursive modules *)\n\nlet anchor_submodule name anchor =\n match anchor, name with\n | None, _\n | _, None ->\n None\n | Some p, Some name ->\n Some(Pdot(p, name))\n\nlet anchor_recmodule = Option.map (fun id -> Pident id)\n\nlet enrich_type_decls anchor decls oldenv newenv =\n match anchor with\n None -> newenv\n | Some p ->\n List.fold_left\n (fun e info ->\n let id = info.typ_id in\n let info' =\n Mtype.enrich_typedecl oldenv (Pdot(p, Ident.name id))\n id info.typ_type\n in\n Env.add_type ~check:true id info' e)\n oldenv decls\n\nlet enrich_module_type anchor name mty env =\n match anchor, name with\n | None, _\n | _, None ->\n mty\n | Some p, Some name ->\n Mtype.enrich_modtype env (Pdot(p, name)) mty\n\nlet check_recmodule_inclusion env bindings =\n (* PR#4450, PR#4470: consider\n module rec X : DECL = MOD where MOD has inferred type ACTUAL\n The \"natural\" typing condition\n E, X: ACTUAL |- ACTUAL <: DECL\n leads to circularities through manifest types.\n Instead, we \"unroll away\" the potential circularities a finite number\n of times. The (weaker) condition we implement is:\n E, X: DECL,\n X1: ACTUAL,\n X2: ACTUAL{X <- X1}/X1\n ...\n Xn: ACTUAL{X <- X(n-1)}/X(n-1)\n |- ACTUAL{X <- Xn}/Xn <: DECL{X <- Xn}\n so that manifest types rooted at X(n+1) are expanded in terms of X(n),\n avoiding circularities. The strengthenings ensure that\n Xn.t = X(n-1).t = ... = X2.t = X1.t.\n N can be chosen arbitrarily; larger values of N result in more\n recursive definitions being accepted. A good choice appears to be\n the number of mutually recursive declarations. *)\n\n let subst_and_strengthen env scope s id mty =\n let mty = Subst.modtype (Rescope scope) s mty in\n match id with\n | None -> mty\n | Some id ->\n Mtype.strengthen ~aliasable:false env mty\n (Subst.module_path s (Pident id))\n in\n\n let rec check_incl first_time n env s =\n let scope = Ctype.create_scope () in\n if n > 0 then begin\n (* Generate fresh names Y_i for the rec. bound module idents X_i *)\n let bindings1 =\n List.map\n (fun (id, _name, _mty_decl, _modl,\n mty_actual, _attrs, _loc, shape, _uid) ->\n let ids =\n Option.map\n (fun id -> (id, Ident.create_scoped ~scope (Ident.name id))) id\n in\n (ids, mty_actual, shape))\n bindings in\n (* Enter the Y_i in the environment with their actual types substituted\n by the input substitution s *)\n let env' =\n List.fold_left\n (fun env (ids, mty_actual, shape) ->\n match ids with\n | None -> env\n | Some (id, id') ->\n let mty_actual' =\n if first_time\n then mty_actual\n else subst_and_strengthen env scope s (Some id) mty_actual\n in\n Env.add_module ~arg:false ~shape id' Mp_present mty_actual' env)\n env bindings1 in\n (* Build the output substitution Y_i <- X_i *)\n let s' =\n List.fold_left\n (fun s (ids, _mty_actual, _shape) ->\n match ids with\n | None -> s\n | Some (id, id') -> Subst.add_module id (Pident id') s)\n Subst.identity bindings1 in\n (* Recurse with env' and s' *)\n check_incl false (n-1) env' s'\n end else begin\n (* Base case: check inclusion of s(mty_actual) in s(mty_decl)\n and insert coercion if needed *)\n let check_inclusion\n (id, name, mty_decl, modl, mty_actual, attrs, loc, shape, uid) =\n let mty_decl' = Subst.modtype (Rescope scope) s mty_decl.mty_type\n and mty_actual' = subst_and_strengthen env scope s id mty_actual in\n let coercion, shape =\n try\n Includemod.modtypes_with_shape ~shape\n ~loc:modl.mod_loc ~mark:Mark_both\n env mty_actual' mty_decl'\n with Includemod.Error msg ->\n raise(Error(modl.mod_loc, env, Not_included msg)) in\n let modl' =\n { mod_desc = Tmod_constraint(modl, mty_decl.mty_type,\n Tmodtype_explicit mty_decl, coercion);\n mod_type = mty_decl.mty_type;\n mod_env = env;\n mod_loc = modl.mod_loc;\n mod_attributes = [];\n } in\n let mb =\n {\n mb_id = id;\n mb_name = name;\n mb_presence = Mp_present;\n mb_expr = modl';\n mb_attributes = attrs;\n mb_loc = loc;\n }\n in\n mb, shape, uid\n in\n List.map check_inclusion bindings\n end\n in check_incl true (List.length bindings) env Subst.identity\n\n(* Helper for unpack *)\n\nlet rec package_constraints_sig env loc sg constrs =\n List.map\n (function\n | Sig_type (id, ({type_params=[]} as td), rs, priv)\n when List.mem_assoc [Ident.name id] constrs ->\n let ty = List.assoc [Ident.name id] constrs in\n Sig_type (id, {td with type_manifest = Some ty}, rs, priv)\n | Sig_module (id, pres, md, rs, priv) ->\n let rec aux = function\n | (m :: ((_ :: _) as l), t) :: rest when m = Ident.name id ->\n (l, t) :: aux rest\n | _ :: rest -> aux rest\n | [] -> []\n in\n let md =\n {md with\n md_type = package_constraints env loc md.md_type (aux constrs)\n }\n in\n Sig_module (id, pres, md, rs, priv)\n | item -> item\n )\n sg\n\nand package_constraints env loc mty constrs =\n if constrs = [] then mty\n else begin\n match Mtype.scrape env mty with\n | Mty_signature sg ->\n Mty_signature (package_constraints_sig env loc sg constrs)\n | Mty_functor _ | Mty_alias _ -> assert false\n | Mty_ident p -> raise(Error(loc, env, Cannot_scrape_package_type p))\n end\n\nlet modtype_of_package env loc p fl =\n package_constraints env loc (Mty_ident p)\n (List.map (fun (n, t) -> (Longident.flatten n, t)) fl)\n\nlet package_subtype env p1 fl1 p2 fl2 =\n let mkmty p fl =\n let fl =\n List.filter (fun (_n,t) -> Ctype.free_variables t = []) fl in\n modtype_of_package env Location.none p fl\n in\n match mkmty p1 fl1, mkmty p2 fl2 with\n | exception Error(_, _, Cannot_scrape_package_type _) -> false\n | mty1, mty2 ->\n let loc = Location.none in\n match Includemod.modtypes ~loc ~mark:Mark_both env mty1 mty2 with\n | Tcoerce_none -> true\n | _ | exception Includemod.Error _ -> false\n\nlet () = Ctype.package_subtype := package_subtype\n\nlet wrap_constraint env mark arg mty explicit =\n let mark = if mark then Includemod.Mark_both else Includemod.Mark_neither in\n let coercion =\n try\n Includemod.modtypes ~loc:arg.mod_loc env ~mark arg.mod_type mty\n with Includemod.Error msg ->\n raise(Error(arg.mod_loc, env, Not_included msg)) in\n { mod_desc = Tmod_constraint(arg, mty, explicit, coercion);\n mod_type = mty;\n mod_env = env;\n mod_attributes = [];\n mod_loc = arg.mod_loc }\n\nlet wrap_constraint_with_shape env mark arg mty\n shape explicit =\n let mark = if mark then Includemod.Mark_both else Includemod.Mark_neither in\n let coercion, shape =\n try\n Includemod.modtypes_with_shape ~shape ~loc:arg.mod_loc env ~mark\n arg.mod_type mty\n with Includemod.Error msg ->\n raise(Error(arg.mod_loc, env, Not_included msg)) in\n { mod_desc = Tmod_constraint(arg, mty, explicit, coercion);\n mod_type = mty;\n mod_env = env;\n mod_attributes = [];\n mod_loc = arg.mod_loc }, shape\n\n(* Type a module value expression *)\n\n\n(* Summary for F(X) *)\ntype application_summary = {\n loc: Location.t;\n attributes: attributes;\n f_loc: Location.t; (* loc for F *)\n arg_is_syntactic_unit: bool;\n arg: Typedtree.module_expr;\n arg_path: Path.t option;\n shape: Shape.t\n}\n\nlet simplify_app_summary app_view =\n let mty = app_view.arg.mod_type in\n match app_view.arg_is_syntactic_unit , app_view.arg_path with\n | true, _ -> Includemod.Error.Unit, mty\n | false, Some p -> Includemod.Error.Named p, mty\n | false, None -> Includemod.Error.Anonymous, mty\n\nlet rec type_module ?(alias=false) sttn funct_body anchor env smod =\n Builtin_attributes.warning_scope smod.pmod_attributes\n (fun () -> type_module_aux ~alias sttn funct_body anchor env smod)\n\nand type_module_aux ~alias sttn funct_body anchor env smod =\n match smod.pmod_desc with\n Pmod_ident lid ->\n let path =\n Env.lookup_module_path ~load:(not alias) ~loc:smod.pmod_loc lid.txt env\n in\n let md = { mod_desc = Tmod_ident (path, lid);\n mod_type = Mty_alias path;\n mod_env = env;\n mod_attributes = smod.pmod_attributes;\n mod_loc = smod.pmod_loc } in\n let aliasable = not (Env.is_functor_arg path env) in\n let shape =\n Env.shape_of_path ~namespace:Shape.Sig_component_kind.Module env path\n in\n let md =\n if alias && aliasable then\n (Env.add_required_global (Path.head path); md)\n else begin\n let mty =\n if sttn then\n Env.find_strengthened_module ~aliasable path env\n else\n (Env.find_module path env).md_type\n in\n match mty with\n | Mty_alias p1 when not alias ->\n let p1 = Env.normalize_module_path (Some smod.pmod_loc) env p1 in\n let mty = Includemod.expand_module_alias\n ~strengthen:sttn env p1 in\n { md with\n mod_desc =\n Tmod_constraint (md, mty, Tmodtype_implicit,\n Tcoerce_alias (env, path, Tcoerce_none));\n mod_type = mty }\n | mty ->\n { md with mod_type = mty }\n end\n in\n md, shape\n | Pmod_structure sstr ->\n let (str, sg, names, shape, _finalenv) =\n type_structure funct_body anchor env sstr in\n let md =\n { mod_desc = Tmod_structure str;\n mod_type = Mty_signature sg;\n mod_env = env;\n mod_attributes = smod.pmod_attributes;\n mod_loc = smod.pmod_loc }\n in\n let sg' = Signature_names.simplify _finalenv names sg in\n if List.length sg' = List.length sg then md, shape else\n wrap_constraint_with_shape env false md\n (Mty_signature sg') shape Tmodtype_implicit\n | Pmod_functor(arg_opt, sbody) ->\n let t_arg, ty_arg, newenv, funct_shape_param, funct_body =\n match arg_opt with\n | Unit ->\n Unit, Types.Unit, env, Shape.for_unnamed_functor_param, false\n | Named (param, smty) ->\n let mty = transl_modtype_functor_arg env smty in\n let scope = Ctype.create_scope () in\n let (id, newenv, var) =\n match param.txt with\n | None -> None, env, Shape.for_unnamed_functor_param\n | Some name ->\n let md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in\n let arg_md =\n { md_type = mty.mty_type;\n md_attributes = [];\n md_loc = param.loc;\n md_uid;\n }\n in\n let id = Ident.create_scoped ~scope name in\n let shape = Shape.var md_uid id in\n let newenv = Env.add_module_declaration\n ~shape ~arg:true ~check:true id Mp_present arg_md env\n in\n Some id, newenv, id\n in\n Named (id, param, mty), Types.Named (id, mty.mty_type), newenv,\n var, true\n in\n let body, body_shape = type_module true funct_body None newenv sbody in\n { mod_desc = Tmod_functor(t_arg, body);\n mod_type = Mty_functor(ty_arg, body.mod_type);\n mod_env = env;\n mod_attributes = smod.pmod_attributes;\n mod_loc = smod.pmod_loc },\n Shape.abs funct_shape_param body_shape\n | Pmod_apply _ ->\n type_application smod.pmod_loc sttn funct_body env smod\n | Pmod_constraint(sarg, smty) ->\n let arg, arg_shape = type_module ~alias true funct_body anchor env sarg in\n let mty = transl_modtype env smty in\n let md, final_shape =\n wrap_constraint_with_shape env true arg mty.mty_type arg_shape\n (Tmodtype_explicit mty)\n in\n { md with\n mod_loc = smod.pmod_loc;\n mod_attributes = smod.pmod_attributes;\n },\n final_shape\n | Pmod_unpack sexp ->\n if !Clflags.principal then Ctype.begin_def ();\n let exp = Typecore.type_exp env sexp in\n if !Clflags.principal then begin\n Ctype.end_def ();\n Ctype.generalize_structure exp.exp_type\n end;\n let mty =\n match get_desc (Ctype.expand_head env exp.exp_type) with\n Tpackage (p, fl) ->\n if List.exists (fun (_n, t) -> Ctype.free_variables t <> []) fl then\n raise (Error (smod.pmod_loc, env,\n Incomplete_packed_module exp.exp_type));\n if !Clflags.principal &&\n not (Typecore.generalizable (Btype.generic_level-1) exp.exp_type)\n then\n Location.prerr_warning smod.pmod_loc\n (Warnings.Not_principal \"this module unpacking\");\n modtype_of_package env smod.pmod_loc p fl\n | Tvar _ ->\n raise (Typecore.Error\n (smod.pmod_loc, env, Typecore.Cannot_infer_signature))\n | _ ->\n raise (Error(smod.pmod_loc, env, Not_a_packed_module exp.exp_type))\n in\n if funct_body && Mtype.contains_type env mty then\n raise (Error (smod.pmod_loc, env, Not_allowed_in_functor_body));\n { mod_desc = Tmod_unpack(exp, mty);\n mod_type = mty;\n mod_env = env;\n mod_attributes = smod.pmod_attributes;\n mod_loc = smod.pmod_loc },\n Shape.leaf_for_unpack\n | Pmod_extension ext ->\n raise (Error_forward (Builtin_attributes.error_of_extension ext))\n\nand type_application loc strengthen funct_body env smod =\n let rec extract_application funct_body env sargs smod =\n match smod.pmod_desc with\n | Pmod_apply(f, sarg) ->\n let arg, shape = type_module true funct_body None env sarg in\n let summary =\n { loc=smod.pmod_loc;\n attributes=smod.pmod_attributes;\n f_loc = f.pmod_loc;\n arg_is_syntactic_unit = sarg.pmod_desc = Pmod_structure [];\n arg;\n arg_path = path_of_module arg;\n shape\n }\n in\n extract_application funct_body env (summary::sargs) f\n | _ -> smod, sargs\n in\n let sfunct, args = extract_application funct_body env [] smod in\n let funct, funct_shape =\n let strengthen =\n strengthen && List.for_all (fun {arg_path;_} -> arg_path <> None) args\n in\n type_module strengthen funct_body None env sfunct\n in\n List.fold_left (type_one_application ~ctx:(loc, funct, args) funct_body env)\n (funct, funct_shape) args\n\nand type_one_application ~ctx:(apply_loc,md_f,args)\n funct_body env (funct, funct_shape) app_view =\n match Env.scrape_alias env funct.mod_type with\n | Mty_functor (Unit, mty_res) ->\n if not app_view.arg_is_syntactic_unit then\n raise (Error (app_view.f_loc, env, Apply_generative));\n if funct_body && Mtype.contains_type env funct.mod_type then\n raise (Error (apply_loc, env, Not_allowed_in_functor_body));\n { mod_desc = Tmod_apply(funct, app_view.arg, Tcoerce_none);\n mod_type = mty_res;\n mod_env = env;\n mod_attributes = app_view.attributes;\n mod_loc = funct.mod_loc },\n Shape.app funct_shape ~arg:app_view.shape\n | Mty_functor (Named (param, mty_param), mty_res) as mty_functor ->\n let coercion =\n try\n Includemod.modtypes\n ~loc:app_view.arg.mod_loc ~mark:Mark_both env\n app_view.arg.mod_type mty_param\n with Includemod.Error _ ->\n let args = List.map simplify_app_summary args in\n let mty_f = md_f.mod_type in\n let lid_app = None in\n raise(Includemod.Apply_error {loc=apply_loc;env;lid_app;mty_f;args})\n in\n let mty_appl =\n match app_view.arg_path with\n | Some path ->\n let scope = Ctype.create_scope () in\n let subst =\n match param with\n | None -> Subst.identity\n | Some p -> Subst.add_module p path Subst.identity\n in\n Subst.modtype (Rescope scope) subst mty_res\n | None ->\n let env, nondep_mty =\n match param with\n | None -> env, mty_res\n | Some param ->\n let env =\n Env.add_module ~arg:true param Mp_present\n app_view.arg.mod_type env\n in\n check_well_formed_module env app_view.loc\n \"the signature of this functor application\" mty_res;\n try env, Mtype.nondep_supertype env [param] mty_res\n with Ctype.Nondep_cannot_erase _ ->\n let error = Cannot_eliminate_dependency mty_functor in\n raise (Error(app_view.loc, env, error))\n in\n begin match\n Includemod.modtypes\n ~loc:app_view.loc ~mark:Mark_neither env mty_res nondep_mty\n with\n | Tcoerce_none -> ()\n | _ ->\n fatal_error\n \"unexpected coercion from original module type to \\\n nondep_supertype one\"\n | exception Includemod.Error _ ->\n fatal_error\n \"nondep_supertype not included in original module type\"\n end;\n nondep_mty\n in\n check_well_formed_module env apply_loc\n \"the signature of this functor application\" mty_appl;\n { mod_desc = Tmod_apply(funct, app_view.arg, coercion);\n mod_type = mty_appl;\n mod_env = env;\n mod_attributes = app_view.attributes;\n mod_loc = app_view.loc },\n Shape.app ~arg:app_view.shape funct_shape\n | Mty_alias path ->\n raise(Error(app_view.f_loc, env, Cannot_scrape_alias path))\n | _ ->\n let args = List.map simplify_app_summary args in\n let mty_f = md_f.mod_type in\n let lid_app = None in\n raise(Includemod.Apply_error {loc=apply_loc;env;lid_app;mty_f;args})\n\nand type_open_decl ?used_slot ?toplevel funct_body names env sod =\n Builtin_attributes.warning_scope sod.popen_attributes\n (fun () ->\n type_open_decl_aux ?used_slot ?toplevel funct_body names env sod\n )\n\nand type_open_decl_aux ?used_slot ?toplevel funct_body names env od =\n let loc = od.popen_loc in\n match od.popen_expr.pmod_desc with\n | Pmod_ident lid ->\n let path, newenv =\n type_open_ ?used_slot ?toplevel od.popen_override env loc lid\n in\n let md = { mod_desc = Tmod_ident (path, lid);\n mod_type = Mty_alias path;\n mod_env = env;\n mod_attributes = od.popen_expr.pmod_attributes;\n mod_loc = od.popen_expr.pmod_loc }\n in\n let open_descr = {\n open_expr = md;\n open_bound_items = [];\n open_override = od.popen_override;\n open_env = newenv;\n open_loc = loc;\n open_attributes = od.popen_attributes\n } in\n open_descr, [], newenv\n | _ ->\n let md, mod_shape = type_module true funct_body None env od.popen_expr in\n let scope = Ctype.create_scope () in\n let sg, newenv =\n Env.enter_signature ~scope ~mod_shape\n (extract_sig_open env md.mod_loc md.mod_type) env\n in\n let info, visibility =\n match toplevel with\n | Some false | None -> Some `From_open, Hidden\n | Some true -> None, Exported\n in\n Signature_group.iter (Signature_names.check_sig_item ?info names loc) sg;\n let sg =\n List.map (function\n | Sig_value(id, vd, _) -> Sig_value(id, vd, visibility)\n | Sig_type(id, td, rs, _) -> Sig_type(id, td, rs, visibility)\n | Sig_typext(id, ec, et, _) -> Sig_typext(id, ec, et, visibility)\n | Sig_module(id, mp, md, rs, _) ->\n Sig_module(id, mp, md, rs, visibility)\n | Sig_modtype(id, mtd, _) -> Sig_modtype(id, mtd, visibility)\n | Sig_class(id, cd, rs, _) -> Sig_class(id, cd, rs, visibility)\n | Sig_class_type(id, ctd, rs, _) ->\n Sig_class_type(id, ctd, rs, visibility)\n ) sg\n in\n let open_descr = {\n open_expr = md;\n open_bound_items = sg;\n open_override = od.popen_override;\n open_env = newenv;\n open_loc = loc;\n open_attributes = od.popen_attributes\n } in\n open_descr, sg, newenv\n\nand type_structure ?(toplevel = false) funct_body anchor env sstr =\n let names = Signature_names.create () in\n\n let type_str_item env shape_map {pstr_loc = loc; pstr_desc = desc} =\n match desc with\n | Pstr_eval (sexpr, attrs) ->\n let expr =\n Builtin_attributes.warning_scope attrs\n (fun () -> Typecore.type_expression env sexpr)\n in\n Tstr_eval (expr, attrs), [], shape_map, env\n | Pstr_value(rec_flag, sdefs) ->\n let (defs, newenv) =\n Typecore.type_binding env rec_flag sdefs in\n let () = if rec_flag = Recursive then\n Typecore.check_recursive_bindings env defs\n in\n (* Note: Env.find_value does not trigger the value_used event. Values\n will be marked as being used during the signature inclusion test. *)\n let items, shape_map =\n List.fold_left\n (fun (acc, shape_map) (id, { Asttypes.loc; _ }, _typ)->\n Signature_names.check_value names loc id;\n let vd = Env.find_value (Pident id) newenv in\n Env.register_uid vd.val_uid vd.val_loc;\n Sig_value(id, vd, Exported) :: acc,\n Shape.Map.add_value shape_map id vd.val_uid\n )\n ([], shape_map)\n (let_bound_idents_full defs)\n in\n Tstr_value(rec_flag, defs),\n List.rev items,\n shape_map,\n newenv\n | Pstr_primitive sdesc ->\n let (desc, newenv) = Typedecl.transl_value_decl env loc sdesc in\n Signature_names.check_value names desc.val_loc desc.val_id;\n Env.register_uid desc.val_val.val_uid desc.val_val.val_loc;\n Tstr_primitive desc,\n [Sig_value(desc.val_id, desc.val_val, Exported)],\n Shape.Map.add_value shape_map desc.val_id desc.val_val.val_uid,\n newenv\n | Pstr_type (rec_flag, sdecls) ->\n let (decls, newenv) = Typedecl.transl_type_decl env rec_flag sdecls in\n List.iter\n Signature_names.(fun td -> check_type names td.typ_loc td.typ_id)\n decls;\n let items = map_rec_type_with_row_types ~rec_flag\n (fun rs info -> Sig_type(info.typ_id, info.typ_type, rs, Exported))\n decls []\n in\n let shape_map = List.fold_left\n (fun shape_map -> function\n | Sig_type (id, vd, _, _) ->\n if not (Btype.is_row_name (Ident.name id)) then begin\n Env.register_uid vd.type_uid vd.type_loc;\n Shape.Map.add_type shape_map id vd.type_uid\n end else shape_map\n | _ -> assert false\n )\n shape_map\n items\n in\n Tstr_type (rec_flag, decls),\n items,\n shape_map,\n enrich_type_decls anchor decls env newenv\n | Pstr_typext styext ->\n let (tyext, newenv) =\n Typedecl.transl_type_extension true env loc styext\n in\n let constructors = tyext.tyext_constructors in\n let shape_map = List.fold_left (fun shape_map ext ->\n Signature_names.check_typext names ext.ext_loc ext.ext_id;\n Env.register_uid ext.ext_type.ext_uid ext.ext_loc;\n Shape.Map.add_extcons shape_map ext.ext_id ext.ext_type.ext_uid\n ) shape_map constructors\n in\n (Tstr_typext tyext,\n map_ext\n (fun es ext -> Sig_typext(ext.ext_id, ext.ext_type, es, Exported))\n constructors [],\n shape_map,\n newenv)\n | Pstr_exception sext ->\n let (ext, newenv) = Typedecl.transl_type_exception env sext in\n let constructor = ext.tyexn_constructor in\n Signature_names.check_typext names constructor.ext_loc\n constructor.ext_id;\n Env.register_uid\n constructor.ext_type.ext_uid\n constructor.ext_loc;\n Tstr_exception ext,\n [Sig_typext(constructor.ext_id,\n constructor.ext_type,\n Text_exception,\n Exported)],\n Shape.Map.add_extcons shape_map\n constructor.ext_id\n constructor.ext_type.ext_uid,\n newenv\n | Pstr_module {pmb_name = name; pmb_expr = smodl; pmb_attributes = attrs;\n pmb_loc;\n } ->\n let outer_scope = Ctype.get_current_level () in\n let scope = Ctype.create_scope () in\n let modl, md_shape =\n Builtin_attributes.warning_scope attrs\n (fun () ->\n type_module ~alias:true true funct_body\n (anchor_submodule name.txt anchor) env smodl\n )\n in\n let pres =\n match modl.mod_type with\n | Mty_alias _ -> Mp_absent\n | _ -> Mp_present\n in\n let md_uid = Uid.mk ~current_unit:(Env.get_unit_name ()) in\n let md =\n { md_type = enrich_module_type anchor name.txt modl.mod_type env;\n md_attributes = attrs;\n md_loc = pmb_loc;\n md_uid;\n }\n in\n let md_shape = Shape.set_uid_if_none md_shape md_uid in\n Env.register_uid md_uid pmb_loc;\n (*prerr_endline (Ident.unique_toplevel_name id);*)\n Mtype.lower_nongen outer_scope md.md_type;\n let id, newenv, sg =\n match name.txt with\n | None -> None, env, []\n | Some name ->\n let id, e = Env.enter_module_declaration\n ~scope ~shape:md_shape name pres md env\n in\n Signature_names.check_module names pmb_loc id;\n Some id, e,\n [Sig_module(id, pres,\n {md_type = modl.mod_type;\n md_attributes = attrs;\n md_loc = pmb_loc;\n md_uid;\n }, Trec_not, Exported)]\n in\n let shape_map = match id with\n | Some id -> Shape.Map.add_module shape_map id md_shape\n | None -> shape_map\n in\n Tstr_module {mb_id=id; mb_name=name; mb_expr=modl;\n mb_presence=pres; mb_attributes=attrs; mb_loc=pmb_loc; },\n sg,\n shape_map,\n newenv\n | Pstr_recmodule sbind ->\n let sbind =\n List.map\n (function\n | {pmb_name = name;\n pmb_expr = {pmod_desc=Pmod_constraint(expr, typ)};\n pmb_attributes = attrs;\n pmb_loc = loc;\n } ->\n name, typ, expr, attrs, loc\n | mb ->\n raise (Error (mb.pmb_expr.pmod_loc, env,\n Recursive_module_require_explicit_type))\n )\n sbind\n in\n let (decls, newenv) =\n transl_recmodule_modtypes env\n (List.map (fun (name, smty, _smodl, attrs, loc) ->\n {pmd_name=name; pmd_type=smty;\n pmd_attributes=attrs; pmd_loc=loc}) sbind\n ) in\n List.iter\n (fun (md, _, _) ->\n Option.iter Signature_names.(check_module names md.md_loc) md.md_id\n ) decls;\n let bindings1 =\n List.map2\n (fun ({md_id=id; md_type=mty}, uid, _prev_shape)\n (name, _, smodl, attrs, loc) ->\n let modl, shape =\n Builtin_attributes.warning_scope attrs\n (fun () ->\n type_module true funct_body (anchor_recmodule id)\n newenv smodl\n )\n in\n let mty' =\n enrich_module_type anchor name.txt modl.mod_type newenv\n in\n (id, name, mty, modl, mty', attrs, loc, shape, uid))\n decls sbind in\n let newenv = (* allow aliasing recursive modules from outside *)\n List.fold_left\n (fun env (id_opt, _, mty, _, _, attrs, loc, shape, uid) ->\n match id_opt with\n | None -> env\n | Some id ->\n let mdecl =\n {\n md_type = mty.mty_type;\n md_attributes = attrs;\n md_loc = loc;\n md_uid = uid;\n }\n in\n Env.add_module_declaration ~check:true ~shape\n id Mp_present mdecl env\n )\n env bindings1\n in\n let bindings2 =\n check_recmodule_inclusion newenv bindings1 in\n let mbs =\n List.filter_map (fun (mb, shape, uid) ->\n Option.map (fun id -> id, mb, uid, shape) mb.mb_id\n ) bindings2\n in\n let shape_map =\n List.fold_left (fun map (id, mb, uid, shape) ->\n Env.register_uid uid mb.mb_loc;\n Shape.Map.add_module map id shape\n ) shape_map mbs\n in\n Tstr_recmodule (List.map (fun (mb, _, _) -> mb) bindings2),\n map_rec (fun rs (id, mb, uid, _shape) ->\n Sig_module(id, Mp_present, {\n md_type=mb.mb_expr.mod_type;\n md_attributes=mb.mb_attributes;\n md_loc=mb.mb_loc;\n md_uid = uid;\n }, rs, Exported))\n mbs [],\n shape_map,\n newenv\n | Pstr_modtype pmtd ->\n (* check that it is non-abstract *)\n let newenv, mtd, decl = transl_modtype_decl env pmtd in\n Signature_names.check_modtype names pmtd.pmtd_loc mtd.mtd_id;\n Env.register_uid decl.mtd_uid decl.mtd_loc;\n let id = mtd.mtd_id in\n let map = Shape.Map.add_module_type shape_map id decl.mtd_uid in\n Tstr_modtype mtd, [Sig_modtype (id, decl, Exported)], map, newenv\n | Pstr_open sod ->\n let (od, sg, newenv) =\n type_open_decl ~toplevel funct_body names env sod\n in\n Tstr_open od, sg, shape_map, newenv\n | Pstr_class cl ->\n let (classes, new_env) = Typeclass.class_declarations env cl in\n let shape_map = List.fold_left (fun acc cls ->\n let open Typeclass in\n let loc = cls.cls_id_loc.Location.loc in\n Signature_names.check_class names loc cls.cls_id;\n Signature_names.check_class_type names loc cls.cls_ty_id;\n Signature_names.check_type names loc cls.cls_obj_id;\n Signature_names.check_type names loc cls.cls_typesharp_id;\n Env.register_uid cls.cls_decl.cty_uid loc;\n let map f id acc = f acc id cls.cls_decl.cty_uid in\n map Shape.Map.add_class cls.cls_id acc\n |> map Shape.Map.add_class_type cls.cls_ty_id\n |> map Shape.Map.add_type cls.cls_obj_id\n |> map Shape.Map.add_type cls.cls_typesharp_id\n ) shape_map classes\n in\n Tstr_class\n (List.map (fun cls ->\n (cls.Typeclass.cls_info,\n cls.Typeclass.cls_pub_methods)) classes),\n List.flatten\n (map_rec\n (fun rs cls ->\n let open Typeclass in\n [Sig_class(cls.cls_id, cls.cls_decl, rs, Exported);\n Sig_class_type(cls.cls_ty_id, cls.cls_ty_decl, rs, Exported);\n Sig_type(cls.cls_obj_id, cls.cls_obj_abbr, rs, Exported);\n Sig_type(cls.cls_typesharp_id, cls.cls_abbr, rs, Exported)])\n classes []),\n shape_map,\n new_env\n | Pstr_class_type cl ->\n let (classes, new_env) = Typeclass.class_type_declarations env cl in\n let shape_map = List.fold_left (fun acc decl ->\n let open Typeclass in\n let loc = decl.clsty_id_loc.Location.loc in\n Signature_names.check_class_type names loc decl.clsty_ty_id;\n Signature_names.check_type names loc decl.clsty_obj_id;\n Signature_names.check_type names loc decl.clsty_typesharp_id;\n Env.register_uid decl.clsty_ty_decl.clty_uid loc;\n let map f id acc = f acc id decl.clsty_ty_decl.clty_uid in\n map Shape.Map.add_class_type decl.clsty_ty_id acc\n |> map Shape.Map.add_type decl.clsty_obj_id\n |> map Shape.Map.add_type decl.clsty_typesharp_id\n ) shape_map classes\n in\n Tstr_class_type\n (List.map (fun cl ->\n (cl.Typeclass.clsty_ty_id,\n cl.Typeclass.clsty_id_loc,\n cl.Typeclass.clsty_info)) classes),\n List.flatten\n (map_rec\n (fun rs decl ->\n let open Typeclass in\n [Sig_class_type(decl.clsty_ty_id, decl.clsty_ty_decl, rs,\n Exported);\n Sig_type(decl.clsty_obj_id, decl.clsty_obj_abbr, rs, Exported);\n Sig_type(decl.clsty_typesharp_id, decl.clsty_abbr, rs,\n Exported)\n ])\n classes []),\n shape_map,\n new_env\n | Pstr_include sincl ->\n let smodl = sincl.pincl_mod in\n let modl, modl_shape =\n Builtin_attributes.warning_scope sincl.pincl_attributes\n (fun () -> type_module true funct_body None env smodl)\n in\n let scope = Ctype.create_scope () in\n (* Rename all identifiers bound by this signature to avoid clashes *)\n let sg, shape, new_env =\n Env.enter_signature_and_shape ~scope ~parent_shape:shape_map\n modl_shape (extract_sig_open env smodl.pmod_loc modl.mod_type) env\n in\n Signature_group.iter (Signature_names.check_sig_item names loc) sg;\n let incl =\n { incl_mod = modl;\n incl_type = sg;\n incl_attributes = sincl.pincl_attributes;\n incl_loc = sincl.pincl_loc;\n }\n in\n Tstr_include incl, sg, shape, new_env\n | Pstr_extension (ext, _attrs) ->\n raise (Error_forward (Builtin_attributes.error_of_extension ext))\n | Pstr_attribute x ->\n Builtin_attributes.warning_attribute x;\n Tstr_attribute x, [], shape_map, env\n in\n let rec type_struct env shape_map sstr =\n match sstr with\n | [] -> ([], [], shape_map, env)\n | pstr :: srem ->\n let previous_saved_types = Cmt_format.get_saved_types () in\n let desc, sg, shape_map, new_env = type_str_item env shape_map pstr in\n let str = { str_desc = desc; str_loc = pstr.pstr_loc; str_env = env } in\n Cmt_format.set_saved_types (Cmt_format.Partial_structure_item str\n :: previous_saved_types);\n let (str_rem, sig_rem, shape_map, final_env) =\n type_struct new_env shape_map srem\n in\n (str :: str_rem, sg @ sig_rem, shape_map, final_env)\n in\n let previous_saved_types = Cmt_format.get_saved_types () in\n let run () =\n let (items, sg, shape_map, final_env) =\n type_struct env Shape.Map.empty sstr\n in\n let str = { str_items = items; str_type = sg; str_final_env = final_env } in\n Cmt_format.set_saved_types\n (Cmt_format.Partial_structure str :: previous_saved_types);\n str, sg, names, Shape.str shape_map, final_env\n in\n if toplevel then run ()\n else Builtin_attributes.warning_scope [] run\n\nlet type_toplevel_phrase env s =\n Env.reset_required_globals ();\n type_structure ~toplevel:true false None env s\n\nlet type_module_alias = type_module ~alias:true true false None\nlet type_module = type_module true false None\nlet type_structure = type_structure false None\n\n(* Normalize types in a signature *)\n\nlet rec normalize_modtype = function\n Mty_ident _\n | Mty_alias _ -> ()\n | Mty_signature sg -> normalize_signature sg\n | Mty_functor(_param, body) -> normalize_modtype body\n\nand normalize_signature sg = List.iter normalize_signature_item sg\n\nand normalize_signature_item = function\n Sig_value(_id, desc, _) -> Ctype.normalize_type desc.val_type\n | Sig_module(_id, _, md, _, _) -> normalize_modtype md.md_type\n | _ -> ()\n\n(* Extract the module type of a module expression *)\n\nlet type_module_type_of env smod =\n let remove_aliases = has_remove_aliases_attribute smod.pmod_attributes in\n let tmty =\n match smod.pmod_desc with\n | Pmod_ident lid -> (* turn off strengthening in this case *)\n let path, md = Env.lookup_module ~loc:smod.pmod_loc lid.txt env in\n { mod_desc = Tmod_ident (path, lid);\n mod_type = md.md_type;\n mod_env = env;\n mod_attributes = smod.pmod_attributes;\n mod_loc = smod.pmod_loc }\n | _ ->\n let me, _shape = type_module env smod in\n me\n in\n let mty = Mtype.scrape_for_type_of ~remove_aliases env tmty.mod_type in\n (* PR#5036: must not contain non-generalized type variables *)\n if nongen_modtype env mty then\n raise(Error(smod.pmod_loc, env, Non_generalizable_module mty));\n tmty, mty\n\n(* For Typecore *)\n\n(* Graft a longident onto a path *)\nlet rec extend_path path =\n fun lid ->\n match lid with\n | Lident name -> Pdot(path, name)\n | Ldot(m, name) -> Pdot(extend_path path m, name)\n | Lapply _ -> assert false\n\n(* Lookup a type's longident within a signature *)\nlet lookup_type_in_sig sg =\n let types, modules =\n List.fold_left\n (fun acc item ->\n match item with\n | Sig_type(id, _, _, _) ->\n let types, modules = acc in\n let types = String.Map.add (Ident.name id) id types in\n types, modules\n | Sig_module(id, _, _, _, _) ->\n let types, modules = acc in\n let modules = String.Map.add (Ident.name id) id modules in\n types, modules\n | _ -> acc)\n (String.Map.empty, String.Map.empty) sg\n in\n let rec module_path = function\n | Lident name -> Pident (String.Map.find name modules)\n | Ldot(m, name) -> Pdot(module_path m, name)\n | Lapply _ -> assert false\n in\n fun lid ->\n match lid with\n | Lident name -> Pident (String.Map.find name types)\n | Ldot(m, name) -> Pdot(module_path m, name)\n | Lapply _ -> assert false\n\nlet type_package env m p fl =\n (* Same as Pexp_letmodule *)\n (* remember original level *)\n Ctype.begin_def ();\n let context = Typetexp.narrow () in\n let modl, _mod_shape = type_module env m in\n let scope = Ctype.create_scope () in\n Typetexp.widen context;\n let fl', env =\n match fl with\n | [] -> [], env\n | fl ->\n let type_path, env =\n match modl.mod_desc with\n | Tmod_ident (mp,_)\n | Tmod_constraint\n ({mod_desc=Tmod_ident (mp,_)}, _, Tmodtype_implicit, _) ->\n (* We special case these because interactions between\n strengthening of module types and packages can cause\n spurious escape errors. See examples from PR#6982 in the\n testsuite. This can be removed when such issues are\n fixed. *)\n extend_path mp, env\n | _ ->\n let sg = extract_sig_open env modl.mod_loc modl.mod_type in\n let sg, env = Env.enter_signature ~scope sg env in\n lookup_type_in_sig sg, env\n in\n let fl' =\n List.fold_right\n (fun (lid, _t) fl ->\n match type_path lid with\n | exception Not_found -> fl\n | path -> begin\n match Env.find_type path env with\n | exception Not_found -> fl\n | decl ->\n if decl.type_arity > 0 then begin\n fl\n end else begin\n let t = Btype.newgenty (Tconstr (path,[],ref Mnil)) in\n (lid, t) :: fl\n end\n end)\n fl []\n in\n fl', env\n in\n (* go back to original level *)\n Ctype.end_def ();\n let mty =\n if fl = [] then (Mty_ident p)\n else modtype_of_package env modl.mod_loc p fl'\n in\n List.iter\n (fun (n, ty) ->\n try Ctype.unify env ty (Ctype.newvar ())\n with Ctype.Unify _ ->\n raise (Error(modl.mod_loc, env, Scoping_pack (n,ty))))\n fl';\n let modl = wrap_constraint env true modl mty Tmodtype_implicit in\n modl, fl'\n\n(* Fill in the forward declarations *)\n\nlet type_open_decl ?used_slot env od =\n type_open_decl ?used_slot ?toplevel:None false (Signature_names.create ()) env\n od\n\nlet type_open_descr ?used_slot env od =\n type_open_descr ?used_slot ?toplevel:None env od\n\nlet () =\n Typecore.type_module := type_module_alias;\n Typetexp.transl_modtype_longident := transl_modtype_longident;\n Typetexp.transl_modtype := transl_modtype;\n Typecore.type_open := type_open_ ?toplevel:None;\n Typecore.type_open_decl := type_open_decl;\n Typecore.type_package := type_package;\n Typeclass.type_open_descr := type_open_descr;\n type_module_type_of_fwd := type_module_type_of\n\n\n(* Typecheck an implementation file *)\n\nlet gen_annot outputprefix sourcefile annots =\n Cmt2annot.gen_annot (Some (outputprefix ^ \".annot\"))\n ~sourcefile:(Some sourcefile) ~use_summaries:false annots\n\nlet type_implementation sourcefile outputprefix modulename initial_env ast =\n Cmt_format.clear ();\n Misc.try_finally (fun () ->\n Typecore.reset_delayed_checks ();\n Env.reset_required_globals ();\n if !Clflags.print_types then (* #7656 *)\n ignore @@ Warnings.parse_options false \"-32-34-37-38-60\";\n let (str, sg, names, shape, finalenv) =\n type_structure initial_env ast in\n let shape =\n Shape.set_uid_if_none shape\n (Uid.of_compilation_unit_id (Ident.create_persistent modulename))\n in\n let simple_sg = Signature_names.simplify finalenv names sg in\n if !Clflags.print_types then begin\n Typecore.force_delayed_checks ();\n let shape = Shape.local_reduce shape in\n Printtyp.wrap_printing_env ~error:false initial_env\n (fun () -> fprintf std_formatter \"%a@.\"\n (Printtyp.printed_signature sourcefile) simple_sg\n );\n gen_annot outputprefix sourcefile (Cmt_format.Implementation str);\n { structure = str;\n coercion = Tcoerce_none;\n shape;\n signature = simple_sg\n } (* result is ignored by Compile.implementation *)\n end else begin\n let sourceintf =\n Filename.remove_extension sourcefile ^ !Config.interface_suffix in\n if Sys.file_exists sourceintf then begin\n let intf_file =\n try\n Load_path.find_uncap (modulename ^ \".cmi\")\n with Not_found ->\n raise(Error(Location.in_file sourcefile, Env.empty,\n Interface_not_compiled sourceintf)) in\n let dclsig = Env.read_signature modulename intf_file in\n let coercion, shape =\n Includemod.compunit initial_env ~mark:Mark_positive\n sourcefile sg intf_file dclsig shape\n in\n Typecore.force_delayed_checks ();\n (* It is important to run these checks after the inclusion test above,\n so that value declarations which are not used internally but\n exported are not reported as being unused. *)\n let shape = Shape.local_reduce shape in\n let annots = Cmt_format.Implementation str in\n Cmt_format.save_cmt (outputprefix ^ \".cmt\") modulename\n annots (Some sourcefile) initial_env None (Some shape);\n gen_annot outputprefix sourcefile annots;\n { structure = str;\n coercion;\n shape;\n signature = dclsig\n }\n end else begin\n Location.prerr_warning (Location.in_file sourcefile)\n Warnings.Missing_mli;\n let coercion, shape =\n Includemod.compunit initial_env ~mark:Mark_positive\n sourcefile sg \"(inferred signature)\" simple_sg shape\n in\n check_nongen_signature finalenv simple_sg;\n normalize_signature simple_sg;\n Typecore.force_delayed_checks ();\n (* See comment above. Here the target signature contains all\n the value being exported. We can still capture unused\n declarations like \"let x = true;; let x = 1;;\", because in this\n case, the inferred signature contains only the last declaration. *)\n let shape = Shape.local_reduce shape in\n if not !Clflags.dont_write_files then begin\n let alerts = Builtin_attributes.alerts_of_str ast in\n let cmi =\n Env.save_signature ~alerts\n simple_sg modulename (outputprefix ^ \".cmi\")\n in\n let annots = Cmt_format.Implementation str in\n Cmt_format.save_cmt (outputprefix ^ \".cmt\") modulename\n annots (Some sourcefile) initial_env (Some cmi) (Some shape);\n gen_annot outputprefix sourcefile annots\n end;\n { structure = str;\n coercion;\n shape;\n signature = simple_sg\n }\n end\n end\n )\n ~exceptionally:(fun () ->\n let annots =\n Cmt_format.Partial_implementation\n (Array.of_list (Cmt_format.get_saved_types ()))\n in\n Cmt_format.save_cmt (outputprefix ^ \".cmt\") modulename\n annots (Some sourcefile) initial_env None None;\n gen_annot outputprefix sourcefile annots\n )\n\nlet save_signature modname tsg outputprefix source_file initial_env cmi =\n Cmt_format.save_cmt (outputprefix ^ \".cmti\") modname\n (Cmt_format.Interface tsg) (Some source_file) initial_env (Some cmi) None\n\nlet type_interface env ast =\n transl_signature env ast\n\n(* \"Packaging\" of several compilation units into one unit\n having them as sub-modules. *)\n\nlet package_signatures units =\n let units_with_ids =\n List.map\n (fun (name, sg) ->\n let oldid = Ident.create_persistent name in\n let newid = Ident.create_local name in\n (oldid, newid, sg))\n units\n in\n let subst =\n List.fold_left\n (fun acc (oldid, newid, _) ->\n Subst.add_module oldid (Pident newid) acc)\n Subst.identity units_with_ids\n in\n List.map\n (fun (_, newid, sg) ->\n (* This signature won't be used for anything, it'll just be saved in a cmi\n and cmt. *)\n let sg = Subst.signature Make_local subst sg in\n let md =\n { md_type=Mty_signature sg;\n md_attributes=[];\n md_loc=Location.none;\n md_uid = Uid.mk ~current_unit:(Env.get_unit_name ());\n }\n in\n Sig_module(newid, Mp_present, md, Trec_not, Exported))\n units_with_ids\n\nlet package_units initial_env objfiles cmifile modulename =\n (* Read the signatures of the units *)\n let units =\n List.map\n (fun f ->\n let pref = chop_extensions f in\n let modname = String.capitalize_ascii(Filename.basename pref) in\n let sg = Env.read_signature modname (pref ^ \".cmi\") in\n if Filename.check_suffix f \".cmi\" &&\n not(Mtype.no_code_needed_sig Env.initial_safe_string sg)\n then raise(Error(Location.none, Env.empty,\n Implementation_is_required f));\n (modname, Env.read_signature modname (pref ^ \".cmi\")))\n objfiles in\n (* Compute signature of packaged unit *)\n Ident.reinit();\n let sg = package_signatures units in\n (* Compute the shape of the package *)\n let prefix = Filename.remove_extension cmifile in\n let pack_uid = Uid.of_compilation_unit_id (Ident.create_persistent prefix) in\n let shape =\n List.fold_left (fun map (name, _sg) ->\n let id = Ident.create_persistent name in\n Shape.Map.add_module map id (Shape.for_persistent_unit name)\n ) Shape.Map.empty units\n |> Shape.str ~uid:pack_uid\n in\n (* See if explicit interface is provided *)\n let mlifile = prefix ^ !Config.interface_suffix in\n if Sys.file_exists mlifile then begin\n if not (Sys.file_exists cmifile) then begin\n raise(Error(Location.in_file mlifile, Env.empty,\n Interface_not_compiled mlifile))\n end;\n let dclsig = Env.read_signature modulename cmifile in\n let cc, _shape =\n Includemod.compunit initial_env ~mark:Mark_both\n \"(obtained by packing)\" sg mlifile dclsig shape\n in\n Cmt_format.save_cmt (prefix ^ \".cmt\") modulename\n (Cmt_format.Packed (sg, objfiles)) None initial_env None (Some shape);\n cc\n end else begin\n (* Determine imports *)\n let unit_names = List.map fst units in\n let imports =\n List.filter\n (fun (name, _crc) -> not (List.mem name unit_names))\n (Env.imports()) in\n (* Write packaged signature *)\n if not !Clflags.dont_write_files then begin\n let cmi =\n Env.save_signature_with_imports ~alerts:Misc.Stdlib.String.Map.empty\n sg modulename\n (prefix ^ \".cmi\") imports\n in\n Cmt_format.save_cmt (prefix ^ \".cmt\") modulename\n (Cmt_format.Packed (cmi.Cmi_format.cmi_sign, objfiles)) None initial_env\n (Some cmi) (Some shape);\n end;\n Tcoerce_none\n end\n\n\n(* Error report *)\n\n\nopen Printtyp\n\nlet report_error ~loc _env = function\n Cannot_apply mty ->\n Location.errorf ~loc\n \"@[This module is not a functor; it has type@ %a@]\" modtype mty\n | Not_included errs ->\n let main = Includemod_errorprinter.err_msgs errs in\n Location.errorf ~loc \"@[Signature mismatch:@ %t@]\" main\n | Cannot_eliminate_dependency mty ->\n Location.errorf ~loc\n \"@[This functor has type@ %a@ \\\n The parameter cannot be eliminated in the result type.@ \\\n Please bind the argument to a module identifier.@]\" modtype mty\n | Signature_expected ->\n Location.errorf ~loc \"This module type is not a signature\"\n | Structure_expected mty ->\n Location.errorf ~loc\n \"@[This module is not a structure; it has type@ %a\" modtype mty\n | With_no_component lid ->\n Location.errorf ~loc\n \"@[The signature constrained by `with' has no component named %a@]\"\n longident lid\n | With_mismatch(lid, explanation) ->\n let main = Includemod_errorprinter.err_msgs explanation in\n Location.errorf ~loc\n \"@[\\\n @[In this `with' constraint, the new definition of %a@ \\\n does not match its original definition@ \\\n in the constrained signature:@]@ \\\n %t@]\"\n longident lid main\n | With_makes_applicative_functor_ill_typed(lid, path, explanation) ->\n let main = Includemod_errorprinter.err_msgs explanation in\n Location.errorf ~loc\n \"@[\\\n @[This `with' constraint on %a makes the applicative functor @ \\\n type %s ill-typed in the constrained signature:@]@ \\\n %t@]\"\n longident lid (Path.name path) main\n | With_changes_module_alias(lid, id, path) ->\n Location.errorf ~loc\n \"@[\\\n @[This `with' constraint on %a changes %s, which is aliased @ \\\n in the constrained signature (as %s)@].@]\"\n longident lid (Path.name path) (Ident.name id)\n | With_cannot_remove_constrained_type ->\n Location.errorf ~loc\n \"@[Destructive substitutions are not supported for constrained @ \\\n types (other than when replacing a type constructor with @ \\\n a type constructor with the same arguments).@]\"\n | With_cannot_remove_packed_modtype (p,mty) ->\n Location.errorf ~loc\n \"This `with' constraint@ %s := %a@ makes a packed module ill-formed.\"\n (Path.name p) Printtyp.modtype mty\n | Repeated_name(kind, name) ->\n Location.errorf ~loc\n \"@[Multiple definition of the %s name %s.@ \\\n Names must be unique in a given structure or signature.@]\"\n (Sig_component_kind.to_string kind) name\n | Non_generalizable typ ->\n Location.errorf ~loc\n \"@[The type of this expression,@ %a,@ \\\n contains type variables that cannot be generalized@]\" type_scheme typ\n | Non_generalizable_module mty ->\n Location.errorf ~loc\n \"@[The type of this module,@ %a,@ \\\n contains type variables that cannot be generalized@]\" modtype mty\n | Implementation_is_required intf_name ->\n Location.errorf ~loc\n \"@[The interface %a@ declares values, not just types.@ \\\n An implementation must be provided.@]\"\n Location.print_filename intf_name\n | Interface_not_compiled intf_name ->\n Location.errorf ~loc\n \"@[Could not find the .cmi file for interface@ %a.@]\"\n Location.print_filename intf_name\n | Not_allowed_in_functor_body ->\n Location.errorf ~loc\n \"@[This expression creates fresh types.@ %s@]\"\n \"It is not allowed inside applicative functors.\"\n | Not_a_packed_module ty ->\n Location.errorf ~loc\n \"This expression is not a packed module. It has type@ %a\"\n type_expr ty\n | Incomplete_packed_module ty ->\n Location.errorf ~loc\n \"The type of this packed module contains variables:@ %a\"\n type_expr ty\n | Scoping_pack (lid, ty) ->\n Location.errorf ~loc\n \"The type %a in this module cannot be exported.@ \\\n Its type contains local dependencies:@ %a\" longident lid type_expr ty\n | Recursive_module_require_explicit_type ->\n Location.errorf ~loc \"Recursive modules require an explicit module type.\"\n | Apply_generative ->\n Location.errorf ~loc\n \"This is a generative functor. It can only be applied to ()\"\n | Cannot_scrape_alias p ->\n Location.errorf ~loc\n \"This is an alias for module %a, which is missing\"\n path p\n | Cannot_scrape_package_type p ->\n Location.errorf ~loc\n \"The type of this packed module refers to %a, which is missing\"\n path p\n | Badly_formed_signature (context, err) ->\n Location.errorf ~loc \"@[In %s:@ %a@]\" context Typedecl.report_error err\n | Cannot_hide_id Illegal_shadowing\n { shadowed_item_kind; shadowed_item_id; shadowed_item_loc;\n shadower_id; user_id; user_kind; user_loc } ->\n let shadowed_item_kind= Sig_component_kind.to_string shadowed_item_kind in\n Location.errorf ~loc\n \"@[Illegal shadowing of included %s %a by %a@ \\\n %a:@;<1 2>%s %a came from this include@ \\\n %a:@;<1 2>The %s %s has no valid type if %a is shadowed@]\"\n shadowed_item_kind Ident.print shadowed_item_id Ident.print shadower_id\n Location.print_loc shadowed_item_loc\n (String.capitalize_ascii shadowed_item_kind)\n Ident.print shadowed_item_id\n Location.print_loc user_loc\n (Sig_component_kind.to_string user_kind) (Ident.name user_id)\n Ident.print shadowed_item_id\n | Cannot_hide_id Appears_in_signature\n { opened_item_kind; opened_item_id; user_id; user_kind; user_loc } ->\n let opened_item_kind= Sig_component_kind.to_string opened_item_kind in\n Location.errorf ~loc\n \"@[The %s %a introduced by this open appears in the signature@ \\\n %a:@;<1 2>The %s %s has no valid type if %a is hidden@]\"\n opened_item_kind Ident.print opened_item_id\n Location.print_loc user_loc\n (Sig_component_kind.to_string user_kind) (Ident.name user_id)\n Ident.print opened_item_id\n | Invalid_type_subst_rhs ->\n Location.errorf ~loc \"Only type synonyms are allowed on the right of :=\"\n | Unpackable_local_modtype_subst p ->\n Location.errorf ~loc\n \"The module type@ %s@ is not a valid type for a packed module:@ \\\n it is defined as a local substitution for a non-path module type.\"\n (Path.name p)\n\nlet report_error env ~loc err =\n Printtyp.wrap_printing_env ~error:true env\n (fun () -> report_error env ~loc err)\n\nlet () =\n Location.register_error_of_exn\n (function\n | Error (loc, env, err) ->\n Some (report_error ~loc env err)\n | Error_forward err ->\n Some err\n | _ ->\n None\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(* Translation from typed abstract syntax to lambda terms,\n for the core language *)\n\nopen Misc\nopen Asttypes\nopen Primitive\nopen Types\nopen Typedtree\nopen Typeopt\nopen Lambda\nopen Debuginfo.Scoped_location\n\ntype error =\n Free_super_var\n | Unreachable_reached\n\nexception Error of Location.t * error\n\nlet use_dup_for_constant_arrays_bigger_than = 4\n\n(* Forward declaration -- to be filled in by Translmod.transl_module *)\nlet transl_module =\n ref((fun ~scopes:_ _cc _rootpath _modl -> assert false) :\n scopes:scopes -> module_coercion -> Path.t option ->\n module_expr -> lambda)\n\nlet transl_object =\n ref (fun ~scopes:_ _id _s _cl -> assert false :\n scopes:scopes -> Ident.t -> string list -> class_expr -> lambda)\n\n(* Compile an exception/extension definition *)\n\nlet prim_fresh_oo_id =\n Pccall (Primitive.simple ~name:\"caml_fresh_oo_id\" ~arity:1 ~alloc:false)\n\nlet transl_extension_constructor ~scopes env path ext =\n let path =\n Printtyp.wrap_printing_env env ~error:true (fun () ->\n Option.map (Printtyp.rewrite_double_underscore_paths env) path)\n in\n let name =\n match path, !Clflags.for_package with\n None, _ -> Ident.name ext.ext_id\n | Some p, None -> Path.name p\n | Some p, Some pack -> Printf.sprintf \"%s.%s\" pack (Path.name p)\n in\n let loc = of_location ~scopes ext.ext_loc in\n match ext.ext_kind with\n Text_decl _ ->\n Lprim (Pmakeblock (Obj.object_tag, Immutable, None),\n [Lconst (Const_base (Const_string (name, ext.ext_loc, None)));\n Lprim (prim_fresh_oo_id, [Lconst (const_int 0)], loc)],\n loc)\n | Text_rebind(path, _lid) ->\n transl_extension_path loc env path\n\n(* To propagate structured constants *)\n\nexception Not_constant\n\nlet extract_constant = function\n Lconst sc -> sc\n | _ -> raise Not_constant\n\nlet extract_float = function\n Const_base(Const_float f) -> f\n | _ -> fatal_error \"Translcore.extract_float\"\n\n(* Push the default values under the functional abstractions *)\n(* Also push bindings of module patterns, since this sound *)\n\ntype binding =\n | Bind_value of value_binding list\n | Bind_module of Ident.t * string option loc * module_presence * module_expr\n\nlet wrap_bindings bindings exp =\n List.fold_left\n (fun exp binds ->\n {exp with exp_desc =\n match binds with\n | Bind_value binds -> Texp_let(Nonrecursive, binds, exp)\n | Bind_module (id, name, pres, mexpr) ->\n Texp_letmodule (Some id, name, pres, mexpr, exp)})\n exp bindings\n\nlet rec trivial_pat pat =\n match pat.pat_desc with\n Tpat_var _\n | Tpat_any -> true\n | Tpat_construct (_, cd, [], _) ->\n not cd.cstr_generalized && cd.cstr_consts = 1 && cd.cstr_nonconsts = 0\n | Tpat_tuple patl ->\n List.for_all trivial_pat patl\n | _ -> false\n\nlet rec push_defaults loc bindings use_lhs cases partial =\n match cases with\n [{c_lhs=pat; c_guard=None;\n c_rhs={exp_desc = Texp_function { arg_label; param; cases; partial; } }\n as exp}] when bindings = [] || trivial_pat pat ->\n let cases = push_defaults exp.exp_loc bindings false cases partial in\n [{c_lhs=pat; c_guard=None;\n c_rhs={exp with exp_desc = Texp_function { arg_label; param; cases;\n partial; }}}]\n | [{c_lhs=pat; c_guard=None;\n c_rhs={exp_attributes=[{Parsetree.attr_name = {txt=\"#default\"};_}];\n exp_desc = Texp_let\n (Nonrecursive, binds,\n ({exp_desc = Texp_function _} as e2))}}] ->\n push_defaults loc (Bind_value binds :: bindings) true\n [{c_lhs=pat;c_guard=None;c_rhs=e2}]\n partial\n | [{c_lhs=pat; c_guard=None;\n c_rhs={exp_attributes=[{Parsetree.attr_name = {txt=\"#modulepat\"};_}];\n exp_desc = Texp_letmodule\n (Some id, name, pres, mexpr,\n ({exp_desc = Texp_function _} as e2))}}] ->\n push_defaults loc (Bind_module (id, name, pres, mexpr) :: bindings) true\n [{c_lhs=pat;c_guard=None;c_rhs=e2}]\n partial\n | [{c_lhs=pat; c_guard=None; c_rhs=exp} as case]\n when use_lhs || trivial_pat pat && exp.exp_desc <> Texp_unreachable ->\n [{case with c_rhs = wrap_bindings bindings exp}]\n | {c_lhs=pat; c_rhs=exp; c_guard=_} :: _ when bindings <> [] ->\n let param = Typecore.name_cases \"param\" cases in\n let desc =\n {val_type = pat.pat_type; val_kind = Val_reg;\n val_attributes = []; Types.val_loc = Location.none;\n val_uid = Types.Uid.internal_not_actually_unique; }\n in\n let env = Env.add_value param desc exp.exp_env in\n let name = Ident.name param in\n let exp =\n let cases =\n let pure_case ({c_lhs; _} as case) =\n {case with c_lhs = as_computation_pattern c_lhs} in\n List.map pure_case cases in\n { exp with exp_loc = loc; exp_env = env; exp_desc =\n Texp_match\n ({exp with exp_type = pat.pat_type; exp_env = env; exp_desc =\n Texp_ident\n (Path.Pident param, mknoloc (Longident.Lident name), desc)},\n cases, partial) }\n in\n [{c_lhs = {pat with pat_desc = Tpat_var (param, mknoloc name)};\n c_guard = None; c_rhs= wrap_bindings bindings exp}]\n | _ ->\n cases\n\nlet push_defaults loc = push_defaults loc [] false\n\n(* Insertion of debugging events *)\n\nlet event_before ~scopes exp lam =\n Translprim.event_before (of_location ~scopes exp.exp_loc) exp lam\n\nlet event_after ~scopes exp lam =\n Translprim.event_after (of_location ~scopes exp.exp_loc) exp lam\n\nlet event_function ~scopes exp lam =\n if !Clflags.debug && not !Clflags.native_code then\n let repr = Some (ref 0) in\n let (info, body) = lam repr in\n (info,\n Levent(body, {lev_loc = of_location ~scopes exp.exp_loc;\n lev_kind = Lev_function;\n lev_repr = repr;\n lev_env = exp.exp_env}))\n else\n lam None\n\n(* Assertions *)\n\nlet assert_failed ~scopes exp =\n let slot =\n transl_extension_path Loc_unknown\n Env.initial_safe_string Predef.path_assert_failure\n in\n let loc = exp.exp_loc in\n let (fname, line, char) =\n Location.get_pos_info loc.Location.loc_start\n in\n let loc = of_location ~scopes exp.exp_loc in\n Lprim(Praise Raise_regular, [event_after ~scopes exp\n (Lprim(Pmakeblock(0, Immutable, None),\n [slot;\n Lconst(Const_block(0,\n [Const_base(Const_string (fname, exp.exp_loc, None));\n Const_base(Const_int line);\n Const_base(Const_int char)]))], loc))], loc)\n;;\n\nlet rec cut n l =\n if n = 0 then ([],l) else\n match l with [] -> failwith \"Translcore.cut\"\n | a::l -> let (l1,l2) = cut (n-1) l in (a::l1,l2)\n\n(* Translation of expressions *)\n\nlet rec iter_exn_names f pat =\n match pat.pat_desc with\n | Tpat_var (id, _) -> f id\n | Tpat_alias (p, id, _) ->\n f id;\n iter_exn_names f p\n | _ -> ()\n\nlet transl_ident loc env ty path desc =\n match desc.val_kind with\n | Val_prim p ->\n Translprim.transl_primitive loc p env ty (Some path)\n | Val_anc _ ->\n raise(Error(to_location loc, Free_super_var))\n | Val_reg | Val_self _ ->\n transl_value_path loc env path\n | _ -> fatal_error \"Translcore.transl_exp: bad Texp_ident\"\n\nlet rec transl_exp ~scopes e =\n transl_exp1 ~scopes ~in_new_scope:false e\n\n(* ~in_new_scope tracks whether we just opened a new scope.\n\n We go to some trouble to avoid introducing many new anonymous function\n scopes, as `let f a b = ...` is desugared to several Pexp_fun.\n*)\nand transl_exp1 ~scopes ~in_new_scope e =\n List.iter (Translattribute.check_attribute e) e.exp_attributes;\n let eval_once =\n (* Whether classes for immediate objects must be cached *)\n match e.exp_desc with\n Texp_function _ | Texp_for _ | Texp_while _ -> false\n | _ -> true\n in\n if eval_once then transl_exp0 ~scopes ~in_new_scope e else\n Translobj.oo_wrap e.exp_env true (transl_exp0 ~scopes ~in_new_scope) e\n\nand transl_exp0 ~in_new_scope ~scopes e =\n match e.exp_desc with\n | Texp_ident(path, _, desc) ->\n transl_ident (of_location ~scopes e.exp_loc)\n e.exp_env e.exp_type path desc\n | Texp_constant cst ->\n Lconst(Const_base cst)\n | Texp_let(rec_flag, pat_expr_list, body) ->\n transl_let ~scopes rec_flag pat_expr_list\n (event_before ~scopes body (transl_exp ~scopes body))\n | Texp_function { arg_label = _; param; cases; partial; } ->\n let scopes =\n if in_new_scope then scopes\n else enter_anonymous_function ~scopes\n in\n transl_function ~scopes e param cases partial\n | Texp_apply({ exp_desc = Texp_ident(path, _, {val_kind = Val_prim p});\n exp_type = prim_type } as funct, oargs)\n when List.length oargs >= p.prim_arity\n && List.for_all (fun (_, arg) -> arg <> None) oargs ->\n let argl, extra_args = cut p.prim_arity oargs in\n let arg_exps =\n List.map (function _, Some x -> x | _ -> assert false) argl\n in\n let args = transl_list ~scopes arg_exps in\n let prim_exp = if extra_args = [] then Some e else None in\n let lam =\n Translprim.transl_primitive_application\n (of_location ~scopes e.exp_loc) p e.exp_env prim_type path\n prim_exp args arg_exps\n in\n if extra_args = [] then lam\n else begin\n let tailcall, funct =\n Translattribute.get_tailcall_attribute funct\n in\n let inlined, funct =\n Translattribute.get_and_remove_inlined_attribute funct\n in\n let specialised, funct =\n Translattribute.get_and_remove_specialised_attribute funct\n in\n let e = { e with exp_desc = Texp_apply(funct, oargs) } in\n event_after ~scopes e\n (transl_apply ~scopes ~tailcall ~inlined ~specialised\n lam extra_args (of_location ~scopes e.exp_loc))\n end\n | Texp_apply(funct, oargs) ->\n let tailcall, funct =\n Translattribute.get_tailcall_attribute funct\n in\n let inlined, funct =\n Translattribute.get_and_remove_inlined_attribute funct\n in\n let specialised, funct =\n Translattribute.get_and_remove_specialised_attribute funct\n in\n let e = { e with exp_desc = Texp_apply(funct, oargs) } in\n event_after ~scopes e\n (transl_apply ~scopes ~tailcall ~inlined ~specialised\n (transl_exp ~scopes funct) oargs (of_location ~scopes e.exp_loc))\n | Texp_match(arg, pat_expr_list, partial) ->\n transl_match ~scopes e arg pat_expr_list partial\n | Texp_try(body, pat_expr_list) ->\n let id = Typecore.name_cases \"exn\" pat_expr_list in\n Ltrywith(transl_exp ~scopes body, id,\n Matching.for_trywith ~scopes e.exp_loc (Lvar id)\n (transl_cases_try ~scopes pat_expr_list))\n | Texp_tuple el ->\n let ll, shape = transl_list_with_shape ~scopes el in\n begin try\n Lconst(Const_block(0, List.map extract_constant ll))\n with Not_constant ->\n Lprim(Pmakeblock(0, Immutable, Some shape), ll,\n (of_location ~scopes e.exp_loc))\n end\n | Texp_construct(_, cstr, args) ->\n let ll, shape = transl_list_with_shape ~scopes args in\n if cstr.cstr_inlined <> None then begin match ll with\n | [x] -> x\n | _ -> assert false\n end else begin match cstr.cstr_tag with\n Cstr_constant n ->\n Lconst(const_int n)\n | Cstr_unboxed ->\n (match ll with [v] -> v | _ -> assert false)\n | Cstr_block n ->\n begin try\n Lconst(Const_block(n, List.map extract_constant ll))\n with Not_constant ->\n Lprim(Pmakeblock(n, Immutable, Some shape), ll,\n of_location ~scopes e.exp_loc)\n end\n | Cstr_extension(path, is_const) ->\n let lam = transl_extension_path\n (of_location ~scopes e.exp_loc) e.exp_env path in\n if is_const then lam\n else\n Lprim(Pmakeblock(0, Immutable, Some (Pgenval :: shape)),\n lam :: ll, of_location ~scopes e.exp_loc)\n end\n | Texp_extension_constructor (_, path) ->\n transl_extension_path (of_location ~scopes e.exp_loc) e.exp_env path\n | Texp_variant(l, arg) ->\n let tag = Btype.hash_variant l in\n begin match arg with\n None -> Lconst(const_int tag)\n | Some arg ->\n let lam = transl_exp ~scopes arg in\n try\n Lconst(Const_block(0, [const_int tag;\n extract_constant lam]))\n with Not_constant ->\n Lprim(Pmakeblock(0, Immutable, None),\n [Lconst(const_int tag); lam],\n of_location ~scopes e.exp_loc)\n end\n | Texp_record {fields; representation; extended_expression} ->\n transl_record ~scopes e.exp_loc e.exp_env\n fields representation extended_expression\n | Texp_field(arg, _, lbl) ->\n let targ = transl_exp ~scopes arg in\n begin match lbl.lbl_repres with\n Record_regular | Record_inlined _ ->\n Lprim (Pfield lbl.lbl_pos, [targ],\n of_location ~scopes e.exp_loc)\n | Record_unboxed _ -> targ\n | Record_float ->\n Lprim (Pfloatfield lbl.lbl_pos, [targ],\n of_location ~scopes e.exp_loc)\n | Record_extension _ ->\n Lprim (Pfield (lbl.lbl_pos + 1), [targ],\n of_location ~scopes e.exp_loc)\n end\n | Texp_setfield(arg, _, lbl, newval) ->\n let access =\n match lbl.lbl_repres with\n Record_regular\n | Record_inlined _ ->\n Psetfield(lbl.lbl_pos, maybe_pointer newval, Assignment)\n | Record_unboxed _ -> assert false\n | Record_float -> Psetfloatfield (lbl.lbl_pos, Assignment)\n | Record_extension _ ->\n Psetfield (lbl.lbl_pos + 1, maybe_pointer newval, Assignment)\n in\n Lprim(access, [transl_exp ~scopes arg; transl_exp ~scopes newval],\n of_location ~scopes e.exp_loc)\n | Texp_array expr_list ->\n let kind = array_kind e in\n let ll = transl_list ~scopes expr_list in\n begin try\n (* For native code the decision as to which compilation strategy to\n use is made later. This enables the Flambda passes to lift certain\n kinds of array definitions to symbols. *)\n (* Deactivate constant optimization if array is small enough *)\n if List.length ll <= use_dup_for_constant_arrays_bigger_than\n then begin\n raise Not_constant\n end;\n begin match List.map extract_constant ll with\n | exception Not_constant when kind = Pfloatarray ->\n (* We cannot currently lift [Pintarray] arrays safely in Flambda\n because [caml_modify] might be called upon them (e.g. from\n code operating on polymorphic arrays, or functions such as\n [caml_array_blit].\n To avoid having different Lambda code for\n bytecode/Closure vs. Flambda, we always generate\n [Pduparray] here, and deal with it in [Bytegen] (or in\n the case of Closure, in [Cmmgen], which already has to\n handle [Pduparray Pmakearray Pfloatarray] in the case\n where the array turned out to be inconstant).\n When not [Pfloatarray], the exception propagates to the handler\n below. *)\n let imm_array =\n Lprim (Pmakearray (kind, Immutable), ll,\n of_location ~scopes e.exp_loc)\n in\n Lprim (Pduparray (kind, Mutable), [imm_array],\n of_location ~scopes e.exp_loc)\n | cl ->\n let imm_array =\n match kind with\n | Paddrarray | Pintarray ->\n Lconst(Const_block(0, cl))\n | Pfloatarray ->\n Lconst(Const_float_array(List.map extract_float cl))\n | Pgenarray ->\n raise Not_constant (* can this really happen? *)\n in\n Lprim (Pduparray (kind, Mutable), [imm_array],\n of_location ~scopes e.exp_loc)\n end\n with Not_constant ->\n Lprim(Pmakearray (kind, Mutable), ll,\n of_location ~scopes e.exp_loc)\n end\n | Texp_ifthenelse(cond, ifso, Some ifnot) ->\n Lifthenelse(transl_exp ~scopes cond,\n event_before ~scopes ifso (transl_exp ~scopes ifso),\n event_before ~scopes ifnot (transl_exp ~scopes ifnot))\n | Texp_ifthenelse(cond, ifso, None) ->\n Lifthenelse(transl_exp ~scopes cond,\n event_before ~scopes ifso (transl_exp ~scopes ifso),\n lambda_unit)\n | Texp_sequence(expr1, expr2) ->\n Lsequence(transl_exp ~scopes expr1,\n event_before ~scopes expr2 (transl_exp ~scopes expr2))\n | Texp_while(cond, body) ->\n Lwhile(transl_exp ~scopes cond,\n event_before ~scopes body (transl_exp ~scopes body))\n | Texp_for(param, _, low, high, dir, body) ->\n Lfor(param, transl_exp ~scopes low, transl_exp ~scopes high, dir,\n event_before ~scopes body (transl_exp ~scopes body))\n | Texp_send(expr, met) ->\n let lam =\n let loc = of_location ~scopes e.exp_loc in\n match met with\n | Tmeth_val id ->\n let obj = transl_exp ~scopes expr in\n Lsend (Self, Lvar id, obj, [], loc)\n | Tmeth_name nm ->\n let obj = transl_exp ~scopes expr in\n let (tag, cache) = Translobj.meth obj nm in\n let kind = if cache = [] then Public else Cached in\n Lsend (kind, tag, obj, cache, loc)\n | Tmeth_ancestor(meth, path_self) ->\n let self = transl_value_path loc e.exp_env path_self in\n Lapply {ap_loc = loc;\n ap_func = Lvar meth;\n ap_args = [self];\n ap_tailcall = Default_tailcall;\n ap_inlined = Default_inline;\n ap_specialised = Default_specialise}\n in\n event_after ~scopes e lam\n | Texp_new (cl, {Location.loc=loc}, _) ->\n let loc = of_location ~scopes loc in\n Lapply{\n ap_loc=loc;\n ap_func=\n Lprim(Pfield 0, [transl_class_path loc e.exp_env cl], loc);\n ap_args=[lambda_unit];\n ap_tailcall=Default_tailcall;\n ap_inlined=Default_inline;\n ap_specialised=Default_specialise;\n }\n | Texp_instvar(path_self, path, _) ->\n let loc = of_location ~scopes e.exp_loc in\n let self = transl_value_path loc e.exp_env path_self in\n let var = transl_value_path loc e.exp_env path in\n Lprim(Pfield_computed, [self; var], loc)\n | Texp_setinstvar(path_self, path, _, expr) ->\n let loc = of_location ~scopes e.exp_loc in\n let self = transl_value_path loc e.exp_env path_self in\n let var = transl_value_path loc e.exp_env path in\n transl_setinstvar ~scopes loc self var expr\n | Texp_override(path_self, modifs) ->\n let loc = of_location ~scopes e.exp_loc in\n let self = transl_value_path loc e.exp_env path_self in\n let cpy = Ident.create_local \"copy\" in\n Llet(Strict, Pgenval, cpy,\n Lapply{\n ap_loc=Loc_unknown;\n ap_func=Translobj.oo_prim \"copy\";\n ap_args=[self];\n ap_tailcall=Default_tailcall;\n ap_inlined=Default_inline;\n ap_specialised=Default_specialise;\n },\n List.fold_right\n (fun (id, _, expr) rem ->\n Lsequence(transl_setinstvar ~scopes Loc_unknown\n (Lvar cpy) (Lvar id) expr, rem))\n modifs\n (Lvar cpy))\n | Texp_letmodule(None, loc, Mp_present, modl, body) ->\n let lam = !transl_module ~scopes Tcoerce_none None modl in\n Lsequence(Lprim(Pignore, [lam], of_location ~scopes loc.loc),\n transl_exp ~scopes body)\n | Texp_letmodule(Some id, loc, Mp_present, modl, body) ->\n let defining_expr =\n let mod_scopes = enter_module_definition ~scopes id in\n Levent (!transl_module ~scopes:mod_scopes Tcoerce_none None modl, {\n lev_loc = of_location ~scopes loc.loc;\n lev_kind = Lev_module_definition id;\n lev_repr = None;\n lev_env = Env.empty;\n })\n in\n Llet(Strict, Pgenval, id, defining_expr, transl_exp ~scopes body)\n | Texp_letmodule(_, _, Mp_absent, _, body) ->\n transl_exp ~scopes body\n | Texp_letexception(cd, body) ->\n Llet(Strict, Pgenval,\n cd.ext_id, transl_extension_constructor ~scopes e.exp_env None cd,\n transl_exp ~scopes body)\n | Texp_pack modl ->\n !transl_module ~scopes Tcoerce_none None modl\n | Texp_assert {exp_desc=Texp_construct(_, {cstr_name=\"false\"}, _)} ->\n assert_failed ~scopes e\n | Texp_assert (cond) ->\n if !Clflags.noassert\n then lambda_unit\n else Lifthenelse (transl_exp ~scopes cond, lambda_unit,\n assert_failed ~scopes e)\n | Texp_lazy e ->\n (* when e needs no computation (constants, identifiers, ...), we\n optimize the translation just as Lazy.lazy_from_val would\n do *)\n begin match Typeopt.classify_lazy_argument e with\n | `Constant_or_function ->\n (* A constant expr (of type <> float if [Config.flat_float_array] is\n true) gets compiled as itself. *)\n transl_exp ~scopes e\n | `Float_that_cannot_be_shortcut ->\n (* We don't need to wrap with Popaque: this forward\n block will never be shortcutted since it points to a float\n and Config.flat_float_array is true. *)\n Lprim(Pmakeblock(Obj.forward_tag, Immutable, None),\n [transl_exp ~scopes e], of_location ~scopes e.exp_loc)\n | `Identifier `Forward_value ->\n (* CR-someday mshinwell: Consider adding a new primitive\n that expresses the construction of forward_tag blocks.\n We need to use [Popaque] here to prevent unsound\n optimisation in Flambda, but the concept of a mutable\n block doesn't really match what is going on here. This\n value may subsequently turn into an immediate... *)\n Lprim (Popaque,\n [Lprim(Pmakeblock(Obj.forward_tag, Immutable, None),\n [transl_exp ~scopes e],\n of_location ~scopes e.exp_loc)],\n of_location ~scopes e.exp_loc)\n | `Identifier `Other ->\n transl_exp ~scopes e\n | `Other ->\n (* other cases compile to a lazy block holding a function *)\n let fn = lfunction ~kind:Curried\n ~params:[Ident.create_local \"param\", Pgenval]\n ~return:Pgenval\n ~attr:default_function_attribute\n ~loc:(of_location ~scopes e.exp_loc)\n ~body:(transl_exp ~scopes e) in\n Lprim(Pmakeblock(Config.lazy_tag, Mutable, None), [fn],\n of_location ~scopes e.exp_loc)\n end\n | Texp_object (cs, meths) ->\n let cty = cs.cstr_type in\n let cl = Ident.create_local \"object\" in\n !transl_object ~scopes cl meths\n { cl_desc = Tcl_structure cs;\n cl_loc = e.exp_loc;\n cl_type = Cty_signature cty;\n cl_env = e.exp_env;\n cl_attributes = [];\n }\n | Texp_letop{let_; ands; param; body; partial} ->\n event_after ~scopes e\n (transl_letop ~scopes e.exp_loc e.exp_env let_ ands param body partial)\n | Texp_unreachable ->\n raise (Error (e.exp_loc, Unreachable_reached))\n | Texp_open (od, e) ->\n let pure = pure_module od.open_expr in\n (* this optimization shouldn't be needed because Simplif would\n actually remove the [Llet] when it's not used.\n But since [scan_used_globals] runs before Simplif, we need to\n do it. *)\n begin match od.open_bound_items with\n | [] when pure = Alias -> transl_exp ~scopes e\n | _ ->\n let oid = Ident.create_local \"open\" in\n let body, _ =\n List.fold_left (fun (body, pos) id ->\n Llet(Alias, Pgenval, id,\n Lprim(Pfield pos, [Lvar oid],\n of_location ~scopes od.open_loc), body),\n pos + 1\n ) (transl_exp ~scopes e, 0)\n (bound_value_identifiers od.open_bound_items)\n in\n Llet(pure, Pgenval, oid,\n !transl_module ~scopes Tcoerce_none None od.open_expr, body)\n end\n\nand pure_module m =\n match m.mod_desc with\n Tmod_ident _ -> Alias\n | Tmod_constraint (m,_,_,_) -> pure_module m\n | _ -> Strict\n\nand transl_list ~scopes expr_list =\n List.map (transl_exp ~scopes) expr_list\n\nand transl_list_with_shape ~scopes expr_list =\n let transl_with_shape e =\n let shape = Typeopt.value_kind e.exp_env e.exp_type in\n transl_exp ~scopes e, shape\n in\n List.split (List.map transl_with_shape expr_list)\n\nand transl_guard ~scopes guard rhs =\n let expr = event_before ~scopes rhs (transl_exp ~scopes rhs) in\n match guard with\n | None -> expr\n | Some cond ->\n event_before ~scopes cond\n (Lifthenelse(transl_exp ~scopes cond, expr, staticfail))\n\nand transl_case ~scopes {c_lhs; c_guard; c_rhs} =\n c_lhs, transl_guard ~scopes c_guard c_rhs\n\nand transl_cases ~scopes cases =\n let cases =\n List.filter (fun c -> c.c_rhs.exp_desc <> Texp_unreachable) cases in\n List.map (transl_case ~scopes) cases\n\nand transl_case_try ~scopes {c_lhs; c_guard; c_rhs} =\n iter_exn_names Translprim.add_exception_ident c_lhs;\n Misc.try_finally\n (fun () -> c_lhs, transl_guard ~scopes c_guard c_rhs)\n ~always:(fun () ->\n iter_exn_names Translprim.remove_exception_ident c_lhs)\n\nand transl_cases_try ~scopes cases =\n let cases =\n List.filter (fun c -> c.c_rhs.exp_desc <> Texp_unreachable) cases in\n List.map (transl_case_try ~scopes) cases\n\nand transl_tupled_cases ~scopes patl_expr_list =\n let patl_expr_list =\n List.filter (fun (_,_,e) -> e.exp_desc <> Texp_unreachable)\n patl_expr_list in\n List.map (fun (patl, guard, expr) -> (patl, transl_guard ~scopes guard expr))\n patl_expr_list\n\nand transl_apply ~scopes\n ?(tailcall=Default_tailcall)\n ?(inlined = Default_inline)\n ?(specialised = Default_specialise)\n lam sargs loc\n =\n let lapply funct args =\n match funct with\n Lsend(k, lmet, lobj, largs, _) ->\n Lsend(k, lmet, lobj, largs @ args, loc)\n | Levent(Lsend(k, lmet, lobj, largs, _), _) ->\n Lsend(k, lmet, lobj, largs @ args, loc)\n | Lapply ap ->\n Lapply {ap with ap_args = ap.ap_args @ args; ap_loc = loc}\n | lexp ->\n Lapply {\n ap_loc=loc;\n ap_func=lexp;\n ap_args=args;\n ap_tailcall=tailcall;\n ap_inlined=inlined;\n ap_specialised=specialised;\n }\n in\n let rec build_apply lam args = function\n (None, optional) :: l ->\n let defs = ref [] in\n let protect name lam =\n match lam with\n Lvar _ | Lconst _ -> lam\n | _ ->\n let id = Ident.create_local name in\n defs := (id, lam) :: !defs;\n Lvar id\n in\n let args, args' =\n if List.for_all (fun (_,opt) -> opt) args then [], args\n else args, []\n in\n let lam =\n if args = [] then lam else lapply lam (List.rev_map fst args)\n in\n let handle = protect \"func\" lam in\n let l =\n List.map (fun (arg, opt) -> Option.map (protect \"arg\") arg, opt) l\n in\n let id_arg = Ident.create_local \"param\" in\n let body =\n match build_apply handle ((Lvar id_arg, optional)::args') l with\n Lfunction{kind = Curried; params = ids; return;\n body = lam; attr; loc}\n when List.length ids < Lambda.max_arity () ->\n lfunction ~kind:Curried\n ~params:((id_arg, Pgenval)::ids)\n ~return\n ~body:lam ~attr\n ~loc\n | lam ->\n lfunction ~kind:Curried ~params:[id_arg, Pgenval]\n ~return:Pgenval ~body:lam\n ~attr:default_stub_attribute ~loc\n in\n List.fold_left\n (fun body (id, lam) -> Llet(Strict, Pgenval, id, lam, body))\n body !defs\n | (Some arg, optional) :: l ->\n build_apply lam ((arg, optional) :: args) l\n | [] ->\n lapply lam (List.rev_map fst args)\n in\n (build_apply lam [] (List.map (fun (l, x) ->\n Option.map (transl_exp ~scopes) x,\n Btype.is_optional l)\n sargs)\n : Lambda.lambda)\n\nand transl_curried_function\n ~scopes loc return\n repr partial (param:Ident.t) cases =\n let max_arity = Lambda.max_arity () in\n let rec loop ~scopes loc return ~arity partial (param:Ident.t) cases =\n match cases with\n [{c_lhs=pat; c_guard=None;\n c_rhs={exp_desc =\n Texp_function\n { arg_label = _; param = param'; cases = cases';\n partial = partial'; }; exp_env; exp_type;exp_loc}}]\n when arity < max_arity ->\n if Parmatch.inactive ~partial pat\n then\n let kind = value_kind pat.pat_env pat.pat_type in\n let return_kind = function_return_value_kind exp_env exp_type in\n let ((_, params, return), body) =\n loop ~scopes exp_loc return_kind ~arity:(arity + 1)\n partial' param' cases'\n in\n ((Curried, (param, kind) :: params, return),\n Matching.for_function ~scopes loc None (Lvar param)\n [pat, body] partial)\n else begin\n begin match partial with\n | Total ->\n Location.prerr_warning pat.pat_loc\n Match_on_mutable_state_prevent_uncurry\n | Partial -> ()\n end;\n transl_tupled_function ~scopes ~arity\n loc return repr partial param cases\n end\n | cases ->\n transl_tupled_function ~scopes ~arity\n loc return repr partial param cases\n in\n loop ~scopes loc return ~arity:1 partial param cases\n\nand transl_tupled_function\n ~scopes ~arity loc return\n repr partial (param:Ident.t) cases =\n match cases with\n | {c_lhs={pat_desc = Tpat_tuple pl}} :: _\n when !Clflags.native_code\n && arity = 1\n && List.length pl <= (Lambda.max_arity ()) ->\n begin try\n let size = List.length pl in\n let pats_expr_list =\n List.map\n (fun {c_lhs; c_guard; c_rhs} ->\n (Matching.flatten_pattern size c_lhs, c_guard, c_rhs))\n cases in\n let kinds =\n (* All the patterns might not share the same types. We must take the\n union of the patterns types *)\n match pats_expr_list with\n | [] -> assert false\n | (pats, _, _) :: cases ->\n let first_case_kinds =\n List.map (fun pat -> value_kind pat.pat_env pat.pat_type) pats\n in\n List.fold_left\n (fun kinds (pats, _, _) ->\n List.map2 (fun kind pat ->\n value_kind_union kind\n (value_kind pat.pat_env pat.pat_type))\n kinds pats)\n first_case_kinds cases\n in\n let tparams =\n List.map (fun kind -> Ident.create_local \"param\", kind) kinds\n in\n let params = List.map fst tparams in\n ((Tupled, tparams, return),\n Matching.for_tupled_function ~scopes loc params\n (transl_tupled_cases ~scopes pats_expr_list) partial)\n with Matching.Cannot_flatten ->\n transl_function0 ~scopes loc return repr partial param cases\n end\n | _ -> transl_function0 ~scopes loc return repr partial param cases\n\nand transl_function0\n ~scopes loc return\n repr partial (param:Ident.t) cases =\n let kind =\n match cases with\n | [] ->\n (* With Camlp4, a pattern matching might be empty *)\n Pgenval\n | {c_lhs=pat} :: other_cases ->\n (* All the patterns might not share the same types. We must take the\n union of the patterns types *)\n List.fold_left (fun k {c_lhs=pat} ->\n Typeopt.value_kind_union k\n (value_kind pat.pat_env pat.pat_type))\n (value_kind pat.pat_env pat.pat_type) other_cases\n in\n ((Curried, [param, kind], return),\n Matching.for_function ~scopes loc repr (Lvar param)\n (transl_cases ~scopes cases) partial)\n\nand transl_function ~scopes e param cases partial =\n let ((kind, params, return), body) =\n event_function ~scopes e\n (function repr ->\n let pl = push_defaults e.exp_loc cases partial in\n let return_kind = function_return_value_kind e.exp_env e.exp_type in\n transl_curried_function ~scopes e.exp_loc return_kind\n repr partial param pl)\n in\n let attr = default_function_attribute in\n let loc = of_location ~scopes e.exp_loc in\n let lam = lfunction ~kind ~params ~return ~body ~attr ~loc in\n Translattribute.add_function_attributes lam e.exp_loc e.exp_attributes\n\n(* Like transl_exp, but used when a new scope was just introduced. *)\nand transl_scoped_exp ~scopes expr =\n transl_exp1 ~scopes ~in_new_scope:true expr\n\n(* Decides whether a pattern binding should introduce a new scope. *)\nand transl_bound_exp ~scopes ~in_structure pat expr =\n let should_introduce_scope =\n match expr.exp_desc with\n | Texp_function _ -> true\n | _ when in_structure -> true\n | _ -> false in\n match pat_bound_idents pat with\n | (id :: _) when should_introduce_scope ->\n transl_scoped_exp ~scopes:(enter_value_definition ~scopes id) expr\n | _ -> transl_exp ~scopes expr\n\n(*\n Notice: transl_let consumes (ie compiles) its pat_expr_list argument,\n and returns a function that will take the body of the lambda-let construct.\n This complication allows choosing any compilation order for the\n bindings and body of let constructs.\n*)\nand transl_let ~scopes ?(in_structure=false) rec_flag pat_expr_list =\n match rec_flag with\n Nonrecursive ->\n let rec transl = function\n [] ->\n fun body -> body\n | {vb_pat=pat; vb_expr=expr; vb_attributes=attr; vb_loc} :: rem ->\n let lam = transl_bound_exp ~scopes ~in_structure pat expr in\n let lam = Translattribute.add_function_attributes lam vb_loc attr in\n let mk_body = transl rem in\n fun body ->\n Matching.for_let ~scopes pat.pat_loc lam pat (mk_body body)\n in transl pat_expr_list\n | Recursive ->\n let idlist =\n List.map\n (fun {vb_pat=pat} -> match pat.pat_desc with\n Tpat_var (id,_) -> id\n | Tpat_alias ({pat_desc=Tpat_any}, id,_) -> id\n | _ -> assert false)\n pat_expr_list in\n let transl_case {vb_expr=expr; vb_attributes; vb_loc; vb_pat} id =\n let lam = transl_bound_exp ~scopes ~in_structure vb_pat expr in\n let lam =\n Translattribute.add_function_attributes lam vb_loc vb_attributes\n in\n (id, lam) in\n let lam_bds = List.map2 transl_case pat_expr_list idlist in\n fun body -> Lletrec(lam_bds, body)\n\nand transl_setinstvar ~scopes loc self var expr =\n Lprim(Psetfield_computed (maybe_pointer expr, Assignment),\n [self; var; transl_exp ~scopes expr], loc)\n\nand transl_record ~scopes loc env fields repres opt_init_expr =\n let size = Array.length fields in\n (* Determine if there are \"enough\" fields (only relevant if this is a\n functional-style record update *)\n let no_init = match opt_init_expr with None -> true | _ -> false in\n if no_init || size < Config.max_young_wosize\n then begin\n (* Allocate new record with given fields (and remaining fields\n taken from init_expr if any *)\n let init_id = Ident.create_local \"init\" in\n let lv =\n Array.mapi\n (fun i (_, definition) ->\n match definition with\n | Kept typ ->\n let field_kind = value_kind env typ in\n let access =\n match repres with\n Record_regular | Record_inlined _ -> Pfield i\n | Record_unboxed _ -> assert false\n | Record_extension _ -> Pfield (i + 1)\n | Record_float -> Pfloatfield i in\n Lprim(access, [Lvar init_id],\n of_location ~scopes loc),\n field_kind\n | Overridden (_lid, expr) ->\n let field_kind = value_kind expr.exp_env expr.exp_type in\n transl_exp ~scopes expr, field_kind)\n fields\n in\n let ll, shape = List.split (Array.to_list lv) in\n let mut =\n if Array.exists (fun (lbl, _) -> lbl.lbl_mut = Mutable) fields\n then Mutable\n else Immutable in\n let lam =\n try\n if mut = Mutable then raise Not_constant;\n let cl = List.map extract_constant ll in\n match repres with\n | Record_regular -> Lconst(Const_block(0, cl))\n | Record_inlined tag -> Lconst(Const_block(tag, cl))\n | Record_unboxed _ -> Lconst(match cl with [v] -> v | _ -> assert false)\n | Record_float ->\n Lconst(Const_float_array(List.map extract_float cl))\n | Record_extension _ ->\n raise Not_constant\n with Not_constant ->\n let loc = of_location ~scopes loc in\n match repres with\n Record_regular ->\n Lprim(Pmakeblock(0, mut, Some shape), ll, loc)\n | Record_inlined tag ->\n Lprim(Pmakeblock(tag, mut, Some shape), ll, loc)\n | Record_unboxed _ -> (match ll with [v] -> v | _ -> assert false)\n | Record_float ->\n Lprim(Pmakearray (Pfloatarray, mut), ll, loc)\n | Record_extension path ->\n let slot = transl_extension_path loc env path in\n Lprim(Pmakeblock(0, mut, Some (Pgenval :: shape)), slot :: ll, loc)\n in\n begin match opt_init_expr with\n None -> lam\n | Some init_expr -> Llet(Strict, Pgenval, init_id,\n transl_exp ~scopes init_expr, lam)\n end\n end else begin\n (* Take a shallow copy of the init record, then mutate the fields\n of the copy *)\n let copy_id = Ident.create_local \"newrecord\" in\n let update_field cont (lbl, definition) =\n match definition with\n | Kept _type -> cont\n | Overridden (_lid, expr) ->\n let upd =\n match repres with\n Record_regular\n | Record_inlined _ ->\n Psetfield(lbl.lbl_pos, maybe_pointer expr, Assignment)\n | Record_unboxed _ -> assert false\n | Record_float -> Psetfloatfield (lbl.lbl_pos, Assignment)\n | Record_extension _ ->\n Psetfield(lbl.lbl_pos + 1, maybe_pointer expr, Assignment)\n in\n Lsequence(Lprim(upd, [Lvar copy_id; transl_exp ~scopes expr],\n of_location ~scopes loc),\n cont)\n in\n begin match opt_init_expr with\n None -> assert false\n | Some init_expr ->\n Llet(Strict, Pgenval, copy_id,\n Lprim(Pduprecord (repres, size), [transl_exp ~scopes init_expr],\n of_location ~scopes loc),\n Array.fold_left update_field (Lvar copy_id) fields)\n end\n end\n\nand transl_match ~scopes e arg pat_expr_list partial =\n let rewrite_case (val_cases, exn_cases, static_handlers as acc)\n ({ c_lhs; c_guard; c_rhs } as case) =\n if c_rhs.exp_desc = Texp_unreachable then acc else\n let val_pat, exn_pat = split_pattern c_lhs in\n match val_pat, exn_pat with\n | None, None -> assert false\n | Some pv, None ->\n let val_case =\n transl_case ~scopes { case with c_lhs = pv }\n in\n val_case :: val_cases, exn_cases, static_handlers\n | None, Some pe ->\n let exn_case = transl_case_try ~scopes { case with c_lhs = pe } in\n val_cases, exn_case :: exn_cases, static_handlers\n | Some pv, Some pe ->\n assert (c_guard = None);\n let lbl = next_raise_count () in\n let static_raise ids =\n Lstaticraise (lbl, List.map (fun id -> Lvar id) ids)\n in\n (* Simplif doesn't like it if binders are not uniq, so we make sure to\n use different names in the value and the exception branches. *)\n let ids_full = Typedtree.pat_bound_idents_full pv in\n let ids = List.map (fun (id, _, _) -> id) ids_full in\n let ids_kinds =\n List.map (fun (id, _, ty) -> id, Typeopt.value_kind pv.pat_env ty)\n ids_full\n in\n let vids = List.map Ident.rename ids in\n let pv = alpha_pat (List.combine ids vids) pv in\n (* Also register the names of the exception so Re-raise happens. *)\n iter_exn_names Translprim.add_exception_ident pe;\n let rhs =\n Misc.try_finally\n (fun () -> event_before ~scopes c_rhs\n (transl_exp ~scopes c_rhs))\n ~always:(fun () ->\n iter_exn_names Translprim.remove_exception_ident pe)\n in\n (pv, static_raise vids) :: val_cases,\n (pe, static_raise ids) :: exn_cases,\n (lbl, ids_kinds, rhs) :: static_handlers\n in\n let val_cases, exn_cases, static_handlers =\n let x, y, z = List.fold_left rewrite_case ([], [], []) pat_expr_list in\n List.rev x, List.rev y, List.rev z\n in\n (* In presence of exception patterns, the code we generate for\n\n match with\n | -> \n | -> \n\n looks like\n\n staticcatch\n (try (exit )\n with -> )\n with ->\n match with -> \n\n In particular, the 'exit' in the value case ensures that the\n value actions run outside the try..with exception handler.\n *)\n let static_catch scrutinees val_ids handler =\n let id = Typecore.name_pattern \"exn\" (List.map fst exn_cases) in\n let static_exception_id = next_raise_count () in\n Lstaticcatch\n (Ltrywith (Lstaticraise (static_exception_id, scrutinees), id,\n Matching.for_trywith ~scopes e.exp_loc (Lvar id) exn_cases),\n (static_exception_id, val_ids),\n handler)\n in\n let classic =\n match arg, exn_cases with\n | {exp_desc = Texp_tuple argl}, [] ->\n assert (static_handlers = []);\n Matching.for_multiple_match ~scopes e.exp_loc\n (transl_list ~scopes argl) val_cases partial\n | {exp_desc = Texp_tuple argl}, _ :: _ ->\n let val_ids =\n List.map\n (fun arg ->\n Typecore.name_pattern \"val\" [],\n Typeopt.value_kind arg.exp_env arg.exp_type\n )\n argl\n in\n let lvars = List.map (fun (id, _) -> Lvar id) val_ids in\n static_catch (transl_list ~scopes argl) val_ids\n (Matching.for_multiple_match ~scopes e.exp_loc\n lvars val_cases partial)\n | arg, [] ->\n assert (static_handlers = []);\n Matching.for_function ~scopes e.exp_loc\n None (transl_exp ~scopes arg) val_cases partial\n | arg, _ :: _ ->\n let val_id = Typecore.name_pattern \"val\" (List.map fst val_cases) in\n let k = Typeopt.value_kind arg.exp_env arg.exp_type in\n static_catch [transl_exp ~scopes arg] [val_id, k]\n (Matching.for_function ~scopes e.exp_loc\n None (Lvar val_id) val_cases partial)\n in\n List.fold_left (fun body (static_exception_id, val_ids, handler) ->\n Lstaticcatch (body, (static_exception_id, val_ids), handler)\n ) classic static_handlers\n\nand transl_letop ~scopes loc env let_ ands param case partial =\n let rec loop prev_lam = function\n | [] -> prev_lam\n | and_ :: rest ->\n let left_id = Ident.create_local \"left\" in\n let right_id = Ident.create_local \"right\" in\n let op =\n transl_ident (of_location ~scopes and_.bop_op_name.loc) env\n and_.bop_op_type and_.bop_op_path and_.bop_op_val\n in\n let exp = transl_exp ~scopes and_.bop_exp in\n let lam =\n bind Strict right_id exp\n (Lapply{\n ap_loc = of_location ~scopes and_.bop_loc;\n ap_func = op;\n ap_args=[Lvar left_id; Lvar right_id];\n ap_tailcall = Default_tailcall;\n ap_inlined = Default_inline;\n ap_specialised = Default_specialise;\n })\n in\n bind Strict left_id prev_lam (loop lam rest)\n in\n let op =\n transl_ident (of_location ~scopes let_.bop_op_name.loc) env\n let_.bop_op_type let_.bop_op_path let_.bop_op_val\n in\n let exp = loop (transl_exp ~scopes let_.bop_exp) ands in\n let func =\n let return_kind = value_kind case.c_rhs.exp_env case.c_rhs.exp_type in\n let (kind, params, return), body =\n event_function ~scopes case.c_rhs\n (function repr ->\n transl_curried_function ~scopes case.c_rhs.exp_loc return_kind\n repr partial param [case])\n in\n let attr = default_function_attribute in\n let loc = of_location ~scopes case.c_rhs.exp_loc in\n lfunction ~kind ~params ~return ~body ~attr ~loc\n in\n Lapply{\n ap_loc = of_location ~scopes loc;\n ap_func = op;\n ap_args=[exp; func];\n ap_tailcall = Default_tailcall;\n ap_inlined = Default_inline;\n ap_specialised = Default_specialise;\n }\n\n(* Wrapper for class compilation *)\n\n(*\nlet transl_exp = transl_exp_wrap\n\nlet transl_let rec_flag pat_expr_list body =\n match pat_expr_list with\n [] -> body\n | (_, expr) :: _ ->\n Translobj.oo_wrap expr.exp_env false\n (transl_let rec_flag pat_expr_list) body\n*)\n\n(* Error report *)\n\nopen Format\n\nlet report_error ppf = function\n | Free_super_var ->\n fprintf ppf\n \"Ancestor names can only be used to select inherited methods\"\n | Unreachable_reached ->\n fprintf ppf \"Unreachable expression was reached\"\n\nlet () =\n Location.register_error_of_exn\n (function\n | Error (loc, err) ->\n Some (Location.error_of_printer ~loc report_error err)\n | _ ->\n None\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\nopen Misc\nopen Asttypes\n\ntype compile_time_constant =\n | Big_endian\n | Word_size\n | Int_size\n | Max_wosize\n | Ostype_unix\n | Ostype_win32\n | Ostype_cygwin\n | Backend_type\n\ntype immediate_or_pointer =\n | Immediate\n | Pointer\n\ntype initialization_or_assignment =\n | Assignment\n | Heap_initialization\n | Root_initialization\n\ntype is_safe =\n | Safe\n | Unsafe\n\ntype primitive =\n | Pbytes_to_string\n | Pbytes_of_string\n | Pignore\n (* Globals *)\n | Pgetglobal of Ident.t\n | Psetglobal of Ident.t\n (* Operations on heap blocks *)\n | Pmakeblock of int * mutable_flag * block_shape\n | Pfield of int\n | Pfield_computed\n | Psetfield of int * immediate_or_pointer * initialization_or_assignment\n | Psetfield_computed of immediate_or_pointer * initialization_or_assignment\n | Pfloatfield of int\n | Psetfloatfield of int * initialization_or_assignment\n | Pduprecord of Types.record_representation * int\n (* Force lazy values *)\n (* External call *)\n | Pccall of Primitive.description\n (* Exceptions *)\n | Praise of raise_kind\n (* Boolean operations *)\n | Psequand | Psequor | Pnot\n (* Integer operations *)\n | Pnegint | Paddint | Psubint | Pmulint\n | Pdivint of is_safe | Pmodint of is_safe\n | Pandint | Porint | Pxorint\n | Plslint | Plsrint | Pasrint\n | Pintcomp of integer_comparison\n | Pcompare_ints | Pcompare_floats | Pcompare_bints of boxed_integer\n | Poffsetint of int\n | Poffsetref of int\n (* Float operations *)\n | Pintoffloat | Pfloatofint\n | Pnegfloat | Pabsfloat\n | Paddfloat | Psubfloat | Pmulfloat | Pdivfloat\n | Pfloatcomp of float_comparison\n (* String operations *)\n | Pstringlength | Pstringrefu | Pstringrefs\n | Pbyteslength | Pbytesrefu | Pbytessetu | Pbytesrefs | Pbytessets\n (* Array operations *)\n | Pmakearray of array_kind * mutable_flag\n | Pduparray of array_kind * mutable_flag\n | Parraylength of array_kind\n | Parrayrefu of array_kind\n | Parraysetu of array_kind\n | Parrayrefs of array_kind\n | Parraysets of array_kind\n (* Test if the argument is a block or an immediate integer *)\n | Pisint\n (* Test if the (integer) argument is outside an interval *)\n | Pisout\n (* Operations on boxed integers (Nativeint.t, Int32.t, Int64.t) *)\n | Pbintofint of boxed_integer\n | Pintofbint of boxed_integer\n | Pcvtbint of boxed_integer (*source*) * boxed_integer (*destination*)\n | Pnegbint of boxed_integer\n | Paddbint of boxed_integer\n | Psubbint of boxed_integer\n | Pmulbint of boxed_integer\n | Pdivbint of { size : boxed_integer; is_safe : is_safe }\n | Pmodbint of { size : boxed_integer; is_safe : is_safe }\n | Pandbint of boxed_integer\n | Porbint of boxed_integer\n | Pxorbint of boxed_integer\n | Plslbint of boxed_integer\n | Plsrbint of boxed_integer\n | Pasrbint of boxed_integer\n | Pbintcomp of boxed_integer * integer_comparison\n (* Operations on Bigarrays: (unsafe, #dimensions, kind, layout) *)\n | Pbigarrayref of bool * int * bigarray_kind * bigarray_layout\n | Pbigarrayset of bool * int * bigarray_kind * bigarray_layout\n (* size of the nth dimension of a Bigarray *)\n | Pbigarraydim of int\n (* load/set 16,32,64 bits from a string: (unsafe)*)\n | Pstring_load_16 of bool\n | Pstring_load_32 of bool\n | Pstring_load_64 of bool\n | Pbytes_load_16 of bool\n | Pbytes_load_32 of bool\n | Pbytes_load_64 of bool\n | Pbytes_set_16 of bool\n | Pbytes_set_32 of bool\n | Pbytes_set_64 of bool\n (* load/set 16,32,64 bits from a\n (char, int8_unsigned_elt, c_layout) Bigarray.Array1.t : (unsafe) *)\n | Pbigstring_load_16 of bool\n | Pbigstring_load_32 of bool\n | Pbigstring_load_64 of bool\n | Pbigstring_set_16 of bool\n | Pbigstring_set_32 of bool\n | Pbigstring_set_64 of bool\n (* Compile time constants *)\n | Pctconst of compile_time_constant\n (* byte swap *)\n | Pbswap16\n | Pbbswap of boxed_integer\n (* Integer to external pointer *)\n | Pint_as_pointer\n (* Inhibition of optimisation *)\n | Popaque\n\nand integer_comparison =\n Ceq | Cne | Clt | Cgt | Cle | Cge\n\nand float_comparison =\n CFeq | CFneq | CFlt | CFnlt | CFgt | CFngt | CFle | CFnle | CFge | CFnge\n\nand value_kind =\n Pgenval | Pfloatval | Pboxedintval of boxed_integer | Pintval\n\nand block_shape =\n value_kind list option\n\nand array_kind =\n Pgenarray | Paddrarray | Pintarray | Pfloatarray\n\nand boxed_integer = Primitive.boxed_integer =\n Pnativeint | Pint32 | Pint64\n\nand bigarray_kind =\n Pbigarray_unknown\n | Pbigarray_float32 | Pbigarray_float64\n | Pbigarray_sint8 | Pbigarray_uint8\n | Pbigarray_sint16 | Pbigarray_uint16\n | Pbigarray_int32 | Pbigarray_int64\n | Pbigarray_caml_int | Pbigarray_native_int\n | Pbigarray_complex32 | Pbigarray_complex64\n\nand bigarray_layout =\n Pbigarray_unknown_layout\n | Pbigarray_c_layout\n | Pbigarray_fortran_layout\n\nand raise_kind =\n | Raise_regular\n | Raise_reraise\n | Raise_notrace\n\nlet equal_boxed_integer = Primitive.equal_boxed_integer\n\nlet equal_primitive =\n (* Should be implemented like [equal_value_kind] of [equal_boxed_integer],\n i.e. by matching over the various constructors but the type has more\n than 100 constructors... *)\n (=)\n\nlet equal_value_kind x y =\n match x, y with\n | Pgenval, Pgenval -> true\n | Pfloatval, Pfloatval -> true\n | Pboxedintval bi1, Pboxedintval bi2 -> equal_boxed_integer bi1 bi2\n | Pintval, Pintval -> true\n | (Pgenval | Pfloatval | Pboxedintval _ | Pintval), _ -> false\n\n\ntype structured_constant =\n Const_base of constant\n | Const_block of int * structured_constant list\n | Const_float_array of string list\n | Const_immstring of string\n\ntype tailcall_attribute =\n | Tailcall_expectation of bool\n (* [@tailcall] and [@tailcall true] have [true],\n [@tailcall false] has [false] *)\n | Default_tailcall (* no [@tailcall] attribute *)\n\ntype inline_attribute =\n | Always_inline (* [@inline] or [@inline always] *)\n | Never_inline (* [@inline never] *)\n | Hint_inline (* [@inlined hint] attribute *)\n | Unroll of int (* [@unroll x] *)\n | Default_inline (* no [@inline] attribute *)\n\nlet equal_inline_attribute x y =\n match x, y with\n | Always_inline, Always_inline\n | Never_inline, Never_inline\n | Hint_inline, Hint_inline\n | Default_inline, Default_inline\n ->\n true\n | Unroll u, Unroll v ->\n u = v\n | (Always_inline | Never_inline\n | Hint_inline | Unroll _ | Default_inline), _ ->\n false\n\ntype specialise_attribute =\n | Always_specialise (* [@specialise] or [@specialise always] *)\n | Never_specialise (* [@specialise never] *)\n | Default_specialise (* no [@specialise] attribute *)\n\nlet equal_specialise_attribute x y =\n match x, y with\n | Always_specialise, Always_specialise\n | Never_specialise, Never_specialise\n | Default_specialise, Default_specialise ->\n true\n | (Always_specialise | Never_specialise | Default_specialise), _ ->\n false\n\ntype local_attribute =\n | Always_local (* [@local] or [@local always] *)\n | Never_local (* [@local never] *)\n | Default_local (* [@local maybe] or no [@local] attribute *)\n\ntype poll_attribute =\n | Error_poll (* [@poll error] *)\n | Default_poll (* no [@poll] attribute *)\n\ntype function_kind = Curried | Tupled\n\ntype let_kind = Strict | Alias | StrictOpt\n\ntype meth_kind = Self | Public | Cached\n\nlet equal_meth_kind x y =\n match x, y with\n | Self, Self -> true\n | Public, Public -> true\n | Cached, Cached -> true\n | (Self | Public | Cached), _ -> false\n\ntype shared_code = (int * int) list\n\ntype function_attribute = {\n inline : inline_attribute;\n specialise : specialise_attribute;\n local: local_attribute;\n poll: poll_attribute;\n is_a_functor: bool;\n stub: bool;\n tmc_candidate: bool;\n}\n\ntype scoped_location = Debuginfo.Scoped_location.t\n\ntype lambda =\n Lvar of Ident.t\n | Lmutvar of Ident.t\n | Lconst of structured_constant\n | Lapply of lambda_apply\n | Lfunction of lfunction\n | Llet of let_kind * value_kind * Ident.t * lambda * lambda\n | Lmutlet of value_kind * Ident.t * lambda * lambda\n | Lletrec of (Ident.t * lambda) list * lambda\n | Lprim of primitive * lambda list * scoped_location\n | Lswitch of lambda * lambda_switch * scoped_location\n | Lstringswitch of\n lambda * (string * lambda) list * lambda option * scoped_location\n | Lstaticraise of int * lambda list\n | Lstaticcatch of lambda * (int * (Ident.t * value_kind) list) * lambda\n | Ltrywith of lambda * Ident.t * lambda\n | Lifthenelse of lambda * lambda * lambda\n | Lsequence of lambda * lambda\n | Lwhile of lambda * lambda\n | Lfor of Ident.t * lambda * lambda * direction_flag * lambda\n | Lassign of Ident.t * lambda\n | Lsend of meth_kind * lambda * lambda * lambda list * scoped_location\n | Levent of lambda * lambda_event\n | Lifused of Ident.t * lambda\n\nand lfunction =\n { kind: function_kind;\n params: (Ident.t * value_kind) list;\n return: value_kind;\n body: lambda;\n attr: function_attribute; (* specified with [@inline] attribute *)\n loc: scoped_location; }\n\nand lambda_apply =\n { ap_func : lambda;\n ap_args : lambda list;\n ap_loc : scoped_location;\n ap_tailcall : tailcall_attribute;\n ap_inlined : inline_attribute;\n ap_specialised : specialise_attribute; }\n\nand lambda_switch =\n { sw_numconsts: int;\n sw_consts: (int * lambda) list;\n sw_numblocks: int;\n sw_blocks: (int * lambda) list;\n sw_failaction : lambda option}\n\nand lambda_event =\n { lev_loc: scoped_location;\n lev_kind: lambda_event_kind;\n lev_repr: int ref option;\n lev_env: Env.t }\n\nand lambda_event_kind =\n Lev_before\n | Lev_after of Types.type_expr\n | Lev_function\n | Lev_pseudo\n | Lev_module_definition of Ident.t\n\ntype program =\n { module_ident : Ident.t;\n main_module_block_size : int;\n required_globals : Ident.Set.t;\n code : lambda }\n\nlet const_int n = Const_base (Const_int n)\n\nlet const_unit = const_int 0\n\nlet max_arity () =\n if !Clflags.native_code then 126 else max_int\n (* 126 = 127 (the maximal number of parameters supported in C--)\n - 1 (the hidden parameter containing the environment) *)\n\nlet lfunction ~kind ~params ~return ~body ~attr ~loc =\n assert (List.length params <= max_arity ());\n Lfunction { kind; params; return; body; attr; loc }\n\nlet lambda_unit = Lconst const_unit\n\nlet default_function_attribute = {\n inline = Default_inline;\n specialise = Default_specialise;\n local = Default_local;\n poll = Default_poll;\n is_a_functor = false;\n stub = false;\n tmc_candidate = false;\n}\n\nlet default_stub_attribute =\n { default_function_attribute with stub = true }\n\n(* Build sharing keys *)\n(*\n Those keys are later compared with Stdlib.compare.\n For that reason, they should not include cycles.\n*)\n\nlet max_raw = 32\n\nlet make_key e =\n let exception Not_simple in\n let count = ref 0 (* Used for controlling size *)\n and make_key = Ident.make_key_generator () in\n (* make_key is used for normalizing let-bound variables *)\n let rec tr_rec env e =\n incr count ;\n if !count > max_raw then raise Not_simple ; (* Too big ! *)\n match e with\n | Lvar id\n | Lmutvar id ->\n begin\n try Ident.find_same id env\n with Not_found -> e\n end\n | Lconst (Const_base (Const_string _)) ->\n (* Mutable constants are not shared *)\n raise Not_simple\n | Lconst _ -> e\n | Lapply ap ->\n Lapply {ap with ap_func = tr_rec env ap.ap_func;\n ap_args = tr_recs env ap.ap_args;\n ap_loc = Loc_unknown}\n | Llet (Alias,_k,x,ex,e) -> (* Ignore aliases -> substitute *)\n let ex = tr_rec env ex in\n tr_rec (Ident.add x ex env) e\n | Llet ((Strict | StrictOpt),_k,x,ex,Lvar v) when Ident.same v x ->\n tr_rec env ex\n | Llet (str,k,x,ex,e) ->\n (* Because of side effects, keep other lets with normalized names *)\n let ex = tr_rec env ex in\n let y = make_key x in\n Llet (str,k,y,ex,tr_rec (Ident.add x (Lvar y) env) e)\n | Lmutlet (k,x,ex,e) ->\n let ex = tr_rec env ex in\n let y = make_key x in\n Lmutlet (k,y,ex,tr_rec (Ident.add x (Lmutvar y) env) e)\n | Lprim (p,es,_) ->\n Lprim (p,tr_recs env es, Loc_unknown)\n | Lswitch (e,sw,loc) ->\n Lswitch (tr_rec env e,tr_sw env sw,loc)\n | Lstringswitch (e,sw,d,_) ->\n Lstringswitch\n (tr_rec env e,\n List.map (fun (s,e) -> s,tr_rec env e) sw,\n tr_opt env d,\n Loc_unknown)\n | Lstaticraise (i,es) ->\n Lstaticraise (i,tr_recs env es)\n | Lstaticcatch (e1,xs,e2) ->\n Lstaticcatch (tr_rec env e1,xs,tr_rec env e2)\n | Ltrywith (e1,x,e2) ->\n Ltrywith (tr_rec env e1,x,tr_rec env e2)\n | Lifthenelse (cond,ifso,ifnot) ->\n Lifthenelse (tr_rec env cond,tr_rec env ifso,tr_rec env ifnot)\n | Lsequence (e1,e2) ->\n Lsequence (tr_rec env e1,tr_rec env e2)\n | Lassign (x,e) ->\n Lassign (x,tr_rec env e)\n | Lsend (m,e1,e2,es,_loc) ->\n Lsend (m,tr_rec env e1,tr_rec env e2,tr_recs env es,Loc_unknown)\n | Lifused (id,e) -> Lifused (id,tr_rec env e)\n | Lletrec _|Lfunction _\n | Lfor _ | Lwhile _\n(* Beware: (PR#6412) the event argument to Levent\n may include cyclic structure of type Type.typexpr *)\n | Levent _ ->\n raise Not_simple\n\n and tr_recs env es = List.map (tr_rec env) es\n\n and tr_sw env sw =\n { sw with\n sw_consts = List.map (fun (i,e) -> i,tr_rec env e) sw.sw_consts ;\n sw_blocks = List.map (fun (i,e) -> i,tr_rec env e) sw.sw_blocks ;\n sw_failaction = tr_opt env sw.sw_failaction ; }\n\n and tr_opt env = function\n | None -> None\n | Some e -> Some (tr_rec env e) in\n\n try\n Some (tr_rec Ident.empty e)\n with Not_simple -> None\n\n(***************)\n\nlet name_lambda strict arg fn =\n match arg with\n Lvar id -> fn id\n | _ ->\n let id = Ident.create_local \"let\" in\n Llet(strict, Pgenval, id, arg, fn id)\n\nlet name_lambda_list args fn =\n let rec name_list names = function\n [] -> fn (List.rev names)\n | (Lvar _ as arg) :: rem ->\n name_list (arg :: names) rem\n | arg :: rem ->\n let id = Ident.create_local \"let\" in\n Llet(Strict, Pgenval, id, arg, name_list (Lvar id :: names) rem) in\n name_list [] args\n\n\nlet iter_opt f = function\n | None -> ()\n | Some e -> f e\n\nlet shallow_iter ~tail ~non_tail:f = function\n Lvar _\n | Lmutvar _\n | Lconst _ -> ()\n | Lapply{ap_func = fn; ap_args = args} ->\n f fn; List.iter f args\n | Lfunction{body} ->\n f body\n | Llet(_, _k, _id, arg, body)\n | Lmutlet(_k, _id, arg, body) ->\n f arg; tail body\n | Lletrec(decl, body) ->\n tail body;\n List.iter (fun (_id, exp) -> f exp) decl\n | Lprim (Psequand, [l1; l2], _)\n | Lprim (Psequor, [l1; l2], _) ->\n f l1;\n tail l2\n | Lprim(_p, args, _loc) ->\n List.iter f args\n | Lswitch(arg, sw,_) ->\n f arg;\n List.iter (fun (_key, case) -> tail case) sw.sw_consts;\n List.iter (fun (_key, case) -> tail case) sw.sw_blocks;\n iter_opt tail sw.sw_failaction\n | Lstringswitch (arg,cases,default,_) ->\n f arg ;\n List.iter (fun (_,act) -> tail act) cases ;\n iter_opt tail default\n | Lstaticraise (_,args) ->\n List.iter f args\n | Lstaticcatch(e1, _, e2) ->\n tail e1; tail e2\n | Ltrywith(e1, _, e2) ->\n f e1; tail e2\n | Lifthenelse(e1, e2, e3) ->\n f e1; tail e2; tail e3\n | Lsequence(e1, e2) ->\n f e1; tail e2\n | Lwhile(e1, e2) ->\n f e1; f e2\n | Lfor(_v, e1, e2, _dir, e3) ->\n f e1; f e2; f e3\n | Lassign(_, e) ->\n f e\n | Lsend (_k, met, obj, args, _) ->\n List.iter f (met::obj::args)\n | Levent (e, _evt) ->\n tail e\n | Lifused (_v, e) ->\n tail e\n\nlet iter_head_constructor f l =\n shallow_iter ~tail:f ~non_tail:f l\n\nlet rec free_variables = function\n | Lvar id\n | Lmutvar id -> Ident.Set.singleton id\n | Lconst _ -> Ident.Set.empty\n | Lapply{ap_func = fn; ap_args = args} ->\n free_variables_list (free_variables fn) args\n | Lfunction{body; params} ->\n Ident.Set.diff (free_variables body)\n (Ident.Set.of_list (List.map fst params))\n | Llet(_, _k, id, arg, body)\n | Lmutlet(_k, id, arg, body) ->\n Ident.Set.union\n (free_variables arg)\n (Ident.Set.remove id (free_variables body))\n | Lletrec(decl, body) ->\n let set = free_variables_list (free_variables body) (List.map snd decl) in\n Ident.Set.diff set (Ident.Set.of_list (List.map fst decl))\n | Lprim(_p, args, _loc) ->\n free_variables_list Ident.Set.empty args\n | Lswitch(arg, sw,_) ->\n let set =\n free_variables_list\n (free_variables_list (free_variables arg)\n (List.map snd sw.sw_consts))\n (List.map snd sw.sw_blocks)\n in\n begin match sw.sw_failaction with\n | None -> set\n | Some failaction -> Ident.Set.union set (free_variables failaction)\n end\n | Lstringswitch (arg,cases,default,_) ->\n let set =\n free_variables_list (free_variables arg)\n (List.map snd cases)\n in\n begin match default with\n | None -> set\n | Some default -> Ident.Set.union set (free_variables default)\n end\n | Lstaticraise (_,args) ->\n free_variables_list Ident.Set.empty args\n | Lstaticcatch(body, (_, params), handler) ->\n Ident.Set.union\n (Ident.Set.diff\n (free_variables handler)\n (Ident.Set.of_list (List.map fst params)))\n (free_variables body)\n | Ltrywith(body, param, handler) ->\n Ident.Set.union\n (Ident.Set.remove\n param\n (free_variables handler))\n (free_variables body)\n | Lifthenelse(e1, e2, e3) ->\n Ident.Set.union\n (Ident.Set.union (free_variables e1) (free_variables e2))\n (free_variables e3)\n | Lsequence(e1, e2) ->\n Ident.Set.union (free_variables e1) (free_variables e2)\n | Lwhile(e1, e2) ->\n Ident.Set.union (free_variables e1) (free_variables e2)\n | Lfor(v, lo, hi, _dir, body) ->\n let set = Ident.Set.union (free_variables lo) (free_variables hi) in\n Ident.Set.union set (Ident.Set.remove v (free_variables body))\n | Lassign(id, e) ->\n Ident.Set.add id (free_variables e)\n | Lsend (_k, met, obj, args, _) ->\n free_variables_list\n (Ident.Set.union (free_variables met) (free_variables obj))\n args\n | Levent (lam, _evt) ->\n free_variables lam\n | Lifused (_v, e) ->\n (* Shouldn't v be considered a free variable ? *)\n free_variables e\n\nand free_variables_list set exprs =\n List.fold_left (fun set expr -> Ident.Set.union (free_variables expr) set)\n set exprs\n\n(* Check if an action has a \"when\" guard *)\nlet raise_count = ref 0\n\nlet next_raise_count () =\n incr raise_count ;\n !raise_count\n\n(* Anticipated staticraise, for guards *)\nlet staticfail = Lstaticraise (0,[])\n\nlet rec is_guarded = function\n | Lifthenelse(_cond, _body, Lstaticraise (0,[])) -> true\n | Llet(_str, _k, _id, _lam, body) -> is_guarded body\n | Levent(lam, _ev) -> is_guarded lam\n | _ -> false\n\nlet rec patch_guarded patch = function\n | Lifthenelse (cond, body, Lstaticraise (0,[])) ->\n Lifthenelse (cond, body, patch)\n | Llet(str, k, id, lam, body) ->\n Llet (str, k, id, lam, patch_guarded patch body)\n | Levent(lam, ev) ->\n Levent (patch_guarded patch lam, ev)\n | _ -> fatal_error \"Lambda.patch_guarded\"\n\n(* Translate an access path *)\n\nlet rec transl_address loc = function\n | Env.Aident id ->\n if Ident.global id\n then Lprim(Pgetglobal id, [], loc)\n else Lvar id\n | Env.Adot(addr, pos) ->\n Lprim(Pfield pos, [transl_address loc addr], loc)\n\nlet transl_path find loc env path =\n match find path env with\n | exception Not_found ->\n fatal_error (\"Cannot find address for: \" ^ (Path.name path))\n | addr -> transl_address loc addr\n\n(* Translation of identifiers *)\n\nlet transl_module_path loc env path =\n transl_path Env.find_module_address loc env path\n\nlet transl_value_path loc env path =\n transl_path Env.find_value_address loc env path\n\nlet transl_extension_path loc env path =\n transl_path Env.find_constructor_address loc env path\n\nlet transl_class_path loc env path =\n transl_path Env.find_class_address loc env path\n\nlet transl_prim mod_name name =\n let pers = Ident.create_persistent mod_name in\n let env = Env.add_persistent_structure pers Env.empty in\n let lid = Longident.Ldot (Longident.Lident mod_name, name) in\n match Env.find_value_by_name lid env with\n | path, _ -> transl_value_path Loc_unknown env path\n | exception Not_found ->\n fatal_error (\"Primitive \" ^ name ^ \" not found.\")\n\n(* Compile a sequence of expressions *)\n\nlet rec make_sequence fn = function\n [] -> lambda_unit\n | [x] -> fn x\n | x::rem ->\n let lam = fn x in Lsequence(lam, make_sequence fn rem)\n\n(* Apply a substitution to a lambda-term.\n Assumes that the image of the substitution is out of reach\n of the bound variables of the lambda-term (no capture). *)\n\nlet subst update_env ?(freshen_bound_variables = false) s input_lam =\n (* [s] contains a partial substitution for the free variables of the\n input term [input_lam].\n\n During our traversal of the term we maintain a second environment\n [l] with all the bound variables of [input_lam] in the current\n scope, mapped to either themselves or freshened versions of\n themselves when [freshen_bound_variables] is set. *)\n let bind id l =\n let id' = if not freshen_bound_variables then id else Ident.rename id in\n id', Ident.Map.add id id' l\n in\n let bind_many ids l =\n List.fold_right (fun (id, rhs) (ids', l) ->\n let id', l = bind id l in\n ((id', rhs) :: ids' , l)\n ) ids ([], l)\n in\n let rec subst s l lam =\n match lam with\n | Lvar id as lam ->\n begin match Ident.Map.find id l with\n | id' -> Lvar id'\n | exception Not_found ->\n (* note: as this point we know [id] is not a bound\n variable of the input term, otherwise it would belong\n to [l]; it is a free variable of the input term. *)\n begin try Ident.Map.find id s with Not_found -> lam end\n end\n | Lmutvar id as lam ->\n begin match Ident.Map.find id l with\n | id' -> Lmutvar id'\n | exception Not_found ->\n (* Note: a mutable [id] should not appear in [s].\n Keeping the behavior of Lvar case for now. *)\n begin try Ident.Map.find id s with Not_found -> lam end\n end\n | Lconst _ as l -> l\n | Lapply ap ->\n Lapply{ap with ap_func = subst s l ap.ap_func;\n ap_args = subst_list s l ap.ap_args}\n | Lfunction lf ->\n let params, l' = bind_many lf.params l in\n Lfunction {lf with params; body = subst s l' lf.body}\n | Llet(str, k, id, arg, body) ->\n let id, l' = bind id l in\n Llet(str, k, id, subst s l arg, subst s l' body)\n | Lmutlet(k, id, arg, body) ->\n let id, l' = bind id l in\n Lmutlet(k, id, subst s l arg, subst s l' body)\n | Lletrec(decl, body) ->\n let decl, l' = bind_many decl l in\n Lletrec(List.map (subst_decl s l') decl, subst s l' body)\n | Lprim(p, args, loc) -> Lprim(p, subst_list s l args, loc)\n | Lswitch(arg, sw, loc) ->\n Lswitch(subst s l arg,\n {sw with sw_consts = List.map (subst_case s l) sw.sw_consts;\n sw_blocks = List.map (subst_case s l) sw.sw_blocks;\n sw_failaction = subst_opt s l sw.sw_failaction; },\n loc)\n | Lstringswitch (arg,cases,default,loc) ->\n Lstringswitch\n (subst s l arg,\n List.map (subst_strcase s l) cases,\n subst_opt s l default,\n loc)\n | Lstaticraise (i,args) -> Lstaticraise (i, subst_list s l args)\n | Lstaticcatch(body, (id, params), handler) ->\n let params, l' = bind_many params l in\n Lstaticcatch(subst s l body, (id, params),\n subst s l' handler)\n | Ltrywith(body, exn, handler) ->\n let exn, l' = bind exn l in\n Ltrywith(subst s l body, exn, subst s l' handler)\n | Lifthenelse(e1, e2, e3) ->\n Lifthenelse(subst s l e1, subst s l e2, subst s l e3)\n | Lsequence(e1, e2) -> Lsequence(subst s l e1, subst s l e2)\n | Lwhile(e1, e2) -> Lwhile(subst s l e1, subst s l e2)\n | Lfor(v, lo, hi, dir, body) ->\n let v, l' = bind v l in\n Lfor(v, subst s l lo, subst s l hi, dir, subst s l' body)\n | Lassign(id, e) ->\n assert (not (Ident.Map.mem id s));\n let id = try Ident.Map.find id l with Not_found -> id in\n Lassign(id, subst s l e)\n | Lsend (k, met, obj, args, loc) ->\n Lsend (k, subst s l met, subst s l obj, subst_list s l args, loc)\n | Levent (lam, evt) ->\n let old_env = evt.lev_env in\n let env_updates =\n let find_in_old id = Env.find_value (Path.Pident id) old_env in\n let rebind id id' new_env =\n match find_in_old id with\n | exception Not_found -> new_env\n | vd -> Env.add_value id' vd new_env\n in\n let update_free id new_env =\n match find_in_old id with\n | exception Not_found -> new_env\n | vd -> update_env id vd new_env\n in\n Ident.Map.merge (fun id bound free ->\n match bound, free with\n | Some id', _ ->\n if Ident.equal id id' then None else Some (rebind id id')\n | None, Some _ -> Some (update_free id)\n | None, None -> None\n ) l s\n in\n let new_env =\n Ident.Map.fold (fun _id update env -> update env) env_updates old_env\n in\n Levent (subst s l lam, { evt with lev_env = new_env })\n | Lifused (id, e) ->\n let id = try Ident.Map.find id l with Not_found -> id in\n Lifused (id, subst s l e)\n and subst_list s l li = List.map (subst s l) li\n and subst_decl s l (id, exp) = (id, subst s l exp)\n and subst_case s l (key, case) = (key, subst s l case)\n and subst_strcase s l (key, case) = (key, subst s l case)\n and subst_opt s l = function\n | None -> None\n | Some e -> Some (subst s l e)\n in\n subst s Ident.Map.empty input_lam\n\nlet rename idmap lam =\n let update_env oldid vd env =\n let newid = Ident.Map.find oldid idmap in\n Env.add_value newid vd env\n in\n let s = Ident.Map.map (fun new_id -> Lvar new_id) idmap in\n subst update_env s lam\n\nlet duplicate lam =\n subst\n (fun _ _ env -> env)\n ~freshen_bound_variables:true\n Ident.Map.empty\n lam\n\nlet shallow_map f = function\n | Lvar _\n | Lmutvar _\n | Lconst _ as lam -> lam\n | Lapply { ap_func; ap_args; ap_loc; ap_tailcall;\n ap_inlined; ap_specialised } ->\n Lapply {\n ap_func = f ap_func;\n ap_args = List.map f ap_args;\n ap_loc;\n ap_tailcall;\n ap_inlined;\n ap_specialised;\n }\n | Lfunction { kind; params; return; body; attr; loc; } ->\n Lfunction { kind; params; return; body = f body; attr; loc; }\n | Llet (str, k, v, e1, e2) ->\n Llet (str, k, v, f e1, f e2)\n | Lmutlet (k, v, e1, e2) ->\n Lmutlet (k, v, f e1, f e2)\n | Lletrec (idel, e2) ->\n Lletrec (List.map (fun (v, e) -> (v, f e)) idel, f e2)\n | Lprim (p, el, loc) ->\n Lprim (p, List.map f el, loc)\n | Lswitch (e, sw, loc) ->\n Lswitch (f e,\n { sw_numconsts = sw.sw_numconsts;\n sw_consts = List.map (fun (n, e) -> (n, f e)) sw.sw_consts;\n sw_numblocks = sw.sw_numblocks;\n sw_blocks = List.map (fun (n, e) -> (n, f e)) sw.sw_blocks;\n sw_failaction = Option.map f sw.sw_failaction;\n },\n loc)\n | Lstringswitch (e, sw, default, loc) ->\n Lstringswitch (\n f e,\n List.map (fun (s, e) -> (s, f e)) sw,\n Option.map f default,\n loc)\n | Lstaticraise (i, args) ->\n Lstaticraise (i, List.map f args)\n | Lstaticcatch (body, id, handler) ->\n Lstaticcatch (f body, id, f handler)\n | Ltrywith (e1, v, e2) ->\n Ltrywith (f e1, v, f e2)\n | Lifthenelse (e1, e2, e3) ->\n Lifthenelse (f e1, f e2, f e3)\n | Lsequence (e1, e2) ->\n Lsequence (f e1, f e2)\n | Lwhile (e1, e2) ->\n Lwhile (f e1, f e2)\n | Lfor (v, e1, e2, dir, e3) ->\n Lfor (v, f e1, f e2, dir, f e3)\n | Lassign (v, e) ->\n Lassign (v, f e)\n | Lsend (k, m, o, el, loc) ->\n Lsend (k, f m, f o, List.map f el, loc)\n | Levent (l, ev) ->\n Levent (f l, ev)\n | Lifused (v, e) ->\n Lifused (v, f e)\n\nlet map f =\n let rec g lam = f (shallow_map g lam) in\n g\n\n(* To let-bind expressions to variables *)\n\nlet bind_with_value_kind str (var, kind) exp body =\n match exp with\n Lvar var' when Ident.same var var' -> body\n | _ -> Llet(str, kind, var, exp, body)\n\nlet bind str var exp body =\n bind_with_value_kind str (var, Pgenval) exp body\n\nlet negate_integer_comparison = function\n | Ceq -> Cne\n | Cne -> Ceq\n | Clt -> Cge\n | Cle -> Cgt\n | Cgt -> Cle\n | Cge -> Clt\n\nlet swap_integer_comparison = function\n | Ceq -> Ceq\n | Cne -> Cne\n | Clt -> Cgt\n | Cle -> Cge\n | Cgt -> Clt\n | Cge -> Cle\n\nlet negate_float_comparison = function\n | CFeq -> CFneq\n | CFneq -> CFeq\n | CFlt -> CFnlt\n | CFnlt -> CFlt\n | CFgt -> CFngt\n | CFngt -> CFgt\n | CFle -> CFnle\n | CFnle -> CFle\n | CFge -> CFnge\n | CFnge -> CFge\n\nlet swap_float_comparison = function\n | CFeq -> CFeq\n | CFneq -> CFneq\n | CFlt -> CFgt\n | CFnlt -> CFngt\n | CFle -> CFge\n | CFnle -> CFnge\n | CFgt -> CFlt\n | CFngt -> CFnlt\n | CFge -> CFle\n | CFnge -> CFnle\n\nlet raise_kind = function\n | Raise_regular -> \"raise\"\n | Raise_reraise -> \"reraise\"\n | Raise_notrace -> \"raise_notrace\"\n\nlet merge_inline_attributes attr1 attr2 =\n match attr1, attr2 with\n | Default_inline, _ -> Some attr2\n | _, Default_inline -> Some attr1\n | _, _ ->\n if attr1 = attr2 then Some attr1\n else None\n\nlet function_is_curried func =\n match func.kind with\n | Curried -> true\n | Tupled -> false\n\nlet find_exact_application kind ~arity args =\n match kind with\n | Curried ->\n if arity <> List.length args\n then None\n else Some args\n | Tupled ->\n begin match args with\n | [Lprim(Pmakeblock _, tupled_args, _)] ->\n if arity <> List.length tupled_args\n then None\n else Some tupled_args\n | [Lconst(Const_block (_, const_args))] ->\n if arity <> List.length const_args\n then None\n else Some (List.map (fun cst -> Lconst cst) const_args)\n | _ -> None\n end\n\nlet reset () =\n raise_count := 0\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Luc Maranget, projet Moscova, 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\ntype 'a shared = Shared of 'a | Single of 'a\n\ntype ('a, 'ctx) t_store =\n {act_get : unit -> 'a array ;\n act_get_shared : unit -> 'a shared array ;\n act_store : 'ctx -> 'a -> int ;\n act_store_shared : 'ctx -> 'a -> int ; }\n\nmodule type Stored = sig\n type t\n type key\n val compare_key : key -> key -> int\n val make_key : t -> key option\nend\n\nmodule type CtxStored = sig\n include Stored\n type context\n val make_key : context -> t -> key option\nend\n\nmodule CtxStore(A:CtxStored) = struct\n module AMap =\n Map.Make(struct type t = A.key let compare = A.compare_key end)\n\n type intern =\n { mutable map : (bool * int) AMap.t ;\n mutable next : int ;\n mutable acts : (bool * A.t) list; }\n\n let mk_store () =\n let st =\n { map = AMap.empty ;\n next = 0 ;\n acts = [] ; } in\n\n let add mustshare act =\n let i = st.next in\n st.acts <- (mustshare,act) :: st.acts ;\n st.next <- i+1 ;\n i in\n\n let store mustshare ctx act = match A.make_key ctx act with\n | Some key ->\n begin try\n let (shared,i) = AMap.find key st.map in\n if not shared then st.map <- AMap.add key (true,i) st.map ;\n i\n with Not_found ->\n let i = add mustshare act in\n st.map <- AMap.add key (mustshare,i) st.map ;\n i\n end\n | None ->\n add mustshare act\n\n and get () = Array.of_list (List.rev_map (fun (_,act) -> act) st.acts)\n\n and get_shared () =\n let acts =\n Array.of_list\n (List.rev_map\n (fun (shared,act) ->\n if shared then Shared act else Single act)\n st.acts) in\n AMap.iter\n (fun _ (shared,i) ->\n if shared then match acts.(i) with\n | Single act -> acts.(i) <- Shared act\n | Shared _ -> ())\n st.map ;\n acts in\n {act_store = store false ; act_store_shared = store true ;\n act_get = get; act_get_shared = get_shared; }\nend\n\nmodule Store(A:Stored) = struct\n module Me =\n CtxStore\n (struct\n include A\n type context = unit\n let make_key () = A.make_key\n end)\n\n let mk_store = Me.mk_store\nend\n\n\n\nmodule type S =\nsig\n type primitive\n val eqint : primitive\n val neint : primitive\n val leint : primitive\n val ltint : primitive\n val geint : primitive\n val gtint : primitive\n\n type loc\n type arg\n type test\n type act\n\n val bind : arg -> (arg -> act) -> act\n val make_const : int -> arg\n val make_offset : arg -> int -> arg\n val make_prim : primitive -> arg list -> test\n val make_isout : arg -> arg -> test\n val make_isin : arg -> arg -> test\n val make_is_nonzero : arg -> test\n val arg_as_test : arg -> test\n\n val make_if : test -> act -> act -> act\n val make_switch : loc -> arg -> int array -> act array -> act\n\n val make_catch : act -> int * (act -> act)\n val make_exit : int -> act\nend\n\n(* The module will ``produce good code for the case statement'' *)\n(*\n Adaptation of\n R.L. Berstein\n ``Producing good code for the case statement''\n Software Practice and Experience, 15(10) (1985)\n and\n D.L. Spuler\n ``Two-Way Comparison Search Trees, a Generalisation of Binary Search Trees\n and Split Trees''\n ``Compiler Code Generation for Multiway Branch Statement as\n a Static Search Problem''\n Technical Reports, James Cook University\n*)\n(*\n Main adaptation is considering interval tests\n (implemented as one addition + one unsigned test and branch)\n which leads to exhaustive search for finding the optimal\n test sequence in small cases and heuristics otherwise.\n*)\nmodule Make (Arg : S) =\nstruct\n\n type 'a inter =\n {cases : (int * int * int) array ;\n actions : 'a array}\n\n type 'a t_ctx = {off : int ; arg : 'a}\n\n let cut = ref 8\n and more_cut = ref 16\n\n(*\nlet pint chan i =\n if i = min_int then Printf.fprintf chan \"-oo\"\n else if i=max_int then Printf.fprintf chan \"oo\"\n else Printf.fprintf chan \"%d\" i\n\nlet pcases chan cases =\n for i =0 to Array.length cases-1 do\n let l,h,act = cases.(i) in\n if l=h then\n Printf.fprintf chan \"%d:%d \" l act\n else\n Printf.fprintf chan \"%a..%a:%d \" pint l pint h act\n done\n\nlet prerr_inter i = Printf.fprintf stderr\n \"cases=%a\" pcases i.cases\n*)\n\n let get_act cases i =\n let _,_,r = cases.(i) in\n r\n and get_low cases i =\n let r,_,_ = cases.(i) in\n r\n and get_high cases i =\n let _,r,_ = cases.(i) in\n r\n\n type ctests = {\n mutable n : int ;\n mutable ni : int ;\n }\n\n let too_much = {n=max_int ; ni=max_int}\n\n(*\nlet ptests chan {n=n ; ni=ni} =\n Printf.fprintf chan \"{n=%d ; ni=%d}\" n ni\n\nlet pta chan t =\n for i =0 to Array.length t-1 do\n Printf.fprintf chan \"%d: %a\\n\" i ptests t.(i)\n done\n*)\n\n let less_tests c1 c2 =\n if c1.n < c2.n then\n true\n else if c1.n = c2.n then begin\n if c1.ni < c2.ni then\n true\n else\n false\n end else\n false\n\n and eq_tests c1 c2 = c1.n = c2.n && c1.ni=c2.ni\n\n let less2tests (c1,d1) (c2,d2) =\n if eq_tests c1 c2 then\n less_tests d1 d2\n else\n less_tests c1 c2\n\n let add_test t1 t2 =\n t1.n <- t1.n + t2.n ;\n t1.ni <- t1.ni + t2.ni ;\n\n type t_ret = Inter of int * int | Sep of int | No\n\n(*\nlet pret chan = function\n | Inter (i,j)-> Printf.fprintf chan \"Inter %d %d\" i j\n | Sep i -> Printf.fprintf chan \"Sep %d\" i\n | No -> Printf.fprintf chan \"No\"\n*)\n\n let coupe cases i =\n let l,_,_ = cases.(i) in\n l,\n Array.sub cases 0 i,\n Array.sub cases i (Array.length cases-i)\n\n\n let case_append c1 c2 =\n let len1 = Array.length c1\n and len2 = Array.length c2 in\n match len1,len2 with\n | 0,_ -> c2\n | _,0 -> c1\n | _,_ ->\n let l1,h1,act1 = c1.(Array.length c1-1)\n and l2,h2,act2 = c2.(0) in\n if act1 = act2 then\n let r = Array.make (len1+len2-1) c1.(0) in\n for i = 0 to len1-2 do\n r.(i) <- c1.(i)\n done ;\n\n let l =\n if len1-2 >= 0 then begin\n let _,h,_ = r.(len1-2) in\n if h+1 < l1 then\n h+1\n else\n l1\n end else\n l1\n and h =\n if 1 < len2-1 then begin\n let l,_,_ = c2.(1) in\n if h2+1 < l then\n l-1\n else\n h2\n end else\n h2 in\n r.(len1-1) <- (l,h,act1) ;\n for i=1 to len2-1 do\n r.(len1-1+i) <- c2.(i)\n done ;\n r\n else if h1 > l1 then\n let r = Array.make (len1+len2) c1.(0) in\n for i = 0 to len1-2 do\n r.(i) <- c1.(i)\n done ;\n r.(len1-1) <- (l1,l2-1,act1) ;\n for i=0 to len2-1 do\n r.(len1+i) <- c2.(i)\n done ;\n r\n else if h2 > l2 then\n let r = Array.make (len1+len2) c1.(0) in\n for i = 0 to len1-1 do\n r.(i) <- c1.(i)\n done ;\n r.(len1) <- (h1+1,h2,act2) ;\n for i=1 to len2-1 do\n r.(len1+i) <- c2.(i)\n done ;\n r\n else\n Array.append c1 c2\n\n\n let coupe_inter i j cases =\n let lcases = Array.length cases in\n let low,_,_ = cases.(i)\n and _,high,_ = cases.(j) in\n low,high,\n Array.sub cases i (j-i+1),\n case_append (Array.sub cases 0 i) (Array.sub cases (j+1) (lcases-(j+1)))\n\n type kind = Kvalue of int | Kinter of int | Kempty\n\n(*\nlet pkind chan = function\n | Kvalue i ->Printf.fprintf chan \"V%d\" i\n | Kinter i -> Printf.fprintf chan \"I%d\" i\n | Kempty -> Printf.fprintf chan \"E\"\n\nlet rec pkey chan = function\n | [] -> ()\n | [k] -> pkind chan k\n | k::rem ->\n Printf.fprintf chan \"%a %a\" pkey rem pkind k\n*)\n\n let t = Hashtbl.create 17\n\n let make_key cases =\n let seen = ref []\n and count = ref 0 in\n let rec got_it act = function\n | [] ->\n seen := (act,!count):: !seen ;\n let r = !count in\n incr count ;\n r\n | (act0,index) :: rem ->\n if act0 = act then\n index\n else\n got_it act rem in\n\n let make_one l h act =\n if l=h then\n Kvalue (got_it act !seen)\n else\n Kinter (got_it act !seen) in\n\n let rec make_rec i pl =\n if i < 0 then\n []\n else\n let l,h,act = cases.(i) in\n if pl = h+1 then\n make_one l h act::make_rec (i-1) l\n else\n Kempty::make_one l h act::make_rec (i-1) l in\n\n let l,h,act = cases.(Array.length cases-1) in\n make_one l h act::make_rec (Array.length cases-2) l\n\n\n let same_act t =\n let len = Array.length t in\n let a = get_act t (len-1) in\n let rec do_rec i =\n if i < 0 then true\n else\n let b = get_act t i in\n b=a && do_rec (i-1) in\n do_rec (len-2)\n\n\n(*\n Interval test x in [l,h] works by checking x-l in [0,h-l]\n * This may be false for arithmetic modulo 2^31\n * Subtracting l may change the relative ordering of values\n and invalid the invariant that matched values are given in\n increasing order\n\n To avoid this, interval check is allowed only when the\n integers indeed present in the whole case interval are\n in [-2^16 ; 2^16]\n\n This condition is checked by zyva\n*)\n\n let inter_limit = 1 lsl 16\n\n let ok_inter = ref false\n\n let rec opt_count top cases =\n let key = make_key cases in\n try\n Hashtbl.find t key\n with\n | Not_found ->\n let r =\n let lcases = Array.length cases in\n match lcases with\n | 0 -> assert false\n | _ when same_act cases -> No, ({n=0; ni=0},{n=0; ni=0})\n | _ ->\n if lcases < !cut then\n enum top cases\n else if lcases < !more_cut then\n heuristic cases\n else\n divide cases in\n Hashtbl.add t key r ;\n r\n\n and divide cases =\n let lcases = Array.length cases in\n let m = lcases/2 in\n let _,left,right = coupe cases m in\n let ci = {n=1 ; ni=0}\n and cm = {n=1 ; ni=0}\n and _,(cml,cleft) = opt_count false left\n and _,(cmr,cright) = opt_count false right in\n add_test ci cleft ;\n add_test ci cright ;\n if less_tests cml cmr then\n add_test cm cmr\n else\n add_test cm cml ;\n Sep m,(cm, ci)\n\n and heuristic cases =\n let lcases = Array.length cases in\n\n let sep,csep = divide cases\n\n and inter,cinter =\n if !ok_inter then begin\n let _,_,act0 = cases.(0)\n and _,_,act1 = cases.(lcases-1) in\n if act0 = act1 then begin\n let low, high, inside, outside = coupe_inter 1 (lcases-2) cases in\n let _,(cmi,cinside) = opt_count false inside\n and _,(cmo,coutside) = opt_count false outside\n and cmij = {n=1 ; ni=(if low=high then 0 else 1)}\n and cij = {n=1 ; ni=(if low=high then 0 else 1)} in\n add_test cij cinside ;\n add_test cij coutside ;\n if less_tests cmi cmo then\n add_test cmij cmo\n else\n add_test cmij cmi ;\n Inter (1,lcases-2),(cmij,cij)\n end else\n Inter (-1,-1),(too_much, too_much)\n end else\n Inter (-1,-1),(too_much, too_much) in\n if less2tests csep cinter then\n sep,csep\n else\n inter,cinter\n\n\n and enum top cases =\n let lcases = Array.length cases in\n let lim, with_sep =\n let best = ref (-1) and best_cost = ref (too_much,too_much) in\n\n for i = 1 to lcases-(1) do\n let _,left,right = coupe cases i in\n let ci = {n=1 ; ni=0}\n and cm = {n=1 ; ni=0}\n and _,(cml,cleft) = opt_count false left\n and _,(cmr,cright) = opt_count false right in\n add_test ci cleft ;\n add_test ci cright ;\n if less_tests cml cmr then\n add_test cm cmr\n else\n add_test cm cml ;\n\n if\n less2tests (cm,ci) !best_cost\n then begin\n if top then\n Printf.fprintf stderr \"Get it: %d\\n\" i ;\n best := i ;\n best_cost := (cm,ci)\n end\n done ;\n !best, !best_cost in\n\n let ilow, ihigh, with_inter =\n if not !ok_inter then\n let rlow = ref (-1) and rhigh = ref (-1)\n and best_cost= ref (too_much,too_much) in\n for i=1 to lcases-2 do\n let low, high, inside, outside = coupe_inter i i cases in\n if low=high then begin\n let _,(cmi,cinside) = opt_count false inside\n and _,(cmo,coutside) = opt_count false outside\n and cmij = {n=1 ; ni=0}\n and cij = {n=1 ; ni=0} in\n add_test cij cinside ;\n add_test cij coutside ;\n if less_tests cmi cmo then\n add_test cmij cmo\n else\n add_test cmij cmi ;\n if less2tests (cmij,cij) !best_cost then begin\n rlow := i ;\n rhigh := i ;\n best_cost := (cmij,cij)\n end\n end\n done ;\n !rlow, !rhigh, !best_cost\n else\n let rlow = ref (-1) and rhigh = ref (-1)\n and best_cost= ref (too_much,too_much) in\n for i=1 to lcases-2 do\n for j=i to lcases-2 do\n let low, high, inside, outside = coupe_inter i j cases in\n let _,(cmi,cinside) = opt_count false inside\n and _,(cmo,coutside) = opt_count false outside\n and cmij = {n=1 ; ni=(if low=high then 0 else 1)}\n and cij = {n=1 ; ni=(if low=high then 0 else 1)} in\n add_test cij cinside ;\n add_test cij coutside ;\n if less_tests cmi cmo then\n add_test cmij cmo\n else\n add_test cmij cmi ;\n if less2tests (cmij,cij) !best_cost then begin\n rlow := i ;\n rhigh := j ;\n best_cost := (cmij,cij)\n end\n done\n done ;\n !rlow, !rhigh, !best_cost in\n let r = ref (Inter (ilow,ihigh)) and rc = ref with_inter in\n if less2tests with_sep !rc then begin\n r := Sep lim ; rc := with_sep\n end ;\n !r, !rc\n\n let make_if_test test arg i ifso ifnot =\n Arg.make_if\n (Arg.make_prim test [arg ; Arg.make_const i])\n ifso ifnot\n\n let make_if_lt arg i ifso ifnot = match i with\n | 1 ->\n make_if_test Arg.leint arg 0 ifso ifnot\n | _ ->\n make_if_test Arg.ltint arg i ifso ifnot\n\n and make_if_ge arg i ifso ifnot = match i with\n | 1 ->\n make_if_test Arg.gtint arg 0 ifso ifnot\n | _ ->\n make_if_test Arg.geint arg i ifso ifnot\n\n and make_if_eq arg i ifso ifnot =\n make_if_test Arg.eqint arg i ifso ifnot\n\n and make_if_ne arg i ifso ifnot =\n make_if_test Arg.neint arg i ifso ifnot\n\n let make_if_nonzero arg ifso ifnot =\n Arg.make_if (Arg.make_is_nonzero arg) ifso ifnot\n\n let make_if_bool arg ifso ifnot =\n Arg.make_if (Arg.arg_as_test arg) ifso ifnot\n\n let do_make_if_out h arg ifso ifno =\n Arg.make_if (Arg.make_isout h arg) ifso ifno\n\n let make_if_out ctx l d mk_ifso mk_ifno = match l with\n | 0 ->\n do_make_if_out\n (Arg.make_const d) ctx.arg (mk_ifso ctx) (mk_ifno ctx)\n | _ ->\n Arg.bind\n (Arg.make_offset ctx.arg (-l))\n (fun arg ->\n let ctx = {off= (-l+ctx.off) ; arg=arg} in\n do_make_if_out\n (Arg.make_const d) arg (mk_ifso ctx) (mk_ifno ctx))\n\n let do_make_if_in h arg ifso ifno =\n Arg.make_if (Arg.make_isin h arg) ifso ifno\n\n let make_if_in ctx l d mk_ifso mk_ifno = match l with\n | 0 ->\n do_make_if_in\n (Arg.make_const d) ctx.arg (mk_ifso ctx) (mk_ifno ctx)\n | _ ->\n Arg.bind\n (Arg.make_offset ctx.arg (-l))\n (fun arg ->\n let ctx = {off= (-l+ctx.off) ; arg=arg} in\n do_make_if_in\n (Arg.make_const d) arg (mk_ifso ctx) (mk_ifno ctx))\n\n let rec c_test ctx ({cases=cases ; actions=actions} as s) =\n let lcases = Array.length cases in\n assert(lcases > 0) ;\n if lcases = 1 then\n actions.(get_act cases 0) ctx\n\n else begin\n\n let w,_c = opt_count false cases in\n(*\n Printf.fprintf stderr\n \"off=%d tactic=%a for %a\\n\"\n ctx.off pret w pcases cases ;\n *)\n match w with\n | No -> actions.(get_act cases 0) ctx\n | Inter (i,j) ->\n let low,high,inside, outside = coupe_inter i j cases in\n let _,(cinside,_) = opt_count false inside\n and _,(coutside,_) = opt_count false outside in\n (* Costs are retrieved to put the code with more remaining tests\n in the privileged (positive) branch of ``if'' *)\n if low=high then begin\n if less_tests coutside cinside then\n make_if_eq\n ctx.arg\n (low+ctx.off)\n (c_test ctx {s with cases=inside})\n (c_test ctx {s with cases=outside})\n else\n make_if_ne\n ctx.arg\n (low+ctx.off)\n (c_test ctx {s with cases=outside})\n (c_test ctx {s with cases=inside})\n end else begin\n if less_tests coutside cinside then\n make_if_in\n ctx\n (low+ctx.off)\n (high-low)\n (fun ctx -> c_test ctx {s with cases=inside})\n (fun ctx -> c_test ctx {s with cases=outside})\n else\n make_if_out\n ctx\n (low+ctx.off)\n (high-low)\n (fun ctx -> c_test ctx {s with cases=outside})\n (fun ctx -> c_test ctx {s with cases=inside})\n end\n | Sep i ->\n let lim,left,right = coupe cases i in\n let _,(cleft,_) = opt_count false left\n and _,(cright,_) = opt_count false right in\n let left = {s with cases=left}\n and right = {s with cases=right} in\n\n if i=1 && (lim+ctx.off)=1 && get_low cases 0+ctx.off=0 then\n if lcases = 2 && get_high cases 1+ctx.off = 1 then\n make_if_bool\n ctx.arg\n (c_test ctx right) (c_test ctx left)\n else\n make_if_nonzero\n ctx.arg\n (c_test ctx right) (c_test ctx left)\n else if less_tests cright cleft then\n make_if_lt\n ctx.arg (lim+ctx.off)\n (c_test ctx left) (c_test ctx right)\n else\n make_if_ge\n ctx.arg (lim+ctx.off)\n (c_test ctx right) (c_test ctx left)\n\n end\n\n\n (* Minimal density of switches *)\n let theta = ref 0.33333\n\n (* Minimal number of tests to make a switch *)\n let switch_min = ref 3\n\n (* Particular case 0, 1, 2 *)\n let particular_case cases i j =\n j-i = 2 &&\n (let l1,_h1,act1 = cases.(i)\n and l2,_h2,_act2 = cases.(i+1)\n and l3,h3,act3 = cases.(i+2) in\n l1+1=l2 && l2+1=l3 && l3=h3 &&\n act1 <> act3)\n\n let approx_count cases i j =\n let l = j-i+1 in\n if l < !cut then\n let _,(_,{n=ntests}) = opt_count false (Array.sub cases i l) in\n ntests\n else\n l-1\n\n (* Sends back a boolean that says whether is switch is worth or not *)\n\n let dense {cases} i j =\n if i=j then true\n else\n let l,_,_ = cases.(i)\n and _,h,_ = cases.(j) in\n let ntests = approx_count cases i j in\n(*\n (ntests+1) >= theta * (h-l+1)\n*)\n particular_case cases i j ||\n (ntests >= !switch_min &&\n float_of_int ntests +. 1.0 >=\n !theta *. (float_of_int h -. float_of_int l +. 1.0))\n\n (* Compute clusters by dynamic programming\n Adaptation of the correction to Bernstein\n ``Correction to `Producing Good Code for the Case Statement' ''\n S.K. Kannan and T.A. Proebsting\n Software Practice and Experience Vol. 24(2) 233 (Feb 1994)\n *)\n\n let comp_clusters s =\n let len = Array.length s.cases in\n let min_clusters = Array.make len max_int\n and k = Array.make len 0 in\n let get_min i = if i < 0 then 0 else min_clusters.(i) in\n\n for i = 0 to len-1 do\n for j = 0 to i do\n if\n dense s j i &&\n get_min (j-1) + 1 < min_clusters.(i)\n then begin\n k.(i) <- j ;\n min_clusters.(i) <- get_min (j-1) + 1\n end\n done ;\n done ;\n min_clusters.(len-1),k\n\n (* Assume j > i *)\n let make_switch loc {cases=cases ; actions=actions} i j =\n let ll,_,_ = cases.(i)\n and _,hh,_ = cases.(j) in\n let tbl = Array.make (hh-ll+1) 0\n and t = Hashtbl.create 17\n and index = ref 0 in\n let get_index act =\n try\n Hashtbl.find t act\n with\n | Not_found ->\n let i = !index in\n incr index ;\n Hashtbl.add t act i ;\n i in\n\n for k=i to j do\n let l,h,act = cases.(k) in\n let index = get_index act in\n for kk=l-ll to h-ll do\n tbl.(kk) <- index\n done\n done ;\n let acts = Array.make !index actions.(0) in\n Hashtbl.iter\n (fun act i -> acts.(i) <- actions.(act))\n t ;\n (fun ctx ->\n match -ll-ctx.off with\n | 0 -> Arg.make_switch loc ctx.arg tbl acts\n | _ ->\n Arg.bind\n (Arg.make_offset ctx.arg (-ll-ctx.off))\n (fun arg -> Arg.make_switch loc arg tbl acts))\n\n\n let make_clusters loc ({cases=cases ; actions=actions} as s) n_clusters k =\n let len = Array.length cases in\n let r = Array.make n_clusters (0,0,0)\n and t = Hashtbl.create 17\n and index = ref 0\n and bidon = ref (Array.length actions) in\n let get_index act =\n try\n let i,_ = Hashtbl.find t act in\n i\n with\n | Not_found ->\n let i = !index in\n incr index ;\n Hashtbl.add\n t act\n (i,(fun _ -> actions.(act))) ;\n i\n and add_index act =\n let i = !index in\n incr index ;\n incr bidon ;\n Hashtbl.add t !bidon (i,act) ;\n i in\n\n let rec zyva j ir =\n let i = k.(j) in\n begin if i=j then\n let l,h,act = cases.(i) in\n r.(ir) <- (l,h,get_index act)\n else (* assert i < j *)\n let l,_,_ = cases.(i)\n and _,h,_ = cases.(j) in\n r.(ir) <- (l,h,add_index (make_switch loc s i j))\n end ;\n if i > 0 then zyva (i-1) (ir-1) in\n\n zyva (len-1) (n_clusters-1) ;\n let acts = Array.make !index (fun _ -> assert false) in\n Hashtbl.iter (fun _ (i,act) -> acts.(i) <- act) t ;\n {cases = r ; actions = acts}\n ;;\n\n\n let do_zyva loc (low,high) arg cases actions =\n let old_ok = !ok_inter in\n ok_inter := (abs low <= inter_limit && abs high <= inter_limit) ;\n if !ok_inter <> old_ok then Hashtbl.clear t ;\n\n let s = {cases=cases ; actions=actions} in\n\n(*\n Printf.eprintf \"ZYVA: %B [low=%i,high=%i]\\n\" !ok_inter low high ;\n pcases stderr cases ;\n prerr_endline \"\" ;\n*)\n let n_clusters,k = comp_clusters s in\n let clusters = make_clusters loc s n_clusters k in\n c_test {arg=arg ; off=0} clusters\n\n let abstract_shared actions =\n let handlers = ref (fun x -> x) in\n let actions =\n Array.map\n (fun act -> match act with\n | Single act -> act\n | Shared act ->\n let i,h = Arg.make_catch act in\n let oh = !handlers in\n handlers := (fun act -> h (oh act)) ;\n Arg.make_exit i)\n actions in\n !handlers,actions\n\n let zyva loc lh arg cases actions =\n assert (Array.length cases > 0) ;\n let actions = actions.act_get_shared () in\n let hs,actions = abstract_shared actions in\n hs (do_zyva loc lh arg cases actions)\n\n and test_sequence arg cases actions =\n assert (Array.length cases > 0) ;\n let actions = actions.act_get_shared () in\n let hs,actions = abstract_shared actions in\n let old_ok = !ok_inter in\n ok_inter := false ;\n if !ok_inter <> old_ok then Hashtbl.clear t ;\n let s =\n {cases=cases ;\n actions=Array.map (fun act -> (fun _ -> act)) actions} in\n(*\n Printf.eprintf \"SEQUENCE: %B\\n\" !ok_inter ;\n pcases stderr cases ;\n prerr_endline \"\" ;\n*)\n hs (c_test {arg=arg ; off=0} s)\n ;;\n\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(* Compilation of pattern matching\n\n Based upon Lefessant-Maranget ``Optimizing Pattern-Matching'' ICFP'2001.\n\n A previous version was based on Peyton-Jones, ``The Implementation of\n functional programming languages'', chapter 5.\n\n\n Overview of the implementation\n ==============================\n\n 1. Precompilation\n -----------------\n\n (split_and_precompile)\n We first split the initial pattern matching (or \"pm\") along its first column\n -- simplifying pattern heads in the process --, so that we obtain an ordered\n list of pms.\n For every pm in this list, and any two patterns in its first column, either\n the patterns have the same head, or their heads match disjoint sets of\n values. (In particular, two extension constructors that may or may not be\n equal due to hidden rebinding cannot occur in the same simple pm.)\n\n 2. Compilation\n --------------\n\n The compilation of one of these pms obtained after precompiling is done as\n follows:\n\n (divide)\n We split the match along the first column again, this time grouping rows\n which start with the same head, and removing the first column.\n As a result we get a \"division\", which is a list a \"cells\" of the form:\n discriminating pattern head * specialized pm\n\n (compile_list + compile_match)\n We then map over the division to compile each cell: we simply restart the\n whole process on the second element of each cell.\n Each cell is now of the form:\n discriminating pattern head * lambda\n\n (combine_constant, combine_construct, combine_array, ...)\n We recombine the cells using a switch or some ifs, and if the matching can\n fail, introduce a jump to the next pm that could potentially match the\n scrutiny.\n\n 3. Chaining of pms\n ------------------\n\n (comp_match_handlers)\n Once the pms have been compiled, we stitch them back together in the order\n produced by precompilation, resulting in the following structure:\n {v\n catch\n catch\n \n with ->\n \n with ->\n \n v}\n\n Additionally, bodies whose corresponding exit-number is never used are\n discarded. So for instance, if in the pseudo-example above we know that exit\n [i] is never taken, we would actually generate:\n {v\n catch\n \n with ->\n \n v}\n\n*)\n\nopen Misc\nopen Asttypes\nopen Types\nopen Typedtree\nopen Lambda\nopen Parmatch\nopen Printf\nopen Printpat\n\nmodule Scoped_location = Debuginfo.Scoped_location\n\nlet dbg = false\n\n(*\n Compatibility predicate that considers potential rebindings of constructors\n of an extension type.\n\n \"may_compat p q\" returns false when p and q never admit a common instance;\n returns true when they may have a common instance.\n*)\n\nmodule MayCompat = Parmatch.Compat (struct\n let equal = Types.may_equal_constr\nend)\n\nlet may_compat = MayCompat.compat\n\nand may_compats = MayCompat.compats\n\n(*\n Many functions on the various data structures of the algorithm :\n - Pattern matrices.\n - Default environments: mapping from matrices to exit numbers.\n - Contexts: matrices whose column are partitioned into\n left and right.\n - Jump summaries: mapping from exit numbers to contexts\n*)\n\nlet string_of_lam lam =\n Printlambda.lambda Format.str_formatter lam;\n Format.flush_str_formatter ()\n\nlet all_record_args lbls =\n match lbls with\n | [] -> fatal_error \"Matching.all_record_args\"\n | (_, { lbl_all }, _) :: _ ->\n let t =\n Array.map\n (fun lbl ->\n (mknoloc (Longident.Lident \"?temp?\"), lbl, Patterns.omega))\n lbl_all\n in\n List.iter (fun ((_, lbl, _) as x) -> t.(lbl.lbl_pos) <- x) lbls;\n Array.to_list t\n\nlet expand_record_head h =\n let open Patterns.Head in\n match h.pat_desc with\n | Record [] -> fatal_error \"Matching.expand_record_head\"\n | Record ({ lbl_all } :: _) ->\n { h with pat_desc = Record (Array.to_list lbl_all) }\n | _ -> h\n\nlet bind_alias p id ~arg ~action =\n let k = Typeopt.value_kind p.pat_env p.pat_type in\n bind_with_value_kind Alias (id, k) arg action\n\nlet head_loc ~scopes head =\n Scoped_location.of_location ~scopes head.pat_loc\n\ntype 'a clause = 'a * lambda\n\nlet map_on_row f (row, action) = (f row, action)\n\nlet map_on_rows f = List.map (map_on_row f)\n\nmodule Non_empty_row = Patterns.Non_empty_row\n\nmodule General = struct\n include Patterns.General\n\n type nonrec clause = pattern Non_empty_row.t clause\nend\n\nmodule Half_simple : sig\n include module type of Patterns.Half_simple\n (** Half-simplified patterns are patterns where:\n - records are expanded so that they possess all fields\n - aliases are removed and replaced by bindings in actions.\n\n Or-patterns are not removed, they are only \"half-simplified\":\n - aliases under or-patterns are kept\n - or-patterns whose right-hand-side is subsumed by their lhs\n are simplified to their lhs.\n For instance: [(_ :: _ | 1 :: _)] is changed into [_ :: _]\n - or-patterns whose left-hand-side is not simplified\n are preserved: (p|q) is changed into (simpl(p)|simpl(q))\n {v\n # match lazy (print_int 3; 3) with _ | lazy 2 -> ();;\n - : unit = ()\n # match lazy (print_int 3; 3) with lazy 2 | _ -> ();;\n 3- : unit = ()\n v}\n\n In particular, or-patterns may still occur in the leading column,\n so this is only a \"half-simplification\". *)\n\n type nonrec clause = pattern Non_empty_row.t clause\n\n val of_clause : arg:lambda -> General.clause -> clause\nend = struct\n include Patterns.Half_simple\n\n type nonrec clause = pattern Non_empty_row.t clause\n\n let rec simpl_under_orpat p =\n match p.pat_desc with\n | Tpat_any\n | Tpat_var _ ->\n p\n | Tpat_alias (q, id, s) ->\n { p with pat_desc = Tpat_alias (simpl_under_orpat q, id, s) }\n | Tpat_or (p1, p2, o) ->\n let p1, p2 = (simpl_under_orpat p1, simpl_under_orpat p2) in\n if le_pat p1 p2 then\n p1\n else\n { p with pat_desc = Tpat_or (p1, p2, o) }\n | Tpat_record (lbls, closed) ->\n let all_lbls = all_record_args lbls in\n { p with pat_desc = Tpat_record (all_lbls, closed) }\n | _ -> p\n\n (* Explode or-patterns and turn aliases into bindings in actions *)\n let of_clause ~arg cl =\n let rec aux (((p, patl), action) : General.clause) : clause =\n let continue p (view : General.view) : clause =\n aux (({ p with pat_desc = view }, patl), action)\n in\n let stop p (view : view) : clause =\n (({ p with pat_desc = view }, patl), action)\n in\n match p.pat_desc with\n | `Any -> stop p `Any\n | `Var (id, s) -> continue p (`Alias (Patterns.omega, id, s))\n | `Alias (p, id, _) ->\n aux\n ( (General.view p, patl),\n bind_alias p id ~arg ~action )\n | `Record ([], _) as view -> stop p view\n | `Record (lbls, closed) ->\n let full_view = `Record (all_record_args lbls, closed) in\n stop p full_view\n | `Or _ -> (\n let orpat = General.view (simpl_under_orpat (General.erase p)) in\n match orpat.pat_desc with\n | `Or _ as or_view -> stop orpat or_view\n | other_view -> continue orpat other_view\n )\n | ( `Constant _ | `Tuple _ | `Construct _ | `Variant _ | `Array _\n | `Lazy _ ) as view ->\n stop p view\n in\n aux cl\nend\n\nexception Cannot_flatten\n\nmodule Simple : sig\n include module type of Patterns.Simple\n\n type nonrec clause = pattern Non_empty_row.t clause\n\n val head : pattern -> Patterns.Head.t\n\n val explode_or_pat :\n arg:lambda ->\n Half_simple.pattern ->\n mk_action:(vars:Ident.t list -> lambda) ->\n patbound_action_vars:Ident.t list ->\n (pattern * lambda) list\nend = struct\n include Patterns.Simple\n\n type nonrec clause = pattern Non_empty_row.t clause\n\n let head p = fst (Patterns.Head.deconstruct p)\n\n let alpha env (p : pattern) : pattern =\n let alpha_pat env p = Typedtree.alpha_pat env p in\n let pat_desc =\n match p.pat_desc with\n | `Any -> `Any\n | `Constant cst -> `Constant cst\n | `Tuple ps -> `Tuple (List.map (alpha_pat env) ps)\n | `Construct (cstr, cst_descr, args) ->\n `Construct (cstr, cst_descr, List.map (alpha_pat env) args)\n | `Variant (cstr, argo, row_desc) ->\n `Variant (cstr, Option.map (alpha_pat env) argo, row_desc)\n | `Record (fields, closed) ->\n let alpha_field env (lid, l, p) = (lid, l, alpha_pat env p) in\n `Record (List.map (alpha_field env) fields, closed)\n | `Array ps -> `Array (List.map (alpha_pat env) ps)\n | `Lazy p -> `Lazy (alpha_pat env p)\n in\n { p with pat_desc }\n\n (* Consider the following matching problem involving a half-simple pattern,\n with an or-pattern and as-patterns below it:\n\n match arg, other-args with\n | (Foo(y, z) as x | Bar(x, y) as z), other-pats -> action[x,y,z]\n\n (action[x,y,z] is some right-hand-side expression using x, y and z,\n but we assume that it uses no variables from [other-pats]).\n\n [explode_or_pat] explodes this into the following:\n\n match arg, other-args with\n | Foo(y1, z1), other-pats -> let x1 = arg in action[x1,y1,z1]\n | Bar(x2, y2), other-pats -> let z2 = arg in action[x2,y2,z2]\n\n notice that the binding occurrences of x,y,z are alpha-renamed with\n fresh variables x1,y1,z1 and x2,y2,z2.\n\n We assume that it is fine to duplicate the argument [arg] in each\n exploded branch; in most cases it is a variable (in which case\n the bindings [let x1 = arg] are inlined on the fly), except when\n compiling in [do_for_multiple_match] where it is a tuple of\n variables.\n *)\n let explode_or_pat ~arg (p : Half_simple.pattern)\n ~mk_action ~patbound_action_vars\n : (pattern * lambda) list =\n let rec explode p aliases rem =\n let split_explode p aliases rem = explode (General.view p) aliases rem in\n match p.pat_desc with\n | `Or (p1, p2, _) ->\n split_explode p1 aliases (split_explode p2 aliases rem)\n | `Alias (p, id, _) -> split_explode p (id :: aliases) rem\n | `Var (id, str) ->\n explode\n { p with pat_desc = `Alias (Patterns.omega, id, str) }\n aliases rem\n | #view as view ->\n (* We are doing two things here:\n - we freshen the variables of the pattern, to\n avoid reusing the same identifier in distinct exploded\n branches\n - we bind the variables in [aliases] to the argument [arg]\n (the other variables are bound by [view]); to avoid\n code duplication if [arg] is itself not a variable, we\n generate a binding for it, but only if the binding is\n needed.\n\n We are careful to avoid binding [arg] if not needed due\n to the {!do_for_multiple_match} usage, which tries to\n compile a tuple pattern [match e1, .. en with ...]\n without allocating the tuple [(e1, .., en)].\n *)\n let rec fresh_clause arg_id action_vars renaming_env = function\n | [] ->\n let fresh_pat = alpha renaming_env { p with pat_desc = view } in\n let fresh_action = mk_action ~vars:(List.rev action_vars) in\n (fresh_pat, fresh_action)\n | pat_id :: rem_vars ->\n if not (List.mem pat_id aliases) then begin\n let fresh_id = Ident.rename pat_id in\n let action_vars = fresh_id :: action_vars in\n let renaming_env = ((pat_id, fresh_id) :: renaming_env) in\n fresh_clause arg_id action_vars renaming_env rem_vars\n end else begin match arg_id, arg with\n | Some id, _\n | None, Lvar id ->\n let action_vars = id :: action_vars in\n fresh_clause arg_id action_vars renaming_env rem_vars\n | None, _ ->\n (* [pat_id] is a name used locally to refer to the argument,\n so it makes sense to reuse it (refreshed) *)\n let id = Ident.rename pat_id in\n let action_vars = (id :: action_vars) in\n let pat, action =\n fresh_clause (Some id) action_vars renaming_env rem_vars\n in\n pat, bind_alias pat id ~arg ~action\n end\n in\n fresh_clause None [] [] patbound_action_vars :: rem\n in\n explode (p : Half_simple.pattern :> General.pattern) [] []\nend\n\nlet expand_record_simple : Simple.pattern -> Simple.pattern =\n fun p ->\n match p.pat_desc with\n | `Record (l, _) -> { p with pat_desc = `Record (all_record_args l, Closed) }\n | _ -> p\n\ntype initial_clause = pattern list clause\n\ntype matrix = pattern list list\n\nlet add_omega_column pss = List.map (fun ps -> Patterns.omega :: ps) pss\n\nlet rec rev_split_at n ps =\n if n <= 0 then\n ([], ps)\n else\n match ps with\n | p :: rem ->\n let left, right = rev_split_at (n - 1) rem in\n (p :: left, right)\n | _ -> assert false\n\nexception NoMatch\n\nlet matcher discr (p : Simple.pattern) rem =\n let discr = expand_record_head discr in\n let p = expand_record_simple p in\n let omegas = Patterns.(omegas (Head.arity discr)) in\n let ph, args = Patterns.Head.deconstruct p in\n let yes () = args @ rem in\n let no () = raise NoMatch in\n let yesif b =\n if b then\n yes ()\n else\n no ()\n in\n let open Patterns.Head in\n match (discr.pat_desc, ph.pat_desc) with\n | Any, _ -> rem\n | ( ( Constant _ | Construct _ | Variant _ | Lazy | Array _ | Record _\n | Tuple _ ),\n Any ) ->\n omegas @ rem\n | Constant cst, Constant cst' -> yesif (const_compare cst cst' = 0)\n | Constant _, (Construct _ | Variant _ | Lazy | Array _ | Record _ | Tuple _)\n ->\n no ()\n | Construct cstr, Construct cstr' ->\n (* NB: may_equal_constr considers (potential) constructor rebinding;\n Types.may_equal_constr does check that the arities are the same,\n preserving row-size coherence. *)\n yesif (Types.may_equal_constr cstr cstr')\n | Construct _, (Constant _ | Variant _ | Lazy | Array _ | Record _ | Tuple _)\n ->\n no ()\n | Variant { tag; has_arg }, Variant { tag = tag'; has_arg = has_arg' } ->\n yesif (tag = tag' && has_arg = has_arg')\n | Variant _, (Constant _ | Construct _ | Lazy | Array _ | Record _ | Tuple _)\n ->\n no ()\n | Array n1, Array n2 -> yesif (n1 = n2)\n | Array _, (Constant _ | Construct _ | Variant _ | Lazy | Record _ | Tuple _)\n ->\n no ()\n | Tuple n1, Tuple n2 -> yesif (n1 = n2)\n | Tuple _, (Constant _ | Construct _ | Variant _ | Lazy | Array _ | Record _)\n ->\n no ()\n | Record l, Record l' ->\n (* we already expanded the record fully *)\n yesif (List.length l = List.length l')\n | Record _, (Constant _ | Construct _ | Variant _ | Lazy | Array _ | Tuple _)\n ->\n no ()\n | Lazy, Lazy -> yes ()\n | Lazy, (Constant _ | Construct _ | Variant _ | Array _ | Record _ | Tuple _)\n ->\n no ()\n\nlet ncols = function\n | [] -> 0\n | ps :: _ -> List.length ps\n\nmodule Context : sig\n type t\n\n val empty : t\n\n val is_empty : t -> bool\n\n val start : int -> t\n\n val eprintf : t -> unit\n\n val specialize : Patterns.Head.t -> t -> t\n\n val lshift : t -> t\n\n val rshift : t -> t\n\n val rshift_num : int -> t -> t\n\n val lub : pattern -> t -> t\n\n val matches : t -> matrix -> bool\n\n val combine : t -> t\n\n val select_columns : matrix -> t -> t\n\n val union : t -> t -> t\nend = struct\n module Row = struct\n type t = { left : pattern list; right : pattern list }\n\n let eprintf { left; right } =\n Format.eprintf \"LEFT:%a RIGHT:%a\\n\" pretty_line left pretty_line right\n\n let le c1 c2 = le_pats c1.left c2.left && le_pats c1.right c2.right\n\n let lshift { left; right } =\n match right with\n | x :: xs -> { left = x :: left; right = xs }\n | _ -> assert false\n\n let lforget { left; right } =\n match right with\n | _ :: xs -> { left = Patterns.omega :: left; right = xs }\n | _ -> assert false\n\n let rshift { left; right } =\n match left with\n | p :: ps -> { left = ps; right = p :: right }\n | _ -> assert false\n\n let rshift_num n { left; right } =\n let shifted, left = rev_split_at n left in\n { left; right = shifted @ right }\n\n (** Recombination of contexts (eg: (_,_)::p1::p2::rem -> (p1,p2)::rem)\n All mutable fields are replaced by '_', since side-effects in\n guards can alter these fields *)\n let combine { left; right } =\n match left with\n | p :: ps -> { left = ps; right = set_args_erase_mutable p right }\n | _ -> assert false\n end\n\n type t = Row.t list\n\n let empty = []\n\n let start n : t = [ { left = []; right = Patterns.omegas n } ]\n\n let is_empty = function\n | [] -> true\n | _ -> false\n\n let eprintf ctx = List.iter Row.eprintf ctx\n\n let lshift ctx =\n if List.length ctx < !Clflags.match_context_rows then\n List.map Row.lshift ctx\n else\n (* Context pruning *)\n get_mins Row.le (List.map Row.lforget ctx)\n\n let rshift ctx = List.map Row.rshift ctx\n\n let rshift_num n ctx = List.map (Row.rshift_num n) ctx\n\n let combine ctx = List.map Row.combine ctx\n\n let specialize head ctx =\n let non_empty = function\n | { Row.left = _; right = [] } ->\n fatal_error \"Matching.Context.specialize\"\n | { Row.left; right = p :: ps } -> (left, p, ps)\n in\n let ctx = List.map non_empty ctx in\n let rec filter_rec = function\n | [] -> []\n | (left, p, right) :: rem -> (\n let p = General.view p in\n match p.pat_desc with\n | `Or (p1, p2, _) ->\n filter_rec ((left, p1, right) :: (left, p2, right) :: rem)\n | `Alias (p, _, _) -> filter_rec ((left, p, right) :: rem)\n | `Var _ -> filter_rec ((left, Patterns.omega, right) :: rem)\n | #Simple.view as view -> (\n let p = { p with pat_desc = view } in\n match matcher head p right with\n | exception NoMatch -> filter_rec rem\n | right ->\n let left = Patterns.Head.to_omega_pattern head :: left in\n { Row.left; right }\n :: filter_rec rem\n )\n )\n in\n filter_rec ctx\n\n let select_columns pss ctx =\n let n = ncols pss in\n let lub_row ps { Row.left; right } =\n let transfer, right = rev_split_at n right in\n match lubs transfer ps with\n | exception Empty -> None\n | inter -> Some { Row.left = inter @ left; right }\n in\n let lub_with_ctx ps = List.filter_map (lub_row ps) ctx in\n List.flatten (List.map lub_with_ctx pss)\n\n let lub p ctx =\n List.filter_map\n (fun { Row.left; right } ->\n match right with\n | q :: rem -> (\n try Some { Row.left; right = lub p q :: rem } with Empty -> None\n )\n | _ -> fatal_error \"Matching.Context.lub\")\n ctx\n\n let matches ctx pss =\n List.exists\n (fun { Row.right = qs } -> List.exists (fun ps -> may_compats qs ps) pss)\n ctx\n\n let union pss qss = get_mins Row.le (pss @ qss)\nend\n\nlet rec flatten_pat_line size p k =\n match p.pat_desc with\n | Tpat_any | Tpat_var _ -> Patterns.omegas size :: k\n | Tpat_tuple args -> args :: k\n | Tpat_or (p1, p2, _) ->\n flatten_pat_line size p1 (flatten_pat_line size p2 k)\n | Tpat_alias (p, _, _) ->\n (* Note: we are only called from flatten_matrix,\n which is itself only ever used in places\n where variables do not matter (default environments,\n \"provenance\", etc.). *)\n flatten_pat_line size p k\n | _ -> fatal_error \"Matching.flatten_pat_line\"\n\nlet flatten_matrix size pss =\n List.fold_right\n (fun ps r ->\n match ps with\n | [ p ] -> flatten_pat_line size p r\n | _ -> fatal_error \"Matching.flatten_matrix\")\n pss []\n\n(** A default environment (referred to as \"reachable trap handlers\" in the\n paper), is an ordered list of [matrix * raise_num] pairs, and is used to\n decide where to jump next if none of the rows in a given matrix match the\n input.\n\n In such situations, one thing you can do is to jump to the first (leftmost)\n [raise_num] in that list (by doing a raise to the static-cach handler number\n [raise_num]); and you can assume that if the associated pm doesn't match\n either, it will do the same thing, etc.\n This is what [mk_failaction_neg] (and its callers) does.\n\n A more sophisticated alternative is to use what you know about the input\n (what you might already have matched) and the current pm (what you know you\n can't match) to directly jump to a pm that might match it instead of the\n next one; that is why we don't just keep [raise_num]s but also the\n associated matrices.\n [mk_failaction_pos] does (a slightly more sophisticated version of) this.\n*)\nmodule Default_environment : sig\n type t\n\n val is_empty : t -> bool\n\n val pop : t -> ((matrix * int) * t) option\n\n val empty : t\n\n val cons : matrix -> int -> t -> t\n\n val specialize : Patterns.Head.t -> t -> t\n\n val pop_column : t -> t\n\n val pop_compat : pattern -> t -> t\n\n val flatten : int -> t -> t\n\n val pp : t -> unit\nend = struct\n type t = (matrix * int) list\n (** All matrices in the list should have the same arity -- their rows should\n have the same number of columns -- as it should match the arity of the\n current scrutiny vector. *)\n\n let empty = []\n\n let is_empty = function\n | [] -> true\n | _ -> false\n\n let cons matrix raise_num default =\n match matrix with\n | [] -> default\n | _ -> (matrix, raise_num) :: default\n\n let specialize_matrix arity matcher pss =\n let rec filter_rec = function\n | [] -> []\n | (p, ps) :: rem -> (\n let p = General.view p in\n match p.pat_desc with\n | `Alias (p, _, _) -> filter_rec ((p, ps) :: rem)\n | `Var _ -> filter_rec ((Patterns.omega, ps) :: rem)\n | `Or (p1, p2, _) -> filter_rec_or p1 p2 ps rem\n | #Simple.view as view -> (\n let p = { p with pat_desc = view } in\n match matcher p ps with\n | exception NoMatch -> filter_rec rem\n | specialized ->\n assert (List.length specialized = List.length ps + arity);\n specialized :: filter_rec rem\n )\n )\n\n (* Filter just one row, without a `rem` accumulator\n of further rows to process.\n The following equality holds:\n filter_rec ((p :: ps) :: rem)\n = filter_one p ps @ filter_rec rem\n *)\n and filter_one p ps =\n filter_rec [ (p, ps) ]\n\n and filter_rec_or p1 p2 ps rem =\n match arity with\n | 0 -> (\n (* if K has arity 0, specializing ((K|K)::rem) returns just (rem):\n if either sides works (filters into a non-empty list),\n no need to keep the other. *)\n match filter_one p1 ps with\n | [] -> filter_rec ((p2, ps) :: rem)\n | matches -> matches @ filter_rec rem\n )\n | 1 -> (\n (* if K has arity 1, ((K p | K q) :: rem) can be expressed\n as ((p | q) :: rem): even if both sides of an or-pattern\n match, we can compress the output in a single row,\n instead of duplicating the row.\n\n In particular, filtering a single row (the filter_one calls)\n returns a result that respects the following properties:\n - \"row count\": the result is either an empty list or a single row\n - \"row shape\": if there is a row in the result, it contains one\n pattern consed to the tail [ps] of our input row; in particular\n the row is not empty. *)\n match (filter_one p1 ps, filter_one p2 ps) with\n | [], row\n | row, [] ->\n row @ filter_rec rem\n | [ (arg1 :: _) ], [ (arg2 :: _) ] ->\n (* By the row shape property,\n the wildcard patterns can only be ps. *)\n (* The output below is a single row,\n respecting the row count property. *)\n ({ arg1 with\n pat_desc = Tpat_or (arg1, arg2, None);\n pat_loc = Location.none\n }\n :: ps\n )\n :: filter_rec rem\n | (_ :: _ :: _), _\n | _, (_ :: _ :: _) ->\n (* Cannot happen from the row count property. *)\n assert false\n | [ [] ], _\n | _, [ [] ] ->\n (* Cannot happen from the row shape property. *)\n assert false\n )\n | _ ->\n (* we cannot preserve the or-pattern as in the arity-1 case,\n because we cannot express\n (K (p1, .., pn) | K (q1, .. qn))\n as (p1 .. pn | q1 .. qn) *)\n filter_rec ((p1, ps) :: (p2, ps) :: rem)\n in\n filter_rec pss\n\n let specialize_ arity matcher env =\n let rec make_rec = function\n | [] -> []\n | (([] :: _), i) :: _ -> [ ([ [] ], i) ]\n | (pss, i) :: rem -> (\n (* we already handled the empty-row case\n so we know that all rows in pss are non-empty *)\n let non_empty = function\n | [] -> assert false\n | p :: ps -> (p, ps)\n in\n let pss = List.map non_empty pss in\n match specialize_matrix arity matcher pss with\n | [] -> make_rec rem\n | [] :: _ -> [ ([ [] ], i) ]\n | pss -> (pss, i) :: make_rec rem\n )\n in\n make_rec env\n\n let specialize head def =\n specialize_ (Patterns.Head.arity head) (matcher head) def\n\n let pop_column def = specialize_ 0 (fun _p rem -> rem) def\n\n let pop_compat p def =\n let compat_matcher q rem =\n if may_compat p (General.erase q) then\n rem\n else\n raise NoMatch\n in\n specialize_ 0 compat_matcher def\n\n let pop = function\n | [] -> None\n | def :: defs -> Some (def, defs)\n\n let pp def =\n Format.eprintf \"+++++ Defaults +++++\\n\";\n List.iter\n (fun (pss, i) -> Format.eprintf \"Matrix for %d\\n%a\" i pretty_matrix pss)\n def;\n Format.eprintf \"+++++++++++++++++++++\\n\"\n\n let flatten size def =\n List.map (fun (pss, i) -> (flatten_matrix size pss, i)) def\nend\n\nmodule Jumps : sig\n type t\n\n val is_empty : t -> bool\n\n val empty : t\n\n val singleton : int -> Context.t -> t\n\n val add : int -> Context.t -> t -> t\n\n val union : t -> t -> t\n\n val unions : t list -> t\n\n val map : (Context.t -> Context.t) -> t -> t\n\n val remove : int -> t -> t\n\n val extract : int -> t -> Context.t * t\n\n val eprintf : t -> unit\nend = struct\n type t = (int * Context.t) list\n\n let eprintf (env : t) =\n List.iter\n (fun (i, ctx) ->\n Printf.eprintf \"jump for %d\\n\" i;\n Context.eprintf ctx)\n env\n\n let rec extract i = function\n | [] -> (Context.empty, [])\n | ((j, pss) as x) :: rem as all ->\n if i = j then\n (pss, rem)\n else if j < i then\n (Context.empty, all)\n else\n let r, rem = extract i rem in\n (r, x :: rem)\n\n let rec remove i = function\n | [] -> []\n | (j, _) :: rem when i = j -> rem\n | x :: rem -> x :: remove i rem\n\n let empty = []\n\n and is_empty = function\n | [] -> true\n | _ -> false\n\n let singleton i ctx =\n if Context.is_empty ctx then\n []\n else\n [ (i, ctx) ]\n\n let add i ctx jumps =\n let rec add = function\n | [] -> [ (i, ctx) ]\n | ((j, qss) as x) :: rem as all ->\n if j > i then\n x :: add rem\n else if j < i then\n (i, ctx) :: all\n else\n (i, Context.union ctx qss) :: rem\n in\n if Context.is_empty ctx then\n jumps\n else\n add jumps\n\n let rec union (env1 : t) env2 =\n match (env1, env2) with\n | [], _ -> env2\n | _, [] -> env1\n | ((i1, pss1) as x1) :: rem1, ((i2, pss2) as x2) :: rem2 ->\n if i1 = i2 then\n (i1, Context.union pss1 pss2) :: union rem1 rem2\n else if i1 > i2 then\n x1 :: union rem1 env2\n else\n x2 :: union env1 rem2\n\n let rec merge = function\n | env1 :: env2 :: rem -> union env1 env2 :: merge rem\n | envs -> envs\n\n let rec unions envs =\n match envs with\n | [] -> []\n | [ env ] -> env\n | _ -> unions (merge envs)\n\n let map f env = List.map (fun (i, pss) -> (i, f pss)) env\nend\n\n(* Pattern matching before any compilation *)\n\ntype 'row pattern_matching = {\n mutable cases : 'row list;\n args : (lambda * let_kind) list;\n (** args are not just Ident.t in at least the following cases:\n - when matching the arguments of a constructor,\n direct field projections are used (make_field_args)\n - with lazy patterns args can be of the form [Lazy.force ...]\n (inline_lazy_force). *)\n default : Default_environment.t\n}\n\ntype handler = {\n provenance : matrix;\n exit : int;\n vars : (Ident.t * Lambda.value_kind) list;\n pm : initial_clause pattern_matching\n}\n\ntype ('head_pat, 'matrix) pm_or_compiled = {\n body : 'head_pat Non_empty_row.t clause pattern_matching;\n handlers : handler list;\n or_matrix : 'matrix\n}\n\n(* Pattern matching after application of both the or-pat rule and the\n mixture rule *)\n\ntype pm_half_compiled =\n | PmOr of (Simple.pattern, matrix) pm_or_compiled\n | PmVar of { inside : pm_half_compiled }\n | Pm of Simple.clause pattern_matching\n\n(* Only used inside the various split functions, we only keep [me] when we're\n done splitting / precompiling. *)\ntype pm_half_compiled_info = {\n me : pm_half_compiled;\n matrix : matrix;\n (* the matrix matched by [me]. Is used to extend the list of reachable trap\n handlers (aka \"default environments\") when returning from recursive\n calls. *)\n top_default : Default_environment.t\n}\n\nlet erase_cases f cases =\n List.map (fun ((p, ps), act) -> (f p :: ps, act)) cases\n\nlet erase_pm pm =\n { pm with cases = erase_cases General.erase pm.cases }\n\nlet pretty_cases cases =\n List.iter\n (fun (ps, _l) ->\n List.iter (fun p -> Format.eprintf \" %a%!\" top_pretty p) ps;\n Format.eprintf \"\\n\")\n cases\n\nlet pretty_pm pm =\n pretty_cases pm.cases;\n if not (Default_environment.is_empty pm.default) then\n Default_environment.pp pm.default\n\nlet rec pretty_precompiled = function\n | Pm pm ->\n Format.eprintf \"++++ PM ++++\\n\";\n pretty_pm (erase_pm pm)\n | PmVar x ->\n Format.eprintf \"++++ VAR ++++\\n\";\n pretty_precompiled x.inside\n | PmOr x ->\n Format.eprintf \"++++ OR ++++\\n\";\n pretty_pm (erase_pm x.body);\n pretty_matrix Format.err_formatter x.or_matrix;\n List.iter\n (fun { exit = i; pm; _ } ->\n eprintf \"++ Handler %d ++\\n\" i;\n pretty_pm pm)\n x.handlers\n\nlet pretty_precompiled_res first nexts =\n pretty_precompiled first;\n List.iter\n (fun (e, pmh) ->\n eprintf \"** DEFAULT %d **\\n\" e;\n pretty_precompiled pmh)\n nexts\n\n(* Identifying some semantically equivalent lambda-expressions,\n Our goal here is also to\n find alpha-equivalent (simple) terms *)\n\n(* However, as shown by PR#6359 such sharing may hinders the\n lambda-code invariant that all bound idents are unique,\n when switches are compiled to test sequences.\n The definitive fix is the systematic introduction of exit/catch\n in case action sharing is present.\n*)\n\nmodule StoreExp = Switch.Store (struct\n type t = lambda\n\n type key = lambda\n\n let compare_key = Stdlib.compare\n\n let make_key = Lambda.make_key\nend)\n\nlet make_exit i = Lstaticraise (i, [])\n\n(* Introduce a catch, if worth it *)\nlet make_catch d k =\n match d with\n | Lstaticraise (_, []) -> k d\n | _ ->\n let e = next_raise_count () in\n Lstaticcatch (k (make_exit e), (e, []), d)\n\n(* Introduce a catch, if worth it, delayed version *)\nlet rec as_simple_exit = function\n | Lstaticraise (i, []) -> Some i\n | Llet (Alias, _k, _, _, e) -> as_simple_exit e\n | _ -> None\n\nlet make_catch_delayed handler =\n match as_simple_exit handler with\n | Some i -> (i, fun act -> act)\n | None -> (\n let i = next_raise_count () in\n (*\n Printf.eprintf \"SHARE LAMBDA: %i\\n%s\\n\" i (string_of_lam handler);\n*)\n ( i,\n fun body ->\n match body with\n | Lstaticraise (j, _) ->\n if i = j then\n handler\n else\n body\n | _ -> Lstaticcatch (body, (i, []), handler) )\n )\n\nlet raw_action l =\n match make_key l with\n | Some l -> l\n | None -> l\n\nlet same_actions = function\n | [] -> None\n | [ (_, act) ] -> Some act\n | (_, act0) :: rem -> (\n match make_key act0 with\n | None -> None\n | key0_opt ->\n let same_act (_, act) = make_key act = key0_opt in\n if List.for_all same_act rem then\n Some act0\n else\n None\n )\n\nlet safe_before ((p, ps), act_p) l =\n (* Test for swapping two clauses *)\n let same_actions act1 act2 =\n match (make_key act1, make_key act2) with\n | Some key1, Some key2 -> key1 = key2\n | None, _\n | _, None ->\n false\n in\n List.for_all\n (fun ((q, qs), act_q) ->\n same_actions act_p act_q\n || not (may_compats (General.erase p :: ps) (General.erase q :: qs)))\n l\n\nlet half_simplify_nonempty ~arg (cls : Typedtree.pattern Non_empty_row.t clause)\n : Half_simple.clause =\n cls\n |> map_on_row (Non_empty_row.map_first General.view)\n |> Half_simple.of_clause ~arg\n\nlet half_simplify_clause ~arg (cls : Typedtree.pattern list clause) =\n cls\n |> map_on_row Non_empty_row.of_initial\n |> half_simplify_nonempty ~arg\n\n(* Once matchings are *fully* simplified, one can easily find\n their nature. *)\n\nlet rec what_is_cases ~skip_any cases =\n match cases with\n | [] -> Patterns.Head.omega\n | ((p, _), _) :: rem -> (\n let head = Simple.head p in\n match head.pat_desc with\n | Patterns.Head.Any when skip_any -> what_is_cases ~skip_any rem\n | _ -> head\n )\n\nlet what_is_first_case = what_is_cases ~skip_any:false\n\nlet what_is_cases = what_is_cases ~skip_any:true\n\nlet pm_free_variables { cases } =\n List.fold_right\n (fun (_, act) r -> Ident.Set.union (free_variables act) r)\n cases Ident.Set.empty\n\n(* Basic grouping predicates *)\n\nlet can_group discr pat =\n let open Patterns.Head in\n match (discr.pat_desc, (Simple.head pat).pat_desc) with\n | Any, Any\n | Constant (Const_int _), Constant (Const_int _)\n | Constant (Const_char _), Constant (Const_char _)\n | Constant (Const_string _), Constant (Const_string _)\n | Constant (Const_float _), Constant (Const_float _)\n | Constant (Const_int32 _), Constant (Const_int32 _)\n | Constant (Const_int64 _), Constant (Const_int64 _)\n | Constant (Const_nativeint _), Constant (Const_nativeint _) ->\n true\n | Construct { cstr_tag = Cstr_extension _ as discr_tag }, Construct pat_cstr\n ->\n (* Extension constructors with distinct names may be equal thanks to\n constructor rebinding. So we need to produce a specialized\n submatrix for each syntactically-distinct constructor (with a threading\n of exits such that each submatrix falls back to the\n potentially-compatible submatrices below it). *)\n Types.equal_tag discr_tag pat_cstr.cstr_tag\n | Construct _, Construct _\n | Tuple _, (Tuple _ | Any)\n | Record _, (Record _ | Any)\n | Array _, Array _\n | Variant _, Variant _\n | Lazy, Lazy ->\n true\n | ( _,\n ( Any\n | Constant\n ( Const_int _ | Const_char _ | Const_string _ | Const_float _\n | Const_int32 _ | Const_int64 _ | Const_nativeint _ )\n | Construct _ | Tuple _ | Record _ | Array _ | Variant _ | Lazy ) ) ->\n false\n\nlet is_or p =\n match p.pat_desc with\n | Tpat_or _ -> true\n | _ -> false\n\nlet rec omega_like p =\n match p.pat_desc with\n | Tpat_any\n | Tpat_var _ ->\n true\n | Tpat_alias (p, _, _) -> omega_like p\n | Tpat_or (p1, p2, _) -> omega_like p1 || omega_like p2\n | _ -> false\n\nlet simple_omega_like p =\n match (Simple.head p).pat_desc with\n | Any -> true\n | _ -> false\n\nlet equiv_pat p q = le_pat p q && le_pat q p\n\nlet rec extract_equiv_head p l =\n match l with\n | (((q, _), _) as cl) :: rem ->\n if equiv_pat p (General.erase q) then\n let others, rem = extract_equiv_head p rem in\n (cl :: others, rem)\n else\n ([], l)\n | _ -> ([], l)\n\nmodule Or_matrix = struct\n (* Splitting a matrix uses an or-matrix that contains or-patterns (at\n the head of some of its rows).\n\n The property that we want to maintain for the rows of the\n or-matrix is that if the row p::ps is before q::qs and p is an\n or-pattern, and v::vs matches p but not ps, then we don't need to\n try q::qs. This is necessary because the compilation of the\n or-pattern p will exit to a sub-matrix and never come back.\n\n For this to hold, (p::ps) and (q::qs) must satisfy one of:\n - disjointness: p and q are not compatible\n - ordering: if p and q are compatible, ps is more general than qs\n (this only works if the row p::ps is not guarded; otherwise the\n guard could fail and q::qs should still be tried)\n *)\n\n (* Conditions for appending to the Or matrix *)\n let disjoint p q = not (may_compat p q)\n\n let safe_below (ps, act) qs =\n (not (is_guarded act)) && Parmatch.le_pats ps qs\n\n let safe_below_or_matrix l (q, qs) =\n List.for_all\n (fun ((p, ps), act_p) ->\n let p = General.erase p in\n match p.pat_desc with\n | Tpat_or _ -> disjoint p q || safe_below (ps, act_p) qs\n | _ -> true)\n l\n\n (* Insert or append a clause in the Or matrix:\n - insert: adding the clause in the middle of the or_matrix\n - append: adding the clause at the bottom of the or_matrix\n\n If neither are possible we add to the bottom of the No matrix.\n *)\n let insert_or_append (head, ps, act) rev_ors rev_no =\n let safe_to_insert rem (p, ps) seen =\n let _, not_e = extract_equiv_head p rem in\n (* check append condition for head of O *)\n safe_below_or_matrix not_e (p, ps)\n && (* check insert condition for tail of O *)\n List.for_all (fun ((q, _), _) -> disjoint p (General.erase q)) seen\n in\n let rec attempt seen = function\n (* invariant: the new clause is safe to append at the end of\n [seen] (but maybe not [rem] yet) *)\n | [] -> (((head, ps), act) :: rev_ors, rev_no)\n | (((q, qs), act_q) as cl) :: rem ->\n let p = General.erase head in\n let q = General.erase q in\n if (not (is_or q)) || disjoint p q then\n attempt (cl :: seen) rem\n else if\n Typedtree.pat_bound_idents p = []\n && Typedtree.pat_bound_idents q = []\n && equiv_pat p q\n then\n (* attempt insertion, for equivalent orpats with no variables *)\n if safe_to_insert rem (p, ps) seen then\n (List.rev_append seen (((head, ps), act) :: cl :: rem), rev_no)\n else\n (* fail to insert or append *)\n (rev_ors, ((head, ps), act) :: rev_no)\n else if safe_below (qs, act_q) ps then\n attempt (cl :: seen) rem\n else\n (rev_ors, ((head, ps), act) :: rev_no)\n in\n attempt [] rev_ors\nend\n\n(* Reconstruct default information from half_compiled pm list *)\n\nlet as_matrix cases =\n get_mins le_pats (List.map (fun ((p, ps), _) -> General.erase p :: ps) cases)\n\n(*\n Split a matching along the first column.\n\n Splitting is first directed by or-patterns, then by\n tests (e.g. constructors)/variable transitions.\n\n The approach is greedy, every split function attempts to\n raise rows as much as possible in the top matrix,\n then splitting applies again to the remaining rows.\n\n Some precompilation of or-patterns and\n variable pattern occurs. Mostly this means that bindings\n are performed now, being replaced by let-bindings\n in actions (cf. Half_simple.of_clause).\n\n Additionally, if the match argument is a variable, matchings whose\n first column is made of variables only are split further\n (cf. precompile_var).\n\n ---\n\n Note: we assume that the first column of each pattern is coherent -- all\n patterns match values of the same type. This comes from the fact that\n we make aggressive splitting decisions, splitting pattern heads that\n may be different into different submatrices; in particular, in a given\n submatrix the first column is formed of first arguments to the same\n constructor.\n\n GADTs are not an issue because we split columns left-to-right, and\n GADT typing also introduces typing equations left-to-right. In\n particular, a leftmost column in matching.ml will be well-typed under\n a set of equations accepted by the type-checker, and those equations\n are forced to remain consistent: they can equate known types to\n abstract types, but they cannot equate two incompatible known types\n together, and in particular incompatible pattern heads do not appear\n in a leftmost column.\n\n Parmatch has to be more conservative because it splits less\n aggressively: submatrices will contain not just the arguments of\n a given pattern head, but also other lines that may be compatible with\n it, in particular those with a leftmost omega and those starting with\n an extension constructor that may be equal to it.\n\n*)\n\nlet rec split_or ~arg (cls : Half_simple.clause list) args def =\n let rec do_split (rev_before : Simple.clause list) rev_ors rev_no = function\n | [] ->\n cons_next (List.rev rev_before) (List.rev rev_ors) (List.rev rev_no)\n | cl :: rem when not (safe_before cl rev_no) ->\n do_split rev_before rev_ors (cl :: rev_no) rem\n | (((p, ps), act) as cl) :: rem -> (\n match p.pat_desc with\n | #Simple.view as view when safe_before cl rev_ors ->\n do_split\n ((({ p with pat_desc = view }, ps), act) :: rev_before)\n rev_ors rev_no rem\n | _ ->\n let rev_ors, rev_no =\n Or_matrix.insert_or_append (p, ps, act) rev_ors rev_no\n in\n do_split rev_before rev_ors rev_no rem\n )\n and cons_next yes yesor no =\n let def, nexts =\n match no with\n | [] -> (def, [])\n | _ ->\n let { me = next; matrix; top_default = def }, nexts =\n do_split [] [] [] no\n in\n let idef = next_raise_count () in\n (Default_environment.cons matrix idef def, (idef, next) :: nexts)\n in\n match yesor with\n | [] -> split_no_or yes args def nexts\n | _ -> precompile_or ~arg yes yesor args def nexts\n in\n do_split [] [] [] cls\n\nand split_no_or cls args def k =\n (* We split the remaining clauses in as few pms as possible while maintaining\n the property stated earlier (cf. {1. Precompilation}), i.e. for\n any pm in the result, it is possible to decide for any two patterns\n on the first column whether their heads are equal or not.\n\n This generally means that we'll have two kinds of pms: ones where the first\n column is made of variables only, and ones where the head is actually a\n discriminating pattern.\n\n There is some subtlety regarding the handling of extension constructors\n (where it is not always possible to syntactically decide whether two\n different heads match different values), but this is handled by the\n [can_group] function. *)\n let rec split (cls : Simple.clause list) =\n let discr = what_is_first_case cls in\n collect discr [] [] cls\n and collect group_discr rev_yes rev_no = function\n | [ (((p, ps), _) as cl) ]\n when rev_yes <> [] && simple_omega_like p && List.for_all omega_like ps ->\n (* This enables an extra division in some frequent cases:\n last row is made of variables only\n\n Splitting a matrix there creates two default environments (instead of\n one for the non-split matrix), the first of which often gets\n specialized away by further refinement, and the second one jumping\n directly to the catch-all case -- this produces better code.\n\n This optimisation is tested in the first part of\n testsuite/tests/basic/patmatch_split_no_or.ml *)\n collect group_discr rev_yes (cl :: rev_no) []\n | (((p, _), _) as cl) :: rem ->\n if can_group group_discr p && safe_before cl rev_no then\n collect group_discr (cl :: rev_yes) rev_no rem\n else if should_split group_discr then (\n assert (rev_no = []);\n let yes = List.rev rev_yes in\n insert_split group_discr yes (cl :: rem) def k\n ) else\n collect group_discr rev_yes (cl :: rev_no) rem\n | [] ->\n let yes = List.rev rev_yes and no = List.rev rev_no in\n insert_split group_discr yes no def k\n and insert_split group_discr yes no def k =\n let precompile_group =\n match group_discr.pat_desc with\n | Patterns.Head.Any -> precompile_var\n | _ -> do_not_precompile\n in\n match no with\n | [] -> precompile_group args yes def k\n | _ ->\n let { me = next; matrix; top_default = def }, nexts = split no in\n let idef = next_raise_count () in\n precompile_group args yes\n (Default_environment.cons matrix idef def)\n ((idef, next) :: nexts)\n and should_split group_discr =\n match group_discr.pat_desc with\n | Patterns.Head.Construct { cstr_tag = Cstr_extension _ } ->\n (* it is unlikely that we will raise anything, so we split now *)\n true\n | _ -> false\n in\n split cls\n\nand precompile_var args cls def k =\n (* Strategy: pop the first column,\n precompile the rest, add a PmVar to all precompiled submatrices.\n\n If the rest doesn't generate any split, abort and do_not_precompile. *)\n match args with\n | [] -> assert false\n | _ :: ((Lvar v, _) as arg) :: rargs -> (\n (* We will use the name of the head column of the submatrix\n we compile, and this is the *second* column of our argument. *)\n match cls with\n | [ _ ] ->\n (* as split as it can *)\n do_not_precompile args cls def k\n | _ -> (\n (* Precompile *)\n let var_args = arg :: rargs in\n let var_cls =\n List.map\n (fun ((p, ps), act) ->\n assert (simple_omega_like p);\n\n (* we learned by pattern-matching on [args]\n that [p::ps] has at least two arguments,\n so [ps] must be non-empty *)\n half_simplify_clause ~arg:(fst arg) (ps, act))\n cls\n and var_def = Default_environment.pop_column def in\n let { me = first; matrix }, nexts =\n split_or ~arg:(Lvar v) var_cls var_args var_def\n in\n (* Compute top information *)\n match nexts with\n | [] ->\n (* If you need *)\n do_not_precompile args cls def k\n | _ ->\n let rec rebuild_matrix pmh =\n match pmh with\n | Pm pm -> as_matrix pm.cases\n | PmOr { or_matrix = m } -> m\n | PmVar x -> add_omega_column (rebuild_matrix x.inside)\n in\n let rebuild_default nexts def =\n (* We can't just do:\n {[\n List.map\n (fun (mat, e) -> add_omega_column mat, e)\n top_default (* assuming it'd been bound. *)\n ]}\n As we would be losing information: [def] is more precise\n than [add_omega_column (pop_column def)]. *)\n List.fold_right\n (fun (e, pmh) ->\n Default_environment.cons\n (add_omega_column (rebuild_matrix pmh))\n e)\n nexts def\n in\n let rebuild_nexts nexts k =\n map_end (fun (e, pm) -> (e, PmVar { inside = pm })) nexts k\n in\n let rfirst =\n { me = PmVar { inside = first };\n matrix = add_omega_column matrix;\n top_default = rebuild_default nexts def\n }\n and rnexts = rebuild_nexts nexts k in\n (rfirst, rnexts)\n )\n )\n | _ -> do_not_precompile args cls def k\n\nand do_not_precompile args cls def k =\n ( { me = Pm { cases = cls; args; default = def };\n matrix = as_matrix cls;\n top_default = def\n },\n k )\n\nand precompile_or ~arg (cls : Simple.clause list) ors args def k =\n (* Example: if [cls] is a single-row matrix\n\n s11 p12 .. p1n -> act1\n\n and [ors] has three rows\n\n (s21|s'21) p22 .. p2n -> act2\n (s31|s'31) p32 .. p3n -> act3\n s41 p42 .. p4n -> act4\n\n where the first and second rows start with disjoint or-patterns\n of simple patterns, binding the variables x2, y2, z2 and x3, y3\n respectively, we precompile into the following:\n\n catch\n ( match arg1 .. argn with\n | s11 p12 .. p1n -> act1\n | s21 _ .. _ -> exit 2 x2 y2 z2\n | s'21 _ .. _ -> exit 2 x2 y2 z2\n | s31 _ .. _ -> exit 3 x3 y3\n | s'31 _ .. _ -> exit 3 x3 y3\n | s41 p42 .. p4n -> act4 )\n with\n | exit 2 x2 y2 z2 ->\n ( match arg2 .. argn with\n | p22 .. p2n -> act2 )\n | exit 3 x3 y3 ->\n ( match arg2 .. argn with\n | p32 .. p3n -> act3 )\n\n Note that if arg1 matches s21 or s'21, we exit to a submatrix\n that will never try any of the following rows; this relies on the\n disjointness-like properties documented in the {!Or_matrix}\n module.\n\n The code below builds this catch/exit structure, The splitting of\n the or-patterns is done in [Simple.explode_or_pat] -- it turns\n half-simple clauses into simple clauses.\n *)\n let rec do_cases = function\n | [] -> ([], [])\n | ((p, patl), action) :: rem -> (\n match p.pat_desc with\n | #Simple.view as view ->\n let new_ord, new_to_catch = do_cases rem in\n ( (({ p with pat_desc = view }, patl), action) :: new_ord,\n new_to_catch )\n | `Or _ ->\n let orp = General.erase p in\n let others, rem = extract_equiv_head orp rem in\n let orpm =\n { cases =\n (patl, action)\n :: List.map (fun ((_, ps), action) -> (ps, action)) others;\n args =\n ( match args with\n | _ :: r -> r\n | _ -> assert false\n );\n default = Default_environment.pop_compat orp def\n }\n in\n let pm_fv = pm_free_variables orpm in\n let patbound_action_vars =\n (* variables bound in the or-pattern\n that are used in the orpm actions *)\n Typedtree.pat_bound_idents_full orp\n |> List.filter (fun (id, _, _) -> Ident.Set.mem id pm_fv)\n |> List.map (fun (id, _, ty) ->\n (id, Typeopt.value_kind orp.pat_env ty))\n in\n let or_num = next_raise_count () in\n let new_patl = Patterns.omega_list patl in\n let mk_new_action ~vars =\n Lstaticraise (or_num, List.map (fun v -> Lvar v) vars)\n in\n let new_cases =\n Simple.explode_or_pat ~arg p\n ~mk_action:mk_new_action\n ~patbound_action_vars:(List.map fst patbound_action_vars)\n |> List.map (fun (p, act) -> ((p, new_patl), act)) in\n let handler =\n { provenance = [ [ orp ] ];\n exit = or_num;\n vars = patbound_action_vars;\n pm = orpm\n }\n in\n let rem_cases, rem_handlers = do_cases rem in\n (new_cases @ rem_cases, handler :: rem_handlers)\n )\n in\n let cases, handlers = do_cases ors in\n let matrix =\n as_matrix\n ((cls : Simple.clause list :> General.clause list)\n @ (ors : Half_simple.clause list :> General.clause list)\n )\n and body = { cases = cls @ cases; args; default = def } in\n ( { me = PmOr { body; handlers; or_matrix = matrix };\n matrix;\n top_default = def\n },\n k )\n\nlet dbg_split_and_precompile pm next nexts =\n if\n dbg\n && (nexts <> []\n ||\n match next with\n | PmOr _ -> true\n | _ -> false\n )\n then (\n Format.eprintf \"** SPLIT **\\n\";\n pretty_pm (erase_pm pm);\n pretty_precompiled_res next nexts\n )\n\nlet split_and_precompile_simplified pm =\n let { me = next }, nexts = split_no_or pm.cases pm.args pm.default [] in\n dbg_split_and_precompile pm next nexts;\n (next, nexts)\n\nlet split_and_precompile_half_simplified ~arg pm =\n let { me = next }, nexts = split_or ~arg pm.cases pm.args pm.default in\n dbg_split_and_precompile pm next nexts;\n (next, nexts)\n\n(* General divide functions *)\n\ntype cell = {\n pm : initial_clause pattern_matching;\n ctx : Context.t;\n discr : Patterns.Head.t\n}\n(** a submatrix after specializing by discriminant pattern;\n [ctx] is the context shared by all rows. *)\n\nlet make_matching get_expr_args head def ctx = function\n | [] -> fatal_error \"Matching.make_matching\"\n | arg :: rem ->\n let def = Default_environment.specialize head def\n and args = get_expr_args head arg rem\n and ctx = Context.specialize head ctx in\n { pm = { cases = []; args; default = def }; ctx; discr = head }\n\nlet make_line_matching get_expr_args head def = function\n | [] -> fatal_error \"Matching.make_line_matching\"\n | arg :: rem ->\n { cases = [];\n args = get_expr_args head arg rem;\n default = Default_environment.specialize head def\n }\n\ntype 'a division = {\n args : (lambda * let_kind) list;\n cells : ('a * cell) list\n}\n\nlet add_in_div make_matching_fun eq_key key patl_action division =\n let cells =\n match List.find_opt (fun (k, _) -> eq_key key k) division.cells with\n | None ->\n let cell = make_matching_fun division.args in\n cell.pm.cases <- [ patl_action ];\n (key, cell) :: division.cells\n | Some (_, cell) ->\n cell.pm.cases <- patl_action :: cell.pm.cases;\n division.cells\n in\n { division with cells }\n\nlet divide get_expr_args eq_key get_key get_pat_args ctx\n (pm : Simple.clause pattern_matching) =\n let add ((p, patl), action) division =\n let ph = Simple.head p in\n let p = General.erase p in\n add_in_div\n (make_matching get_expr_args ph pm.default ctx)\n eq_key (get_key p)\n (get_pat_args p patl, action)\n division\n in\n List.fold_right add pm.cases { args = pm.args; cells = [] }\n\nlet add_line patl_action pm =\n pm.cases <- patl_action :: pm.cases;\n pm\n\nlet divide_line make_ctx get_expr_args get_pat_args discr ctx\n (pm : Simple.clause pattern_matching) =\n let add ((p, patl), action) submatrix =\n let p = General.erase p in\n add_line (get_pat_args p patl, action) submatrix\n in\n let pm =\n List.fold_right add pm.cases\n (make_line_matching get_expr_args discr pm.default pm.args)\n in\n { pm; ctx = make_ctx ctx; discr }\n\nlet drop_pat_arg _p rem = rem\nlet drop_expr_arg _head _arg rem = rem\n\n(* Then come various functions,\n There is one set of functions per matching style\n (constants, constructors etc.)\n\n - get_{expr,pat}_args and get_key are for the compiled matrices,\n note that selection and getting arguments are separated.\n\n - make_*_matching combines the previous functions for producing\n new ``pattern_matching'' records.\n*)\n\n(* Matching against a constant *)\n\nlet get_key_constant caller = function\n | { pat_desc = Tpat_constant cst } -> cst\n | p ->\n Format.eprintf \"BAD: %s\" caller;\n pretty_pat p;\n assert false\n\nlet get_pat_args_constant = drop_pat_arg\nlet get_expr_args_constant = drop_expr_arg\n\nlet divide_constant ctx m =\n divide\n get_expr_args_constant\n (fun c d -> const_compare c d = 0)\n (get_key_constant \"divide\")\n get_pat_args_constant ctx m\n\n(* Matching against a constructor *)\n\nlet get_key_constr = function\n | { pat_desc = Tpat_construct (_, cstr, _, _) } -> cstr\n | _ -> assert false\n\nlet get_pat_args_constr p rem =\n match p with\n | { pat_desc = Tpat_construct (_, _, args, _) } -> args @ rem\n | _ -> assert false\n\nlet get_expr_args_constr ~scopes head (arg, _mut) rem =\n let cstr =\n match head.pat_desc with\n | Patterns.Head.Construct cstr -> cstr\n | _ -> fatal_error \"Matching.get_expr_args_constr\"\n in\n let loc = head_loc ~scopes head in\n let make_field_accesses binding_kind first_pos last_pos argl =\n let rec make_args pos =\n if pos > last_pos then\n argl\n else\n (Lprim (Pfield pos, [ arg ], loc), binding_kind) :: make_args (pos + 1)\n in\n make_args first_pos\n in\n if cstr.cstr_inlined <> None then\n (arg, Alias) :: rem\n else\n match cstr.cstr_tag with\n | Cstr_constant _\n | Cstr_block _ ->\n make_field_accesses Alias 0 (cstr.cstr_arity - 1) rem\n | Cstr_unboxed -> (arg, Alias) :: rem\n | Cstr_extension _ -> make_field_accesses Alias 1 cstr.cstr_arity rem\n\nlet divide_constructor ~scopes ctx pm =\n divide\n (get_expr_args_constr ~scopes)\n (fun cstr1 cstr2 -> Types.equal_tag cstr1.cstr_tag cstr2.cstr_tag)\n get_key_constr\n get_pat_args_constr\n ctx pm\n\n(* Matching against a variant *)\n\nlet get_expr_args_variant_constant = drop_expr_arg\n\nlet get_expr_args_variant_nonconst ~scopes head (arg, _mut) rem =\n let loc = head_loc ~scopes head in\n (Lprim (Pfield 1, [ arg ], loc), Alias) :: rem\n\nlet divide_variant ~scopes row ctx { cases = cl; args; default = def } =\n let rec divide = function\n | [] -> { args; cells = [] }\n | ((p, patl), action) :: rem\n -> (\n let lab, pato = match p.pat_desc with\n | `Variant (lab, pato, _) -> lab, pato\n | _ -> assert false\n in\n let head = Simple.head p in\n let variants = divide rem in\n if row_field_repr (get_row_field lab row) = Rabsent then\n variants\n else\n let tag = Btype.hash_variant lab in\n match pato with\n | None ->\n add_in_div\n (make_matching get_expr_args_variant_constant head def ctx)\n ( = ) (Cstr_constant tag) (patl, action) variants\n | Some pat ->\n add_in_div\n (make_matching\n (get_expr_args_variant_nonconst ~scopes)\n head def ctx)\n ( = ) (Cstr_block tag)\n (pat :: patl, action)\n variants\n )\n in\n divide cl\n\n(*\n Three ``no-test'' cases\n *)\n\n(* Matching against a variable *)\n\nlet get_pat_args_var = drop_pat_arg\nlet get_expr_args_var = drop_expr_arg\n\nlet divide_var ctx pm =\n divide_line Context.lshift\n get_expr_args_var\n get_pat_args_var\n Patterns.Head.omega ctx pm\n\n(* Matching and forcing a lazy value *)\n\nlet get_pat_args_lazy p rem =\n match p with\n | { pat_desc = Tpat_any } -> Patterns.omega :: rem\n | { pat_desc = Tpat_lazy arg } -> arg :: rem\n | _ -> assert false\n\n(* Inlining the tag tests before calling the primitive that works on\n lazy blocks. This is also used in translcore.ml.\n No other call than Obj.tag when the value has been forced before.\n*)\n\nlet prim_obj_tag = Primitive.simple ~name:\"caml_obj_tag\" ~arity:1 ~alloc:false\n\nlet get_mod_field modname field =\n lazy\n (let mod_ident = Ident.create_persistent modname in\n let env =\n Env.add_persistent_structure mod_ident Env.initial_safe_string\n in\n match Env.open_pers_signature modname env with\n | Error `Not_found ->\n fatal_error (\"Module \" ^ modname ^ \" unavailable.\")\n | Ok env -> (\n match Env.find_value_by_name (Longident.Lident field) env with\n | exception Not_found ->\n fatal_error (\"Primitive \" ^ modname ^ \".\" ^ field ^ \" not found.\")\n | path, _ -> transl_value_path Loc_unknown env path\n ))\n\nlet code_force_lazy_block = get_mod_field \"CamlinternalLazy\" \"force_lazy_block\"\n\nlet code_force_lazy = get_mod_field \"CamlinternalLazy\" \"force\"\n\n(* inline_lazy_force inlines the beginning of the code of Lazy.force. When\n the value argument is tagged as:\n - forward, take field 0\n - lazy, call the primitive that forces (without testing again the tag)\n - anything else, return it\n\n Using Lswitch below relies on the fact that the GC does not shortcut\n Forward(val_out_of_heap).\n*)\n\nlet inline_lazy_force_cond arg loc =\n let idarg = Ident.create_local \"lzarg\" in\n let varg = Lvar idarg in\n let tag = Ident.create_local \"tag\" in\n let tag_var = Lvar tag in\n let force_fun = Lazy.force code_force_lazy_block in\n Llet\n ( Strict,\n Pgenval,\n idarg,\n arg,\n Llet\n ( Alias,\n Pgenval,\n tag,\n Lprim (Pccall prim_obj_tag, [ varg ], loc),\n Lifthenelse\n (* if (tag == Obj.forward_tag) then varg.(0) else ... *)\n ( Lprim\n ( Pintcomp Ceq,\n [ tag_var; Lconst (Const_base (Const_int Obj.forward_tag)) ],\n loc ),\n Lprim (Pfield 0, [ varg ], loc),\n Lifthenelse\n (* if (tag == Obj.lazy_tag) then Lazy.force varg else ... *)\n ( Lprim\n ( Pintcomp Ceq,\n [ tag_var; Lconst (Const_base (Const_int Obj.lazy_tag)) ],\n loc ),\n Lapply\n { ap_tailcall = Default_tailcall;\n ap_loc = loc;\n ap_func = force_fun;\n ap_args = [ varg ];\n ap_inlined = Default_inline;\n ap_specialised = Default_specialise\n },\n (* ... arg *)\n varg ) ) ) )\n\nlet inline_lazy_force_switch arg loc =\n let idarg = Ident.create_local \"lzarg\" in\n let varg = Lvar idarg in\n let force_fun = Lazy.force code_force_lazy_block in\n Llet\n ( Strict,\n Pgenval,\n idarg,\n arg,\n Lifthenelse\n ( Lprim (Pisint, [ varg ], loc),\n varg,\n Lswitch\n ( varg,\n { sw_numconsts = 0;\n sw_consts = [];\n sw_numblocks = 256;\n (* PR#6033 - tag ranges from 0 to 255 *)\n sw_blocks =\n [ (Obj.forward_tag, Lprim (Pfield 0, [ varg ], loc));\n ( Obj.lazy_tag,\n Lapply\n { ap_tailcall = Default_tailcall;\n ap_loc = loc;\n ap_func = force_fun;\n ap_args = [ varg ];\n ap_inlined = Default_inline;\n ap_specialised = Default_specialise\n } )\n ];\n sw_failaction = Some varg\n },\n loc ) ) )\n\nlet inline_lazy_force arg loc =\n if !Clflags.afl_instrument then\n (* Disable inlining optimisation if AFL instrumentation active,\n so that the GC forwarding optimisation is not visible in the\n instrumentation output.\n (see https://github.com/stedolan/crowbar/issues/14) *)\n Lapply\n { ap_tailcall = Default_tailcall;\n ap_loc = loc;\n ap_func = Lazy.force code_force_lazy;\n ap_args = [ arg ];\n ap_inlined = Default_inline;\n ap_specialised = Default_specialise\n }\n else if !Clflags.native_code then\n (* Lswitch generates compact and efficient native code *)\n inline_lazy_force_switch arg loc\n else\n (* generating bytecode: Lswitch would generate too many rather big\n tables (~ 250 elts); conditionals are better *)\n inline_lazy_force_cond arg loc\n\nlet get_expr_args_lazy ~scopes head (arg, _mut) rem =\n let loc = head_loc ~scopes head in\n (inline_lazy_force arg loc, Strict) :: rem\n\nlet divide_lazy ~scopes head ctx pm =\n divide_line (Context.specialize head)\n (get_expr_args_lazy ~scopes)\n get_pat_args_lazy\n head ctx pm\n\n(* Matching against a tuple pattern *)\n\nlet get_pat_args_tuple arity p rem =\n match p with\n | { pat_desc = Tpat_any } -> Patterns.omegas arity @ rem\n | { pat_desc = Tpat_tuple args } -> args @ rem\n | _ -> assert false\n\nlet get_expr_args_tuple ~scopes head (arg, _mut) rem =\n let loc = head_loc ~scopes head in\n let arity = Patterns.Head.arity head in\n let rec make_args pos =\n if pos >= arity then\n rem\n else\n (Lprim (Pfield pos, [ arg ], loc), Alias) :: make_args (pos + 1)\n in\n make_args 0\n\nlet divide_tuple ~scopes head ctx pm =\n let arity = Patterns.Head.arity head in\n divide_line (Context.specialize head)\n (get_expr_args_tuple ~scopes)\n (get_pat_args_tuple arity)\n head ctx pm\n\n(* Matching against a record pattern *)\n\nlet record_matching_line num_fields lbl_pat_list =\n let patv = Array.make num_fields Patterns.omega in\n List.iter (fun (_, lbl, pat) -> patv.(lbl.lbl_pos) <- pat) lbl_pat_list;\n Array.to_list patv\n\nlet get_pat_args_record num_fields p rem =\n match p with\n | { pat_desc = Tpat_any } -> record_matching_line num_fields [] @ rem\n | { pat_desc = Tpat_record (lbl_pat_list, _) } ->\n record_matching_line num_fields lbl_pat_list @ rem\n | _ -> assert false\n\nlet get_expr_args_record ~scopes head (arg, _mut) rem =\n let loc = head_loc ~scopes head in\n let all_labels =\n let open Patterns.Head in\n match head.pat_desc with\n | Record (lbl :: _) -> lbl.lbl_all\n | Record []\n | _ ->\n assert false\n in\n let rec make_args pos =\n if pos >= Array.length all_labels then\n rem\n else\n let lbl = all_labels.(pos) in\n let access =\n match lbl.lbl_repres with\n | Record_regular\n | Record_inlined _ ->\n Lprim (Pfield lbl.lbl_pos, [ arg ], loc)\n | Record_unboxed _ -> arg\n | Record_float -> Lprim (Pfloatfield lbl.lbl_pos, [ arg ], loc)\n | Record_extension _ -> Lprim (Pfield (lbl.lbl_pos + 1), [ arg ], loc)\n in\n let str =\n match lbl.lbl_mut with\n | Immutable -> Alias\n | Mutable -> StrictOpt\n in\n (access, str) :: make_args (pos + 1)\n in\n make_args 0\n\nlet divide_record all_labels ~scopes head ctx pm =\n (* There is some redundancy in the expansions here, [head] is\n expanded here and again in the matcher. It would be\n nicer to have a type-level distinction between expanded heads\n and non-expanded heads, to be able to reason confidently on\n when expansions must happen. *)\n let head = expand_record_head head in\n divide_line (Context.specialize head)\n (get_expr_args_record ~scopes)\n (get_pat_args_record (Array.length all_labels))\n head ctx pm\n\n(* Matching against an array pattern *)\n\nlet get_key_array = function\n | { pat_desc = Tpat_array patl } -> List.length patl\n | _ -> assert false\n\nlet get_pat_args_array p rem =\n match p with\n | { pat_desc = Tpat_array patl } -> patl @ rem\n | _ -> assert false\n\nlet get_expr_args_array ~scopes kind head (arg, _mut) rem =\n let len =\n let open Patterns.Head in\n match head.pat_desc with\n | Array len -> len\n | _ -> assert false\n in\n let loc = head_loc ~scopes head in\n let rec make_args pos =\n if pos >= len then\n rem\n else\n ( Lprim\n (Parrayrefu kind, [ arg; Lconst (Const_base (Const_int pos)) ], loc),\n StrictOpt )\n :: make_args (pos + 1)\n in\n make_args 0\n\nlet divide_array ~scopes kind ctx pm =\n divide\n (get_expr_args_array ~scopes kind)\n ( = )\n get_key_array get_pat_args_array\n ctx pm\n\n(*\n Specific string test sequence\n Will be called by the bytecode compiler, from bytegen.ml.\n The strategy is first dichotomic search (we perform 3-way tests\n with compare_string), then sequence of equality tests\n when there are less then T=strings_test_threshold static strings to match.\n\n Increasing T entails (slightly) less code, decreasing T\n (slightly) favors runtime speed.\n T=8 looks a decent tradeoff.\n*)\n\n(* Utilities *)\n\nlet strings_test_threshold = 8\n\nlet prim_string_notequal =\n Pccall (Primitive.simple ~name:\"caml_string_notequal\" ~arity:2 ~alloc:false)\n\nlet prim_string_compare =\n Pccall (Primitive.simple ~name:\"caml_string_compare\" ~arity:2 ~alloc:false)\n\nlet bind_sw arg k =\n match arg with\n | Lvar _ -> k arg\n | _ ->\n let id = Ident.create_local \"switch\" in\n Llet (Strict, Pgenval, id, arg, k (Lvar id))\n\n(* Sequential equality tests *)\n\nlet make_string_test_sequence loc arg sw d =\n let d, sw =\n match d with\n | None -> (\n match sw with\n | (_, d) :: sw -> (d, sw)\n | [] -> assert false\n )\n | Some d -> (d, sw)\n in\n bind_sw arg (fun arg ->\n List.fold_right\n (fun (str, lam) k ->\n Lifthenelse\n ( Lprim\n ( prim_string_notequal,\n [ arg; Lconst (Const_immstring str) ],\n loc ),\n k,\n lam ))\n sw d)\n\nlet rec split k xs =\n match xs with\n | [] -> assert false\n | x0 :: xs ->\n if k <= 1 then\n ([], x0, xs)\n else\n let xs, y0, ys = split (k - 2) xs in\n (x0 :: xs, y0, ys)\n\nlet zero_lam = Lconst (Const_base (Const_int 0))\n\nlet tree_way_test loc arg lt eq gt =\n Lifthenelse\n ( Lprim (Pintcomp Clt, [ arg; zero_lam ], loc),\n lt,\n Lifthenelse (Lprim (Pintcomp Clt, [ zero_lam; arg ], loc), gt, eq) )\n\n(* Dichotomic tree *)\n\nlet rec do_make_string_test_tree loc arg sw delta d =\n let len = List.length sw in\n if len <= strings_test_threshold + delta then\n make_string_test_sequence loc arg sw d\n else\n let lt, (s, act), gt = split len sw in\n bind_sw\n (Lprim (prim_string_compare, [ arg; Lconst (Const_immstring s) ], loc))\n (fun r ->\n tree_way_test loc r\n (do_make_string_test_tree loc arg lt delta d)\n act\n (do_make_string_test_tree loc arg gt delta d))\n\n(* Entry point *)\nlet expand_stringswitch loc arg sw d =\n match d with\n | None -> bind_sw arg (fun arg -> do_make_string_test_tree loc arg sw 0 None)\n | Some e ->\n bind_sw arg (fun arg ->\n make_catch e (fun d ->\n do_make_string_test_tree loc arg sw 1 (Some d)))\n\n(**********************)\n(* Generic test trees *)\n(**********************)\n\n(* Sharing *)\n\n(* Add handler, if shared *)\nlet handle_shared () =\n let hs = ref (fun x -> x) in\n let handle_shared act =\n match act with\n | Switch.Single act -> act\n | Switch.Shared act ->\n let i, h = make_catch_delayed act in\n let ohs = !hs in\n (hs := fun act -> h (ohs act));\n make_exit i\n in\n (hs, handle_shared)\n\nlet share_actions_tree sw d =\n let store = StoreExp.mk_store () in\n (* Default action is always shared *)\n let d =\n match d with\n | None -> None\n | Some d -> Some (store.Switch.act_store_shared () d)\n in\n (* Store all other actions *)\n let sw =\n List.map (fun (cst, act) -> (cst, store.Switch.act_store () act)) sw\n in\n (* Retrieve all actions, including potential default *)\n let acts = store.Switch.act_get_shared () in\n (* Array of actual actions *)\n let hs, handle_shared = handle_shared () in\n let acts = Array.map handle_shared acts in\n (* Reconstruct default and switch list *)\n let d =\n match d with\n | None -> None\n | Some d -> Some acts.(d)\n in\n let sw = List.map (fun (cst, j) -> (cst, acts.(j))) sw in\n (!hs, sw, d)\n\n(* Note: dichotomic search requires sorted input with no duplicates *)\nlet rec uniq_lambda_list sw =\n match sw with\n | []\n | [ _ ] ->\n sw\n | ((c1, _) as p1) :: ((c2, _) :: sw2 as sw1) ->\n if const_compare c1 c2 = 0 then\n uniq_lambda_list (p1 :: sw2)\n else\n p1 :: uniq_lambda_list sw1\n\nlet sort_lambda_list l =\n let l = List.stable_sort (fun (x, _) (y, _) -> const_compare x y) l in\n uniq_lambda_list l\n\nlet rec do_tests_fail loc fail tst arg = function\n | [] -> fail\n | (c, act) :: rem ->\n Lifthenelse\n ( Lprim (tst, [ arg; Lconst (Const_base c) ], loc),\n do_tests_fail loc fail tst arg rem,\n act )\n\nlet rec do_tests_nofail loc tst arg = function\n | [] -> fatal_error \"Matching.do_tests_nofail\"\n | [ (_, act) ] -> act\n | (c, act) :: rem ->\n Lifthenelse\n ( Lprim (tst, [ arg; Lconst (Const_base c) ], loc),\n do_tests_nofail loc tst arg rem,\n act )\n\nlet make_test_sequence loc fail tst lt_tst arg const_lambda_list =\n let const_lambda_list = sort_lambda_list const_lambda_list in\n let hs, const_lambda_list, fail =\n share_actions_tree const_lambda_list fail\n in\n let rec make_test_sequence const_lambda_list =\n if List.length const_lambda_list >= 4 && lt_tst <> Pignore then\n split_sequence const_lambda_list\n else\n match fail with\n | None -> do_tests_nofail loc tst arg const_lambda_list\n | Some fail -> do_tests_fail loc fail tst arg const_lambda_list\n and split_sequence const_lambda_list =\n let list1, list2 =\n rev_split_at (List.length const_lambda_list / 2) const_lambda_list\n in\n Lifthenelse\n ( Lprim (lt_tst, [ arg; Lconst (Const_base (fst (List.hd list2))) ], loc),\n make_test_sequence list1,\n make_test_sequence list2 )\n in\n hs (make_test_sequence const_lambda_list)\n\nmodule SArg = struct\n type primitive = Lambda.primitive\n\n let eqint = Pintcomp Ceq\n\n let neint = Pintcomp Cne\n\n let leint = Pintcomp Cle\n\n let ltint = Pintcomp Clt\n\n let geint = Pintcomp Cge\n\n let gtint = Pintcomp Cgt\n\n type loc = Lambda.scoped_location\n type arg = Lambda.lambda\n type test = Lambda.lambda\n type act = Lambda.lambda\n\n let make_prim p args = Lprim (p, args, Loc_unknown)\n\n let make_offset arg n =\n match n with\n | 0 -> arg\n | _ -> Lprim (Poffsetint n, [ arg ], Loc_unknown)\n\n let bind arg body =\n let newvar, newarg =\n match arg with\n | Lvar v -> (v, arg)\n | _ ->\n let newvar = Ident.create_local \"switcher\" in\n (newvar, Lvar newvar)\n in\n bind Alias newvar arg (body newarg)\n\n let make_const i = Lconst (Const_base (Const_int i))\n\n let make_isout h arg = Lprim (Pisout, [ h; arg ], Loc_unknown)\n\n let make_isin h arg = Lprim (Pnot, [ make_isout h arg ], Loc_unknown)\n\n let make_is_nonzero arg =\n if !Clflags.native_code then\n Lprim (Pintcomp Cne,\n [arg; Lconst (Const_base (Const_int 0))],\n Loc_unknown)\n else\n arg\n\n let arg_as_test arg = arg\n\n let make_if cond ifso ifnot = Lifthenelse (cond, ifso, ifnot)\n\n let make_switch loc arg cases acts =\n let l = ref [] in\n for i = Array.length cases - 1 downto 0 do\n l := (i, acts.(cases.(i))) :: !l\n done;\n Lswitch\n ( arg,\n { sw_numconsts = Array.length cases;\n sw_consts = !l;\n sw_numblocks = 0;\n sw_blocks = [];\n sw_failaction = None\n },\n loc )\n\n let make_catch = make_catch_delayed\n\n let make_exit = make_exit\nend\n\n(* Action sharing for Lswitch argument *)\nlet share_actions_sw sw =\n (* Attempt sharing on all actions *)\n let store = StoreExp.mk_store () in\n let fail =\n match sw.sw_failaction with\n | None -> None\n | Some fail ->\n (* Fail is translated to exit, whatever happens *)\n Some (store.Switch.act_store_shared () fail)\n in\n let consts =\n List.map (fun (i, e) -> (i, store.Switch.act_store () e)) sw.sw_consts\n and blocks =\n List.map (fun (i, e) -> (i, store.Switch.act_store () e)) sw.sw_blocks\n in\n let acts = store.Switch.act_get_shared () in\n let hs, handle_shared = handle_shared () in\n let acts = Array.map handle_shared acts in\n let fail =\n match fail with\n | None -> None\n | Some fail -> Some acts.(fail)\n in\n ( !hs,\n { sw with\n sw_consts = List.map (fun (i, j) -> (i, acts.(j))) consts;\n sw_blocks = List.map (fun (i, j) -> (i, acts.(j))) blocks;\n sw_failaction = fail\n } )\n\n(* Reintroduce fail action in switch argument,\n for the sake of avoiding carrying over huge switches *)\n\nlet reintroduce_fail sw =\n match sw.sw_failaction with\n | None ->\n let t = Hashtbl.create 17 in\n let seen (_, l) =\n match as_simple_exit l with\n | Some i ->\n let old = try Hashtbl.find t i with Not_found -> 0 in\n Hashtbl.replace t i (old + 1)\n | None -> ()\n in\n List.iter seen sw.sw_consts;\n List.iter seen sw.sw_blocks;\n let i_max = ref (-1) and max = ref (-1) in\n Hashtbl.iter\n (fun i c ->\n if c > !max then (\n i_max := i;\n max := c\n ))\n t;\n if !max >= 3 then\n let default = !i_max in\n let remove =\n List.filter (fun (_, lam) ->\n match as_simple_exit lam with\n | Some j -> j <> default\n | None -> true)\n in\n { sw with\n sw_consts = remove sw.sw_consts;\n sw_blocks = remove sw.sw_blocks;\n sw_failaction = Some (make_exit default)\n }\n else\n sw\n | Some _ -> sw\n\nmodule Switcher = Switch.Make (SArg)\nopen Switch\n\nlet rec last def = function\n | [] -> def\n | [ (x, _) ] -> x\n | _ :: rem -> last def rem\n\nlet get_edges low high l =\n match l with\n | [] -> (low, high)\n | (x, _) :: _ -> (x, last high l)\n\nlet as_interval_canfail fail low high l =\n let store = StoreExp.mk_store () in\n let do_store _tag act =\n let i = store.act_store () act in\n (*\n eprintf \"STORE [%s] %i %s\\n\" tag i (string_of_lam act) ;\n*)\n i\n in\n let rec nofail_rec cur_low cur_high cur_act = function\n | [] ->\n if cur_high = high then\n [ (cur_low, cur_high, cur_act) ]\n else\n [ (cur_low, cur_high, cur_act); (cur_high + 1, high, 0) ]\n | (i, act_i) :: rem as all ->\n let act_index = do_store \"NO\" act_i in\n if cur_high + 1 = i then\n if act_index = cur_act then\n nofail_rec cur_low i cur_act rem\n else if act_index = 0 then\n (cur_low, i - 1, cur_act) :: fail_rec i i rem\n else\n (cur_low, i - 1, cur_act) :: nofail_rec i i act_index rem\n else if act_index = 0 then\n (cur_low, cur_high, cur_act)\n :: fail_rec (cur_high + 1) (cur_high + 1) all\n else\n (cur_low, cur_high, cur_act)\n :: (cur_high + 1, i - 1, 0)\n :: nofail_rec i i act_index rem\n and fail_rec cur_low cur_high = function\n | [] -> [ (cur_low, cur_high, 0) ]\n | (i, act_i) :: rem ->\n let index = do_store \"YES\" act_i in\n if index = 0 then\n fail_rec cur_low i rem\n else\n (cur_low, i - 1, 0) :: nofail_rec i i index rem\n in\n let init_rec = function\n | [] -> [ (low, high, 0) ]\n | (i, act_i) :: rem ->\n let index = do_store \"INIT\" act_i in\n if index = 0 then\n fail_rec low i rem\n else if low < i then\n (low, i - 1, 0) :: nofail_rec i i index rem\n else\n nofail_rec i i index rem\n in\n assert (do_store \"FAIL\" fail = 0);\n\n (* fail has action index 0 *)\n let r = init_rec l in\n (Array.of_list r, store)\n\nlet as_interval_nofail l =\n let store = StoreExp.mk_store () in\n let rec some_hole = function\n | []\n | [ _ ] ->\n false\n | (i, _) :: ((j, _) :: _ as rem) -> j > i + 1 || some_hole rem\n in\n let rec i_rec cur_low cur_high cur_act = function\n | [] -> [ (cur_low, cur_high, cur_act) ]\n | (i, act) :: rem ->\n let act_index = store.act_store () act in\n if act_index = cur_act then\n i_rec cur_low i cur_act rem\n else\n (cur_low, cur_high, cur_act) :: i_rec i i act_index rem\n in\n let inters =\n match l with\n | (i, act) :: rem ->\n let act_index =\n (* In case there is some hole and that a switch is emitted,\n action 0 will be used as the action of unreachable\n cases (cf. switch.ml, make_switch).\n Hence, this action will be shared *)\n if some_hole rem then\n store.act_store_shared () act\n else\n store.act_store () act\n in\n assert (act_index = 0);\n i_rec i i act_index rem\n | _ -> assert false\n in\n (Array.of_list inters, store)\n\nlet sort_int_lambda_list l =\n List.sort\n (fun (i1, _) (i2, _) ->\n if i1 < i2 then\n -1\n else if i2 < i1 then\n 1\n else\n 0)\n l\n\nlet as_interval fail low high l =\n let l = sort_int_lambda_list l in\n ( get_edges low high l,\n match fail with\n | None -> as_interval_nofail l\n | Some act -> as_interval_canfail act low high l )\n\nlet call_switcher loc fail arg low high int_lambda_list =\n let edges, (cases, actions) = as_interval fail low high int_lambda_list in\n Switcher.zyva loc edges arg cases actions\n\nlet rec list_as_pat = function\n | [] -> fatal_error \"Matching.list_as_pat\"\n | [ pat ] -> pat\n | pat :: rem -> { pat with pat_desc = Tpat_or (pat, list_as_pat rem, None) }\n\nlet complete_pats_constrs = function\n | constr :: _ as constrs ->\n let constr_of_pat cstr_pat =\n cstr_pat.pat_desc in\n let pat_of_constr cstr =\n let open Patterns.Head in\n to_omega_pattern { constr with pat_desc = Construct cstr } in\n List.map pat_of_constr\n (complete_constrs constr (List.map constr_of_pat constrs))\n | _ -> assert false\n\n(*\n Following two ``failaction'' function compute n, the trap handler\n to jump to in case of failure of elementary tests\n*)\n\nlet mk_failaction_neg partial ctx def =\n match partial with\n | Partial -> (\n match Default_environment.pop def with\n | Some ((_, idef), _) ->\n (Some (Lstaticraise (idef, [])), Jumps.singleton idef ctx)\n | None ->\n (* Act as Total, this means\n If no appropriate default matrix exists,\n then this switch cannot fail *)\n (None, Jumps.empty)\n )\n | Total -> (None, Jumps.empty)\n\n(* In line with the article and simpler than before *)\nlet mk_failaction_pos partial seen ctx defs =\n if dbg then (\n Format.eprintf \"**POS**\\n\";\n Default_environment.pp defs;\n ()\n );\n let rec scan_def env to_test defs =\n match (to_test, Default_environment.pop defs) with\n | [], _\n | _, None ->\n List.fold_left\n (fun (klist, jumps) (pats, i) ->\n let action = Lstaticraise (i, []) in\n let klist =\n List.fold_right\n (fun pat r -> (get_key_constr pat, action) :: r)\n pats klist\n and jumps =\n Jumps.add i (Context.lub (list_as_pat pats) ctx) jumps\n in\n (klist, jumps))\n ([], Jumps.empty) env\n | _, Some ((pss, idef), rem) -> (\n let now, later =\n List.partition (fun (_p, p_ctx) -> Context.matches p_ctx pss) to_test\n in\n match now with\n | [] -> scan_def env to_test rem\n | _ -> scan_def ((List.map fst now, idef) :: env) later rem\n )\n in\n let fail_pats = complete_pats_constrs seen in\n if List.length fail_pats < !Clflags.match_context_rows then (\n let fail, jmps =\n scan_def []\n (List.map (fun pat -> (pat, Context.lub pat ctx)) fail_pats)\n defs\n in\n if dbg then (\n eprintf \"POSITIVE JUMPS [%i]:\\n\" (List.length fail_pats);\n Jumps.eprintf jmps\n );\n (None, fail, jmps)\n ) else (\n (* Too many non-matched constructors -> reduced information *)\n if dbg then eprintf \"POS->NEG!!!\\n%!\";\n let fail, jumps = mk_failaction_neg partial ctx defs in\n if dbg then\n eprintf \"FAIL: %s\\n\"\n ( match fail with\n | None -> \"\"\n | Some lam -> string_of_lam lam\n );\n (fail, [], jumps)\n )\n\nlet combine_constant loc arg cst partial ctx def\n (const_lambda_list, total, _pats) =\n let fail, local_jumps = mk_failaction_neg partial ctx def in\n let lambda1 =\n match cst with\n | Const_int _ ->\n let int_lambda_list =\n List.map\n (function\n | Const_int n, l -> (n, l)\n | _ -> assert false)\n const_lambda_list\n in\n call_switcher loc fail arg min_int max_int int_lambda_list\n | Const_char _ ->\n let int_lambda_list =\n List.map\n (function\n | Const_char c, l -> (Char.code c, l)\n | _ -> assert false)\n const_lambda_list\n in\n call_switcher loc fail arg 0 255 int_lambda_list\n | Const_string _ ->\n (* Note as the bytecode compiler may resort to dichotomic search,\n the clauses of stringswitch are sorted with duplicates removed.\n This partly applies to the native code compiler, which requires\n no duplicates *)\n let const_lambda_list = sort_lambda_list const_lambda_list in\n let sw =\n List.map\n (fun (c, act) ->\n match c with\n | Const_string (s, _, _) -> (s, act)\n | _ -> assert false)\n const_lambda_list\n in\n let hs, sw, fail = share_actions_tree sw fail in\n hs (Lstringswitch (arg, sw, fail, loc))\n | Const_float _ ->\n make_test_sequence loc fail (Pfloatcomp CFneq) (Pfloatcomp CFlt) arg\n const_lambda_list\n | Const_int32 _ ->\n make_test_sequence loc fail\n (Pbintcomp (Pint32, Cne))\n (Pbintcomp (Pint32, Clt))\n arg const_lambda_list\n | Const_int64 _ ->\n make_test_sequence loc fail\n (Pbintcomp (Pint64, Cne))\n (Pbintcomp (Pint64, Clt))\n arg const_lambda_list\n | Const_nativeint _ ->\n make_test_sequence loc fail\n (Pbintcomp (Pnativeint, Cne))\n (Pbintcomp (Pnativeint, Clt))\n arg const_lambda_list\n in\n (lambda1, Jumps.union local_jumps total)\n\nlet split_cases tag_lambda_list =\n let rec split_rec = function\n | [] -> ([], [])\n | (cstr_tag, act) :: rem -> (\n let consts, nonconsts = split_rec rem in\n match cstr_tag with\n | Cstr_constant n -> ((n, act) :: consts, nonconsts)\n | Cstr_block n -> (consts, (n, act) :: nonconsts)\n | Cstr_unboxed -> (consts, (0, act) :: nonconsts)\n | Cstr_extension _ -> assert false\n )\n in\n let const, nonconst = split_rec tag_lambda_list in\n (sort_int_lambda_list const, sort_int_lambda_list nonconst)\n\nlet split_extension_cases tag_lambda_list =\n let rec split_rec = function\n | [] -> ([], [])\n | (cstr_tag, act) :: rem -> (\n let consts, nonconsts = split_rec rem in\n match cstr_tag with\n | Cstr_extension (path, true) -> ((path, act) :: consts, nonconsts)\n | Cstr_extension (path, false) -> (consts, (path, act) :: nonconsts)\n | _ -> assert false\n )\n in\n split_rec tag_lambda_list\n\nlet combine_constructor loc arg pat_env cstr partial ctx def\n (descr_lambda_list, total1, pats) =\n let tag_lambda (cstr, act) = (cstr.cstr_tag, act) in\n match cstr.cstr_tag with\n | Cstr_extension _ ->\n (* Special cases for extensions *)\n let fail, local_jumps = mk_failaction_neg partial ctx def in\n let lambda1 =\n let consts, nonconsts =\n split_extension_cases (List.map tag_lambda descr_lambda_list) in\n let default, consts, nonconsts =\n match fail with\n | None -> (\n match (consts, nonconsts) with\n | _, (_, act) :: rem -> (act, consts, rem)\n | (_, act) :: rem, _ -> (act, rem, nonconsts)\n | _ -> assert false\n )\n | Some fail -> (fail, consts, nonconsts)\n in\n let nonconst_lambda =\n match nonconsts with\n | [] -> default\n | _ ->\n let tag = Ident.create_local \"tag\" in\n let tests =\n List.fold_right\n (fun (path, act) rem ->\n let ext = transl_extension_path loc pat_env path in\n Lifthenelse\n (Lprim (Pintcomp Ceq, [ Lvar tag; ext ], loc), act, rem))\n nonconsts default\n in\n Llet (Alias, Pgenval, tag, Lprim (Pfield 0, [ arg ], loc), tests)\n in\n List.fold_right\n (fun (path, act) rem ->\n let ext = transl_extension_path loc pat_env path in\n Lifthenelse (Lprim (Pintcomp Ceq, [ arg; ext ], loc), act, rem))\n consts nonconst_lambda\n in\n (lambda1, Jumps.union local_jumps total1)\n | _ ->\n (* Regular concrete type *)\n let ncases = List.length descr_lambda_list\n and nconstrs = cstr.cstr_consts + cstr.cstr_nonconsts in\n let sig_complete = ncases = nconstrs in\n let fail_opt, fails, local_jumps =\n if sig_complete then\n (None, [], Jumps.empty)\n else\n let constrs =\n List.map2 (fun (constr, _act) p -> { p with pat_desc = constr })\n descr_lambda_list pats in\n mk_failaction_pos partial constrs ctx def\n in\n let descr_lambda_list = fails @ descr_lambda_list in\n let consts, nonconsts =\n split_cases (List.map tag_lambda descr_lambda_list) in\n let lambda1 =\n match (fail_opt, same_actions descr_lambda_list) with\n | None, Some act -> act (* Identical actions, no failure *)\n | _ -> (\n match\n (cstr.cstr_consts, cstr.cstr_nonconsts, consts, nonconsts)\n with\n | 1, 1, [ (0, act1) ], [ (0, act2) ] ->\n if !Clflags.native_code then\n Lifthenelse(Lprim (Pisint, [ arg ], loc), act1, act2)\n else\n (* PR#10681: we use [arg] directly as the test here;\n it generates better bytecode for this common case\n (typically options and lists), but would prevent\n some optimizations with the native compiler. *)\n Lifthenelse (arg, act2, act1)\n | n, 0, _, [] ->\n (* The type defines constant constructors only *)\n call_switcher loc fail_opt arg 0 (n - 1) consts\n | n, _, _, _ -> (\n let act0 =\n (* = Some act when all non-const constructors match to act *)\n match (fail_opt, nonconsts) with\n | Some a, [] -> Some a\n | Some _, _ ->\n if List.length nonconsts = cstr.cstr_nonconsts then\n same_actions nonconsts\n else\n None\n | None, _ -> same_actions nonconsts\n in\n match act0 with\n | Some act ->\n Lifthenelse\n ( Lprim (Pisint, [ arg ], loc),\n call_switcher loc fail_opt arg 0 (n - 1) consts,\n act )\n | None ->\n (* Emit a switch, as bytecode implements this sophisticated\n instruction *)\n let sw =\n { sw_numconsts = cstr.cstr_consts;\n sw_consts = consts;\n sw_numblocks = cstr.cstr_nonconsts;\n sw_blocks = nonconsts;\n sw_failaction = fail_opt\n }\n in\n let hs, sw = share_actions_sw sw in\n let sw = reintroduce_fail sw in\n hs (Lswitch (arg, sw, loc))\n )\n )\n in\n (lambda1, Jumps.union local_jumps total1)\n\nlet make_test_sequence_variant_constant fail arg int_lambda_list =\n let _, (cases, actions) = as_interval fail min_int max_int int_lambda_list in\n Switcher.test_sequence arg cases actions\n\nlet call_switcher_variant_constant loc fail arg int_lambda_list =\n call_switcher loc fail arg min_int max_int int_lambda_list\n\nlet call_switcher_variant_constr loc fail arg int_lambda_list =\n let v = Ident.create_local \"variant\" in\n Llet\n ( Alias,\n Pgenval,\n v,\n Lprim (Pfield 0, [ arg ], loc),\n call_switcher loc fail (Lvar v) min_int max_int int_lambda_list )\n\nlet combine_variant loc row arg partial ctx def (tag_lambda_list, total1, _pats)\n =\n let num_constr = ref 0 in\n if row_closed row then\n List.iter\n (fun (_, f) ->\n match row_field_repr f with\n | Rabsent\n | Reither (true, _ :: _, _) ->\n ()\n | _ -> incr num_constr)\n (row_fields row)\n else\n num_constr := max_int;\n let test_int_or_block arg if_int if_block =\n Lifthenelse (Lprim (Pisint, [ arg ], loc), if_int, if_block)\n in\n let sig_complete = List.length tag_lambda_list = !num_constr\n and one_action = same_actions tag_lambda_list in\n let fail, local_jumps =\n if\n sig_complete\n ||\n match partial with\n | Total -> true\n | _ -> false\n then\n (None, Jumps.empty)\n else\n mk_failaction_neg partial ctx def\n in\n let consts, nonconsts = split_cases tag_lambda_list in\n let lambda1 =\n match (fail, one_action) with\n | None, Some act -> act\n | _, _ -> (\n match (consts, nonconsts) with\n | [ (_, act1) ], [ (_, act2) ] when fail = None ->\n test_int_or_block arg act1 act2\n | _, [] ->\n (* One can compare integers and pointers *)\n make_test_sequence_variant_constant fail arg consts\n | [], _ -> (\n let lam = call_switcher_variant_constr loc fail arg nonconsts in\n (* One must not dereference integers *)\n match fail with\n | None -> lam\n | Some fail -> test_int_or_block arg fail lam\n )\n | _, _ ->\n let lam_const = call_switcher_variant_constant loc fail arg consts\n and lam_nonconst =\n call_switcher_variant_constr loc fail arg nonconsts\n in\n test_int_or_block arg lam_const lam_nonconst\n )\n in\n (lambda1, Jumps.union local_jumps total1)\n\nlet combine_array loc arg kind partial ctx def (len_lambda_list, total1, _pats)\n =\n let fail, local_jumps = mk_failaction_neg partial ctx def in\n let lambda1 =\n let newvar = Ident.create_local \"len\" in\n let switch =\n call_switcher loc fail (Lvar newvar) 0 max_int len_lambda_list\n in\n bind Alias newvar (Lprim (Parraylength kind, [ arg ], loc)) switch\n in\n (lambda1, Jumps.union local_jumps total1)\n\n(* Insertion of debugging events *)\n\nlet rec event_branch repr lam =\n match (lam, repr) with\n | _, None -> lam\n | Levent (lam', ev), Some r ->\n incr r;\n Levent\n ( lam',\n { lev_loc = ev.lev_loc;\n lev_kind = ev.lev_kind;\n lev_repr = repr;\n lev_env = ev.lev_env\n } )\n | Llet (str, k, id, lam, body), _ ->\n Llet (str, k, id, lam, event_branch repr body)\n | Lstaticraise _, _ -> lam\n | _, Some _ ->\n Printlambda.lambda Format.str_formatter lam;\n fatal_error (\"Matching.event_branch: \" ^ Format.flush_str_formatter ())\n\n(*\n This exception is raised when the compiler cannot produce code\n because control cannot reach the compiled clause,\n\n Unused is raised initially in compile_test.\n\n compile_list (for compiling switch results) catch Unused\n\n comp_match_handlers (for compiling split matches)\n may reraise Unused\n\n\n*)\n\nexception Unused\n\nlet compile_list compile_fun division =\n let rec c_rec totals = function\n | [] -> ([], Jumps.unions totals, [])\n | (key, cell) :: rem -> (\n if Context.is_empty cell.ctx then\n c_rec totals rem\n else begin\n match compile_fun cell.ctx cell.pm with\n | exception Unused -> c_rec totals rem\n | lambda1, total1 ->\n let c_rem, total, new_discrs =\n c_rec (Jumps.map Context.combine total1 :: totals) rem\n in\n ( (key, lambda1) :: c_rem,\n total,\n Patterns.Head.to_omega_pattern cell.discr :: new_discrs )\n end\n )\n in\n c_rec [] division\n\nlet compile_orhandlers compile_fun lambda1 total1 ctx to_catch =\n let rec do_rec r total_r = function\n | [] -> (r, total_r)\n | { provenance = mat; exit = i; vars; pm } :: rem -> (\n let ctx = Context.select_columns mat ctx in\n match compile_fun ctx pm with\n | exception Unused ->\n do_rec (Lstaticcatch (r, (i, vars), lambda_unit)) total_r rem\n | handler_i, total_i ->\n begin match raw_action r with\n | Lstaticraise (j, args) ->\n if i = j then\n ( List.fold_right2\n (bind_with_value_kind Alias)\n vars args handler_i,\n Jumps.map (Context.rshift_num (ncols mat)) total_i )\n else\n do_rec r total_r rem\n | _ ->\n do_rec\n (Lstaticcatch (r, (i, vars), handler_i))\n (Jumps.union (Jumps.remove i total_r)\n (Jumps.map (Context.rshift_num (ncols mat)) total_i))\n rem\n end\n )\n in\n do_rec lambda1 total1 to_catch\n\nlet compile_test compile_fun partial divide combine ctx to_match =\n let division = divide ctx to_match in\n let c_div = compile_list compile_fun division.cells in\n match c_div with\n | [], _, _ -> (\n match mk_failaction_neg partial ctx to_match.default with\n | None, _ -> raise Unused\n | Some l, total -> (l, total)\n )\n | _ -> combine ctx to_match.default c_div\n\n(* Attempt to avoid some useless bindings by lowering them *)\n\n(* Approximation of v present in lam *)\nlet rec approx_present v = function\n | Lconst _ -> false\n | Lstaticraise (_, args) ->\n List.exists (fun lam -> approx_present v lam) args\n | Lprim (_, args, _) -> List.exists (fun lam -> approx_present v lam) args\n | Llet (Alias, _k, _, l1, l2) -> approx_present v l1 || approx_present v l2\n | Lvar vv -> Ident.same v vv\n | _ -> true\n\nlet rec lower_bind v arg lam =\n match lam with\n | Lifthenelse (cond, ifso, ifnot) -> (\n let pcond = approx_present v cond\n and pso = approx_present v ifso\n and pnot = approx_present v ifnot in\n match (pcond, pso, pnot) with\n | false, false, false -> lam\n | false, true, false -> Lifthenelse (cond, lower_bind v arg ifso, ifnot)\n | false, false, true -> Lifthenelse (cond, ifso, lower_bind v arg ifnot)\n | _, _, _ -> bind Alias v arg lam\n )\n | Lswitch (ls, ({ sw_consts = [ (i, act) ]; sw_blocks = [] } as sw), loc)\n when not (approx_present v ls) ->\n Lswitch (ls, { sw with sw_consts = [ (i, lower_bind v arg act) ] }, loc)\n | Lswitch (ls, ({ sw_consts = []; sw_blocks = [ (i, act) ] } as sw), loc)\n when not (approx_present v ls) ->\n Lswitch (ls, { sw with sw_blocks = [ (i, lower_bind v arg act) ] }, loc)\n | Llet (Alias, k, vv, lv, l) ->\n if approx_present v lv then\n bind Alias v arg lam\n else\n Llet (Alias, k, vv, lv, lower_bind v arg l)\n | _ -> bind Alias v arg lam\n\nlet bind_check str v arg lam =\n match (str, arg) with\n | _, Lvar _ -> bind str v arg lam\n | Alias, _ -> lower_bind v arg lam\n | _, _ -> bind str v arg lam\n\nlet comp_exit ctx m =\n match Default_environment.pop m.default with\n | Some ((_, i), _) -> (Lstaticraise (i, []), Jumps.singleton i ctx)\n | None -> fatal_error \"Matching.comp_exit\"\n\nlet rec comp_match_handlers comp_fun partial ctx first_match next_matchs =\n match next_matchs with\n | [] -> comp_fun partial ctx first_match\n | rem -> (\n let rec c_rec body total_body = function\n | [] -> (body, total_body)\n (* Hum, -1 means never taken\n | (-1,pm)::rem -> c_rec body total_body rem *)\n | (i, pm) :: rem -> (\n let ctx_i, total_rem = Jumps.extract i total_body in\n if Context.is_empty ctx_i then\n c_rec body total_body rem\n else begin\n let partial = match rem with\n | [] -> partial\n | _ -> Partial\n in\n match comp_fun partial ctx_i pm with\n | li, total_i ->\n c_rec\n (Lstaticcatch (body, (i, []), li))\n (Jumps.union total_i total_rem)\n rem\n | exception Unused ->\n c_rec\n (Lstaticcatch (body, (i, []), lambda_unit))\n total_rem rem\n end\n )\n in\n match comp_fun Partial ctx first_match with\n | first_lam, total ->\n c_rec first_lam total rem\n | exception Unused -> (\n match next_matchs with\n | [] -> raise Unused\n | (_, x) :: xs -> comp_match_handlers comp_fun partial ctx x xs\n )\n )\n\n(* To find reasonable names for variables *)\n\nlet rec name_pattern default = function\n | ((pat, _), _) :: rem -> (\n match pat.pat_desc with\n | Tpat_var (id, _) -> id\n | Tpat_alias (_, id, _) -> id\n | _ -> name_pattern default rem\n )\n | _ -> Ident.create_local default\n\nlet arg_to_var arg cls =\n match arg with\n | Lvar v -> (v, arg)\n | _ ->\n let v = name_pattern \"*match*\" cls in\n (v, Lvar v)\n\n(*\n The main compilation function.\n Input:\n repr=used for inserting debug events\n partial=exhaustiveness information from Parmatch\n ctx=a context\n m=a pattern matching\n\n Output: a lambda term, a jump summary {..., exit number -> context, .. }\n*)\n\nlet rec compile_match ~scopes repr partial ctx\n (m : initial_clause pattern_matching) =\n match m.cases with\n | ([], action) :: rem ->\n if is_guarded action then\n let lambda, total =\n compile_match ~scopes None partial ctx { m with cases = rem }\n in\n (event_branch repr (patch_guarded lambda action), total)\n else\n (event_branch repr action, Jumps.empty)\n | nonempty_cases ->\n compile_match_nonempty ~scopes repr partial ctx\n { m with cases = map_on_rows Non_empty_row.of_initial nonempty_cases }\n\nand compile_match_nonempty ~scopes repr partial ctx\n (m : Typedtree.pattern Non_empty_row.t clause pattern_matching) =\n match m with\n | { cases = []; args = [] } -> comp_exit ctx m\n | { args = (arg, str) :: argl } ->\n let v, newarg = arg_to_var arg m.cases in\n let args = (newarg, Alias) :: argl in\n let cases = List.map (half_simplify_nonempty ~arg:newarg) m.cases in\n let m = { m with args; cases } in\n let first_match, rem =\n split_and_precompile_half_simplified ~arg:newarg m in\n combine_handlers ~scopes repr partial ctx (v, str, arg) first_match rem\n | _ -> assert false\n\nand compile_match_simplified ~scopes repr partial ctx\n (m : Simple.clause pattern_matching) =\n match m with\n | { cases = []; args = [] } -> comp_exit ctx m\n | { args = ((Lvar v as arg), str) :: argl } ->\n let args = (arg, Alias) :: argl in\n let m = { m with args } in\n let first_match, rem = split_and_precompile_simplified m in\n combine_handlers ~scopes repr partial ctx (v, str, arg) first_match rem\n | _ -> assert false\n\nand combine_handlers ~scopes repr partial ctx (v, str, arg) first_match rem =\n let lam, total =\n comp_match_handlers\n (( if dbg then\n do_compile_matching_pr ~scopes\n else\n do_compile_matching ~scopes\n )\n repr)\n partial ctx first_match rem\n in\n (bind_check str v arg lam, total)\n\n(* verbose version of do_compile_matching, for debug *)\nand do_compile_matching_pr ~scopes repr partial ctx x =\n Format.eprintf \"COMPILE: %s\\nMATCH\\n\"\n ( match partial with\n | Partial -> \"Partial\"\n | Total -> \"Total\"\n );\n pretty_precompiled x;\n Format.eprintf \"CTX\\n\";\n Context.eprintf ctx;\n let ((_, jumps) as r) = do_compile_matching ~scopes repr partial ctx x in\n Format.eprintf \"JUMPS\\n\";\n Jumps.eprintf jumps;\n r\n\nand do_compile_matching ~scopes repr partial ctx pmh =\n match pmh with\n | Pm pm -> (\n let arg =\n match pm.args with\n | (first_arg, _) :: _ -> first_arg\n | _ ->\n (* We arrive in do_compile_matching from:\n - compile_matching\n - recursive call on PmVars\n The first one explicitly checks that [args] is nonempty, the\n second one is only generated when the inner pm first looks at\n a variable (i.e. there is something to look at).\n *)\n assert false\n in\n let ph = what_is_cases pm.cases in\n let pomega = Patterns.Head.to_omega_pattern ph in\n let ploc = head_loc ~scopes ph in\n let open Patterns.Head in\n match ph.pat_desc with\n | Any ->\n compile_no_test ~scopes\n divide_var\n Context.rshift repr partial ctx pm\n | Tuple _ ->\n compile_no_test ~scopes\n (divide_tuple ~scopes ph)\n Context.combine repr partial ctx pm\n | Record [] -> assert false\n | Record (lbl :: _) ->\n compile_no_test ~scopes\n (divide_record ~scopes lbl.lbl_all ph)\n Context.combine repr partial ctx pm\n | Constant cst ->\n compile_test\n (compile_match ~scopes repr partial)\n partial divide_constant\n (combine_constant ploc arg cst partial)\n ctx pm\n | Construct cstr ->\n compile_test\n (compile_match ~scopes repr partial)\n partial (divide_constructor ~scopes)\n (combine_constructor ploc arg ph.pat_env cstr partial)\n ctx pm\n | Array _ ->\n let kind = Typeopt.array_pattern_kind pomega in\n compile_test\n (compile_match ~scopes repr partial)\n partial (divide_array ~scopes kind)\n (combine_array ploc arg kind partial)\n ctx pm\n | Lazy ->\n compile_no_test ~scopes\n (divide_lazy ~scopes ph)\n Context.combine repr partial ctx pm\n | Variant { cstr_row = row } ->\n compile_test\n (compile_match ~scopes repr partial)\n partial (divide_variant ~scopes !row)\n (combine_variant ploc !row arg partial)\n ctx pm\n )\n | PmVar { inside = pmh } ->\n let lam, total =\n do_compile_matching ~scopes repr partial (Context.lshift ctx) pmh\n in\n (lam, Jumps.map Context.rshift total)\n | PmOr { body; handlers } ->\n let lam, total =\n compile_match_simplified ~scopes repr partial ctx body in\n compile_orhandlers (compile_match ~scopes repr partial)\n lam total ctx handlers\n\nand compile_no_test ~scopes divide up_ctx repr partial ctx to_match =\n let { pm = this_match; ctx = this_ctx } = divide ctx to_match in\n let lambda, total =\n compile_match ~scopes repr partial this_ctx this_match in\n (lambda, Jumps.map up_ctx total)\n\n(* The entry points *)\n\n(*\n If there is a guard in a matching or a lazy pattern,\n then set exhaustiveness info to Partial.\n (because of side effects, assume the worst).\n\n Notice that exhaustiveness information is trusted by the compiler,\n that is, a match flagged as Total should not fail at runtime.\n More specifically, for instance if match y with x::_ -> x is flagged\n total (as it happens during JoCaml compilation) then y cannot be []\n at runtime. As a consequence, the static Total exhaustiveness information\n have to be downgraded to Partial, in the dubious cases where guards\n or lazy pattern execute arbitrary code that may perform side effects\n and change the subject values.\nLM:\n Lazy pattern was PR#5992, initial patch by lpw25.\n I have generalized the patch, so as to also find mutable fields.\n*)\n\nlet is_lazy_pat p =\n match p.pat_desc with\n | Tpat_lazy _ -> true\n | Tpat_alias _\n | Tpat_variant _\n | Tpat_record _\n | Tpat_tuple _\n | Tpat_construct _\n | Tpat_array _\n | Tpat_or _\n | Tpat_constant _\n | Tpat_var _\n | Tpat_any ->\n false\n\nlet has_lazy p = Typedtree.exists_pattern is_lazy_pat p\n\nlet is_record_with_mutable_field p =\n match p.pat_desc with\n | Tpat_record (lps, _) ->\n List.exists\n (fun (_, lbl, _) ->\n match lbl.Types.lbl_mut with\n | Mutable -> true\n | Immutable -> false)\n lps\n | Tpat_alias _\n | Tpat_variant _\n | Tpat_lazy _\n | Tpat_tuple _\n | Tpat_construct _\n | Tpat_array _\n | Tpat_or _\n | Tpat_constant _\n | Tpat_var _\n | Tpat_any ->\n false\n\nlet has_mutable p = Typedtree.exists_pattern is_record_with_mutable_field p\n\n(* Downgrade Total when\n 1. Matching accesses some mutable fields;\n 2. And there are guards or lazy patterns.\n*)\n\nlet check_partial has_mutable has_lazy pat_act_list = function\n | Partial -> Partial\n | Total ->\n if\n pat_act_list = []\n || (* allow empty case list *)\n List.exists\n (fun (pats, lam) ->\n has_mutable pats && (is_guarded lam || has_lazy pats))\n pat_act_list\n then\n Partial\n else\n Total\n\nlet check_partial_list pats_act_list =\n check_partial (List.exists has_mutable) (List.exists has_lazy) pats_act_list\n\nlet check_partial pat_act_list =\n check_partial has_mutable has_lazy pat_act_list\n\n(* have toplevel handler when appropriate *)\n\ntype failer_kind =\n | Raise_match_failure\n | Reraise_noloc of lambda\n\nlet failure_handler ~scopes loc ~failer () =\n match failer with\n | Reraise_noloc exn_lam ->\n Lprim (Praise Raise_reraise, [ exn_lam ], Scoped_location.Loc_unknown)\n | Raise_match_failure ->\n let sloc = Scoped_location.of_location ~scopes loc in\n let slot =\n transl_extension_path sloc\n Env.initial_safe_string Predef.path_match_failure\n in\n let fname, line, char =\n Location.get_pos_info loc.Location.loc_start in\n Lprim\n ( Praise Raise_regular,\n [ Lprim\n ( Pmakeblock (0, Immutable, None),\n [ slot;\n Lconst\n (Const_block\n ( 0,\n [ Const_base (Const_string (fname, loc, None));\n Const_base (Const_int line);\n Const_base (Const_int char)\n ] ))\n ],\n sloc )\n ],\n sloc )\n\nlet check_total ~scopes loc ~failer total lambda i =\n if Jumps.is_empty total then\n lambda\n else\n Lstaticcatch (lambda, (i, []),\n failure_handler ~scopes loc ~failer ())\n\nlet toplevel_handler ~scopes loc ~failer partial args cases compile_fun =\n match partial with\n | Total ->\n let default = Default_environment.empty in\n let pm = { args; cases; default } in\n let (lam, total) = compile_fun Total pm in\n assert (Jumps.is_empty total);\n lam\n | Partial ->\n let raise_num = next_raise_count () in\n let default =\n Default_environment.cons [ Patterns.omega_list args ] raise_num\n Default_environment.empty in\n let pm = { args; cases; default } in\n begin match compile_fun Partial pm with\n | exception Unused -> assert false\n | (lam, total) ->\n check_total ~scopes loc ~failer total lam raise_num\n end\n\nlet compile_matching ~scopes loc ~failer repr arg pat_act_list partial =\n let partial = check_partial pat_act_list partial in\n let args = [ (arg, Strict) ] in\n let rows = map_on_rows (fun pat -> (pat, [])) pat_act_list in\n toplevel_handler ~scopes loc ~failer partial args rows (fun partial pm ->\n compile_match_nonempty ~scopes repr partial (Context.start 1) pm)\n\nlet for_function ~scopes loc repr param pat_act_list partial =\n compile_matching ~scopes loc ~failer:Raise_match_failure\n repr param pat_act_list partial\n\n(* In the following two cases, exhaustiveness info is not available! *)\nlet for_trywith ~scopes loc param pat_act_list =\n (* Note: the failure action of [for_trywith] corresponds\n to an exception that is not matched by a try..with handler,\n and is thus reraised for the next handler in the stack.\n\n It is important to *not* include location information in\n the reraise (hence the [_noloc]) to avoid seeing this\n silent reraise in exception backtraces. *)\n compile_matching ~scopes loc ~failer:(Reraise_noloc param)\n None param pat_act_list Partial\n\nlet simple_for_let ~scopes loc param pat body =\n compile_matching ~scopes loc ~failer:Raise_match_failure\n None param [ (pat, body) ] Partial\n\n(* Optimize binding of immediate tuples\n\n The goal of the implementation of 'for_let' below, which replaces\n 'simple_for_let', is to avoid tuple allocation in cases such as\n this one:\n\n let (x,y) =\n let foo = ... in\n if foo then (1, 2) else (3,4)\n in bar\n\n The compiler easily optimizes the simple `let (x,y) = (1,2) in ...`\n case (call to Matching.for_multiple_match from Translcore), but\n didn't optimize situations where the rhs tuples are hidden under\n a more complex context.\n\n The idea comes from Alain Frisch who suggested and implemented\n the following compilation method, based on Lassign:\n\n let x = dummy in let y = dummy in\n begin\n let foo = ... in\n if foo then\n (let x1 = 1 in let y1 = 2 in x <- x1; y <- y1)\n else\n (let x2 = 3 in let y2 = 4 in x <- x2; y <- y2)\n end;\n bar\n\n The current implementation from Gabriel Scherer uses Lstaticcatch /\n Lstaticraise instead:\n\n catch\n let foo = ... in\n if foo then\n (let x1 = 1 in let y1 = 2 in exit x1 y1)\n else\n (let x2 = 3 in let y2 = 4 in exit x2 y2)\n with x y ->\n bar\n\n The catch/exit is used to avoid duplication of the let body ('bar'\n in the example), on 'if' branches for example; it is useless for\n linear contexts such as 'let', but we don't need to be careful to\n generate nice code because Simplif will remove such useless\n catch/exit.\n*)\n\nlet rec map_return f = function\n | Llet (str, k, id, l1, l2) -> Llet (str, k, id, l1, map_return f l2)\n | Lmutlet (k, id, l1, l2) -> Lmutlet (k, id, l1, map_return f l2)\n | Lletrec (l1, l2) -> Lletrec (l1, map_return f l2)\n | Lifthenelse (lcond, lthen, lelse) ->\n Lifthenelse (lcond, map_return f lthen, map_return f lelse)\n | Lsequence (l1, l2) -> Lsequence (l1, map_return f l2)\n | Levent (l, ev) -> Levent (map_return f l, ev)\n | Ltrywith (l1, id, l2) -> Ltrywith (map_return f l1, id, map_return f l2)\n | Lstaticcatch (l1, b, l2) ->\n Lstaticcatch (map_return f l1, b, map_return f l2)\n | Lswitch (s, sw, loc) ->\n let map_cases cases =\n List.map (fun (i, l) -> (i, map_return f l)) cases\n in\n Lswitch\n ( s,\n { sw with\n sw_consts = map_cases sw.sw_consts;\n sw_blocks = map_cases sw.sw_blocks;\n sw_failaction = Option.map (map_return f) sw.sw_failaction\n },\n loc )\n | Lstringswitch (s, cases, def, loc) ->\n Lstringswitch\n ( s,\n List.map (fun (s, l) -> (s, map_return f l)) cases,\n Option.map (map_return f) def,\n loc )\n | (Lstaticraise _ | Lprim (Praise _, _, _)) as l -> l\n | ( Lvar _ | Lmutvar _ | Lconst _ | Lapply _ | Lfunction _ | Lsend _ | Lprim _\n | Lwhile _ | Lfor _ | Lassign _ | Lifused _ ) as l ->\n f l\n\n(* The 'opt' reference indicates if the optimization is worthy.\n\n It is shared by the different calls to 'assign_pat' performed from\n 'map_return'. For example with the code\n let (x, y) = if foo then z else (1,2)\n the else-branch will activate the optimization for both branches.\n\n That means that the optimization is activated if *there exists* an\n interesting tuple in one hole of the let-rhs context. We could\n choose to activate it only if *all* holes are interesting. We made\n that choice because being optimistic is extremely cheap (one static\n exit/catch overhead in the \"wrong cases\"), while being pessimistic\n can be costly (one unnecessary tuple allocation).\n*)\n\nlet assign_pat ~scopes opt nraise catch_ids loc pat lam =\n let rec collect acc pat lam =\n match (pat.pat_desc, lam) with\n | Tpat_tuple patl, Lprim (Pmakeblock _, lams, _) ->\n opt := true;\n List.fold_left2 collect acc patl lams\n | Tpat_tuple patl, Lconst (Const_block (_, scl)) ->\n opt := true;\n let collect_const acc pat sc = collect acc pat (Lconst sc) in\n List.fold_left2 collect_const acc patl scl\n | _ ->\n (* pattern idents will be bound in staticcatch (let body), so we\n refresh them here to guarantee binders uniqueness *)\n let pat_ids = pat_bound_idents pat in\n let fresh_ids = List.map (fun id -> (id, Ident.rename id)) pat_ids in\n (fresh_ids, alpha_pat fresh_ids pat, lam) :: acc\n in\n (* sublets were accumulated by 'collect' with the leftmost tuple\n pattern at the bottom of the list; to respect right-to-left\n evaluation order for tuples, we must evaluate sublets\n top-to-bottom. To preserve tail-rec, we will fold_left the\n reversed list. *)\n let rev_sublets = List.rev (collect [] pat lam) in\n let exit =\n (* build an Ident.tbl to avoid quadratic refreshing costs *)\n let add t (id, fresh_id) = Ident.add id fresh_id t in\n let add_ids acc (ids, _pat, _lam) = List.fold_left add acc ids in\n let tbl = List.fold_left add_ids Ident.empty rev_sublets in\n let fresh_var id = Lvar (Ident.find_same id tbl) in\n Lstaticraise (nraise, List.map fresh_var catch_ids)\n in\n let push_sublet code (_ids, pat, lam) =\n simple_for_let ~scopes loc lam pat code in\n List.fold_left push_sublet exit rev_sublets\n\nlet for_let ~scopes loc param pat body =\n match pat.pat_desc with\n | Tpat_any ->\n (* This eliminates a useless variable (and stack slot in bytecode)\n for \"let _ = ...\". See #6865. *)\n Lsequence (param, body)\n | Tpat_var (id, _) ->\n (* fast path, and keep track of simple bindings to unboxable numbers *)\n let k = Typeopt.value_kind pat.pat_env pat.pat_type in\n Llet (Strict, k, id, param, body)\n | _ ->\n let opt = ref false in\n let nraise = next_raise_count () in\n let catch_ids = pat_bound_idents_full pat in\n let ids_with_kinds =\n List.map\n (fun (id, _, typ) -> (id, Typeopt.value_kind pat.pat_env typ))\n catch_ids\n in\n let ids = List.map (fun (id, _, _) -> id) catch_ids in\n let bind =\n map_return (assign_pat ~scopes opt nraise ids loc pat) param in\n if !opt then\n Lstaticcatch (bind, (nraise, ids_with_kinds), body)\n else\n simple_for_let ~scopes loc param pat body\n\n(* Handling of tupled functions and matchings *)\n\n(* Easy case since variables are available *)\nlet for_tupled_function ~scopes loc paraml pats_act_list partial =\n let partial = check_partial_list pats_act_list partial in\n let args = List.map (fun id -> (Lvar id, Strict)) paraml in\n let handler =\n toplevel_handler ~scopes loc ~failer:Raise_match_failure\n partial args pats_act_list in\n handler (fun partial pm ->\n compile_match ~scopes None partial\n (Context.start (List.length paraml)) pm\n )\n\nlet flatten_pattern size p =\n match p.pat_desc with\n | Tpat_tuple args -> args\n | Tpat_any -> Patterns.omegas size\n | _ -> raise Cannot_flatten\n\nlet flatten_simple_pattern size (p : Simple.pattern) =\n match p.pat_desc with\n | `Tuple args -> args\n | `Any -> Patterns.omegas size\n | `Array _\n | `Variant _\n | `Record _\n | `Lazy _\n | `Construct _\n | `Constant _ ->\n (* All calls to this function originate from [do_for_multiple_match],\n where we know that the scrutinee is a tuple literal.\n\n Since the PM is well typed, none of these cases are possible. *)\n let msg =\n Format.fprintf Format.str_formatter\n \"Matching.flatten_pattern: got '%a'\" top_pretty (General.erase p);\n Format.flush_str_formatter ()\n in\n fatal_error msg\n\nlet flatten_cases size cases =\n List.map\n (function\n | (p, []), action -> (\n match flatten_simple_pattern size p with\n | p :: ps -> ((p, ps), action)\n | [] -> assert false\n )\n | _ -> fatal_error \"Matching.flatten_hc_cases\")\n cases\n\nlet flatten_pm size args pm =\n { args;\n cases = flatten_cases size pm.cases;\n default = Default_environment.flatten size pm.default\n }\n\nlet flatten_handler size handler =\n { handler with provenance = flatten_matrix size handler.provenance }\n\ntype pm_flattened =\n | FPmOr of (pattern, unit) pm_or_compiled\n | FPm of pattern Non_empty_row.t clause pattern_matching\n\nlet flatten_precompiled size args pmh =\n match pmh with\n | Pm pm -> FPm (flatten_pm size args pm)\n | PmOr { body = b; handlers = hs; or_matrix = _ } ->\n FPmOr\n { body = flatten_pm size args b;\n handlers = List.map (flatten_handler size) hs;\n or_matrix = ();\n }\n | PmVar _ -> assert false\n\n(*\n compiled_flattened is a ``comp_fun'' argument to comp_match_handlers.\n Hence it needs a fourth argument, which it ignores\n*)\n\nlet compile_flattened ~scopes repr partial ctx pmh =\n match pmh with\n | FPm pm -> compile_match_nonempty ~scopes repr partial ctx pm\n | FPmOr { body = b; handlers = hs } ->\n let lam, total = compile_match_nonempty ~scopes repr partial ctx b in\n compile_orhandlers (compile_match ~scopes repr partial) lam total ctx hs\n\nlet do_for_multiple_match ~scopes loc paraml pat_act_list partial =\n let repr = None in\n let arg =\n let sloc = Scoped_location.of_location ~scopes loc in\n Lprim (Pmakeblock (0, Immutable, None), paraml, sloc) in\n let handler =\n let partial = check_partial pat_act_list partial in\n let rows = map_on_rows (fun p -> (p, [])) pat_act_list in\n toplevel_handler ~scopes loc ~failer:Raise_match_failure\n partial [ (arg, Strict) ] rows in\n handler (fun partial pm1 ->\n let pm1_half =\n { pm1 with cases = List.map (half_simplify_nonempty ~arg) pm1.cases }\n in\n let next, nexts = split_and_precompile_half_simplified ~arg pm1_half in\n let size = List.length paraml\n and idl = List.map (function\n | Lvar id -> id\n | _ -> Ident.create_local \"*match*\") paraml in\n let args = List.map (fun id -> (Lvar id, Alias)) idl in\n let flat_next = flatten_precompiled size args next\n and flat_nexts =\n List.map (fun (e, pm) -> (e, flatten_precompiled size args pm)) nexts\n in\n let lam, total =\n comp_match_handlers (compile_flattened ~scopes repr) partial\n (Context.start size) flat_next flat_nexts\n in\n List.fold_right2 (bind Strict) idl paraml lam, total\n )\n\n(* PR#4828: Believe it or not, the 'paraml' argument below\n may not be side effect free. *)\n\nlet param_to_var param =\n match param with\n | Lvar v -> (v, None)\n | _ -> (Ident.create_local \"*match*\", Some param)\n\nlet bind_opt (v, eo) k =\n match eo with\n | None -> k\n | Some e -> Lambda.bind Strict v e k\n\nlet for_multiple_match ~scopes loc paraml pat_act_list partial =\n let v_paraml = List.map param_to_var paraml in\n let paraml = List.map (fun (v, _) -> Lvar v) v_paraml in\n List.fold_right bind_opt v_paraml\n (do_for_multiple_match ~scopes loc paraml pat_act_list partial)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Chambart, OCamlPro *)\n(* *)\n(* Copyright 2015 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 Typedtree\nopen Lambda\nopen Location\n\nlet is_inline_attribute = function\n | {txt=(\"inline\"|\"ocaml.inline\")} -> true\n | _ -> false\n\nlet is_inlined_attribute = function\n | {txt=(\"inlined\"|\"ocaml.inlined\")} -> true\n | {txt=(\"unrolled\"|\"ocaml.unrolled\")} when Config.flambda -> true\n | _ -> false\n\nlet is_specialise_attribute = function\n | {txt=(\"specialise\"|\"ocaml.specialise\")} when Config.flambda -> true\n | _ -> false\n\nlet is_specialised_attribute = function\n | {txt=(\"specialised\"|\"ocaml.specialised\")} when Config.flambda -> true\n | _ -> false\n\nlet is_local_attribute = function\n | {txt=(\"local\"|\"ocaml.local\")} -> true\n | _ -> false\n\nlet is_tmc_attribute = function\n | {txt=(\"tail_mod_cons\"|\"ocaml.tail_mod_cons\")} -> true\n | _ -> false\n\nlet is_poll_attribute = function\n | {txt=(\"poll\")} -> true\n | _ -> false\n\nlet find_attribute p attributes =\n let inline_attribute, other_attributes =\n List.partition (fun a -> p a.Parsetree.attr_name) attributes\n in\n let attr =\n match inline_attribute with\n | [] -> None\n | [attr] -> Some attr\n | _ :: {Parsetree.attr_name = {txt;loc}; _} :: _ ->\n Location.prerr_warning loc (Warnings.Duplicated_attribute txt);\n None\n in\n attr, other_attributes\n\nlet is_unrolled = function\n | {txt=\"unrolled\"|\"ocaml.unrolled\"} -> true\n | {txt=\"inline\"|\"ocaml.inline\"|\"inlined\"|\"ocaml.inlined\"} -> false\n | _ -> assert false\n\nlet get_payload get_from_exp =\n let open Parsetree in\n function\n | PStr [{pstr_desc = Pstr_eval (exp, [])}] -> get_from_exp exp\n | _ -> Result.Error ()\n\nlet get_optional_payload get_from_exp =\n let open Parsetree in\n function\n | PStr [] -> Result.Ok None\n | other -> Result.map Option.some (get_payload get_from_exp other)\n\nlet get_id_from_exp =\n let open Parsetree in\n function\n | { pexp_desc = Pexp_ident { txt = Longident.Lident id } } -> Result.Ok id\n | _ -> Result.Error ()\n\nlet get_int_from_exp =\n let open Parsetree in\n function\n | { pexp_desc = Pexp_constant (Pconst_integer(s, None)) } ->\n begin match Misc.Int_literal_converter.int s with\n | n -> Result.Ok n\n | exception (Failure _) -> Result.Error ()\n end\n | _ -> Result.Error ()\n\nlet get_construct_from_exp =\n let open Parsetree in\n function\n | { pexp_desc =\n Pexp_construct ({ txt = Longident.Lident constr }, None) } ->\n Result.Ok constr\n | _ -> Result.Error ()\n\nlet get_bool_from_exp exp =\n Result.bind (get_construct_from_exp exp)\n (function\n | \"true\" -> Result.Ok true\n | \"false\" -> Result.Ok false\n | _ -> Result.Error ())\n\nlet parse_id_payload txt loc ~default ~empty cases payload =\n let[@local] warn () =\n let ( %> ) f g x = g (f x) in\n let msg =\n cases\n |> List.map (fst %> Printf.sprintf \"'%s'\")\n |> String.concat \", \"\n |> Printf.sprintf \"It must be either %s or empty\"\n in\n Location.prerr_warning loc (Warnings.Attribute_payload (txt, msg));\n default\n in\n match get_optional_payload get_id_from_exp payload with\n | Error () -> warn ()\n | Ok None -> empty\n | Ok (Some id) ->\n match List.assoc_opt id cases with\n | Some r -> r\n | None -> warn ()\n\nlet parse_inline_attribute attr =\n match attr with\n | None -> Default_inline\n | Some {Parsetree.attr_name = {txt;loc} as id; attr_payload = payload} ->\n if is_unrolled id then begin\n (* the 'unrolled' attributes must be used as [@unrolled n]. *)\n let warning txt = Warnings.Attribute_payload\n (txt, \"It must be an integer literal\")\n in\n match get_payload get_int_from_exp payload with\n | Ok n -> Unroll n\n | Error () ->\n Location.prerr_warning loc (warning txt);\n Default_inline\n end else\n parse_id_payload txt loc\n ~default:Default_inline\n ~empty:Always_inline\n [\n \"never\", Never_inline;\n \"always\", Always_inline;\n \"hint\", Hint_inline;\n ]\n payload\n\nlet parse_specialise_attribute attr =\n match attr with\n | None -> Default_specialise\n | Some {Parsetree.attr_name = {txt; loc}; attr_payload = payload} ->\n parse_id_payload txt loc\n ~default:Default_specialise\n ~empty:Always_specialise\n [\n \"never\", Never_specialise;\n \"always\", Always_specialise;\n ]\n payload\n\nlet parse_local_attribute attr =\n match attr with\n | None -> Default_local\n | Some {Parsetree.attr_name = {txt; loc}; attr_payload = payload} ->\n parse_id_payload txt loc\n ~default:Default_local\n ~empty:Always_local\n [\n \"never\", Never_local;\n \"always\", Always_local;\n \"maybe\", Default_local;\n ]\n payload\n\nlet parse_poll_attribute attr =\n match attr with\n | None -> Default_poll\n | Some {Parsetree.attr_name = {txt; loc}; attr_payload = payload} ->\n parse_id_payload txt loc\n ~default:Default_poll\n ~empty:Default_poll\n [\n \"error\", Error_poll;\n ]\n payload\n\nlet get_inline_attribute l =\n let attr, _ = find_attribute is_inline_attribute l in\n parse_inline_attribute attr\n\nlet get_specialise_attribute l =\n let attr, _ = find_attribute is_specialise_attribute l in\n parse_specialise_attribute attr\n\nlet get_local_attribute l =\n let attr, _ = find_attribute is_local_attribute l in\n parse_local_attribute attr\n\nlet get_poll_attribute l =\n let attr, _ = find_attribute is_poll_attribute l in\n parse_poll_attribute attr\n\nlet check_local_inline loc attr =\n match attr.local, attr.inline with\n | Always_local, (Always_inline | Hint_inline | Unroll _) ->\n Location.prerr_warning loc\n (Warnings.Duplicated_attribute \"local/inline\")\n | _ ->\n ()\n\nlet check_poll_inline loc attr =\n match attr.poll, attr.inline with\n | Error_poll, (Always_inline | Hint_inline | Unroll _) ->\n Location.prerr_warning loc\n (Warnings.Inlining_impossible\n \"[@poll error] is incompatible with inlining\")\n | _ ->\n ()\n\nlet check_poll_local loc attr =\n match attr.poll, attr.local with\n | Error_poll, Always_local ->\n Location.prerr_warning loc\n (Warnings.Inlining_impossible\n \"[@poll error] is incompatible with local function optimization\")\n | _ ->\n ()\n\nlet lfunction_with_attr ~attr { kind; params; return; body; attr=_; loc } =\n lfunction ~kind ~params ~return ~body ~attr ~loc\n\nlet add_inline_attribute expr loc attributes =\n match expr, get_inline_attribute attributes with\n | expr, Default_inline -> expr\n | Lfunction({ attr = { stub = false } as attr } as funct), inline ->\n begin match attr.inline with\n | Default_inline -> ()\n | Always_inline | Hint_inline | Never_inline | Unroll _ ->\n Location.prerr_warning loc\n (Warnings.Duplicated_attribute \"inline\")\n end;\n let attr = { attr with inline } in\n check_local_inline loc attr;\n check_poll_inline loc attr;\n lfunction_with_attr ~attr funct\n | expr, (Always_inline | Hint_inline | Never_inline | Unroll _) ->\n Location.prerr_warning loc\n (Warnings.Misplaced_attribute \"inline\");\n expr\n\nlet add_specialise_attribute expr loc attributes =\n match expr, get_specialise_attribute attributes with\n | expr, Default_specialise -> expr\n | Lfunction({ attr = { stub = false } as attr } as funct), specialise ->\n begin match attr.specialise with\n | Default_specialise -> ()\n | Always_specialise | Never_specialise ->\n Location.prerr_warning loc\n (Warnings.Duplicated_attribute \"specialise\")\n end;\n let attr = { attr with specialise } in\n lfunction_with_attr ~attr funct\n | expr, (Always_specialise | Never_specialise) ->\n Location.prerr_warning loc\n (Warnings.Misplaced_attribute \"specialise\");\n expr\n\nlet add_local_attribute expr loc attributes =\n match expr, get_local_attribute attributes with\n | expr, Default_local -> expr\n | Lfunction({ attr = { stub = false } as attr } as funct), local ->\n begin match attr.local with\n | Default_local -> ()\n | Always_local | Never_local ->\n Location.prerr_warning loc\n (Warnings.Duplicated_attribute \"local\")\n end;\n let attr = { attr with local } in\n check_local_inline loc attr;\n check_poll_local loc attr;\n lfunction_with_attr ~attr funct\n | expr, (Always_local | Never_local) ->\n Location.prerr_warning loc\n (Warnings.Misplaced_attribute \"local\");\n expr\n\nlet add_tmc_attribute expr loc attributes =\n let is_tmc_attribute a = is_tmc_attribute a.Parsetree.attr_name in\n if List.exists is_tmc_attribute attributes then\n match expr with\n | Lfunction funct ->\n if funct.attr.tmc_candidate then\n Location.prerr_warning loc\n (Warnings.Duplicated_attribute \"tail_mod_cons\");\n let attr = { funct.attr with tmc_candidate = true } in\n lfunction_with_attr ~attr funct\n | expr ->\n Location.prerr_warning loc\n (Warnings.Misplaced_attribute \"tail_mod_cons\");\n expr\n else\n expr\n\nlet add_poll_attribute expr loc attributes =\n match expr, get_poll_attribute attributes with\n | expr, Default_poll -> expr\n | Lfunction({ attr = { stub = false } as attr } as funct), poll ->\n begin match attr.poll with\n | Default_poll -> ()\n | Error_poll ->\n Location.prerr_warning loc\n (Warnings.Duplicated_attribute \"error_poll\")\n end;\n let attr = { attr with poll } in\n check_poll_inline loc attr;\n check_poll_local loc attr;\n let attr = { attr with inline = Never_inline; local = Never_local } in\n lfunction_with_attr ~attr funct\n | expr, Error_poll ->\n Location.prerr_warning loc\n (Warnings.Misplaced_attribute \"error_poll\");\n expr\n\n(* Get the [@inlined] attribute payload (or default if not present).\n It also returns the expression without this attribute. This is\n used to ensure that this attribute is not misplaced: If it\n appears on any expression, it is an error, otherwise it would\n have been removed by this function *)\nlet get_and_remove_inlined_attribute e =\n let attr, exp_attributes =\n find_attribute is_inlined_attribute e.exp_attributes\n in\n let inlined = parse_inline_attribute attr in\n inlined, { e with exp_attributes }\n\nlet get_and_remove_inlined_attribute_on_module e =\n let rec get_and_remove mod_expr =\n let attr, mod_attributes =\n find_attribute is_inlined_attribute mod_expr.mod_attributes\n in\n let attr = parse_inline_attribute attr in\n let attr, mod_desc =\n match mod_expr.Typedtree.mod_desc with\n | Tmod_constraint (me, mt, mtc, mc) ->\n let inner_attr, me = get_and_remove me in\n let attr =\n match attr with\n | Always_inline | Hint_inline | Never_inline | Unroll _ -> attr\n | Default_inline -> inner_attr\n in\n attr, Tmod_constraint (me, mt, mtc, mc)\n | md -> attr, md\n in\n attr, { mod_expr with mod_desc; mod_attributes }\n in\n get_and_remove e\n\nlet get_and_remove_specialised_attribute e =\n let attr, exp_attributes =\n find_attribute is_specialised_attribute e.exp_attributes\n in\n let specialised = parse_specialise_attribute attr in\n specialised, { e with exp_attributes }\n\n(* It also removes the attribute from the expression, like\n get_inlined_attribute *)\nlet get_tailcall_attribute e =\n let is_tailcall_attribute = function\n | {Parsetree.attr_name = {txt=(\"tailcall\"|\"ocaml.tailcall\")}; _} -> true\n | _ -> false\n in\n let tailcalls, other_attributes =\n List.partition is_tailcall_attribute e.exp_attributes\n in\n let tailcall_attribute = match tailcalls with\n | [] -> Default_tailcall\n | {Parsetree.attr_name = {txt; loc}; attr_payload = payload} :: r ->\n begin match r with\n | [] -> ()\n | {Parsetree.attr_name = {txt;loc}; _} :: _ ->\n Location.prerr_warning loc (Warnings.Duplicated_attribute txt)\n end;\n match get_optional_payload get_bool_from_exp payload with\n | Ok (None | Some true) -> Tailcall_expectation true\n | Ok (Some false) -> Tailcall_expectation false\n | Error () ->\n let msg = \"Only an optional boolean literal is supported.\" in\n Location.prerr_warning loc (Warnings.Attribute_payload (txt, msg));\n Default_tailcall\n in\n tailcall_attribute, { e with exp_attributes = other_attributes }\n\nlet check_attribute e {Parsetree.attr_name = { txt; loc }; _} =\n match txt with\n | \"inline\" | \"ocaml.inline\"\n | \"specialise\" | \"ocaml.specialise\"\n | \"poll\" -> begin\n match e.exp_desc with\n | Texp_function _ -> ()\n | _ ->\n Location.prerr_warning loc\n (Warnings.Misplaced_attribute txt)\n end\n | \"inlined\" | \"ocaml.inlined\"\n | \"specialised\" | \"ocaml.specialised\"\n | \"tailcall\" | \"ocaml.tailcall\" ->\n (* Removed by the Texp_apply cases *)\n Location.prerr_warning loc\n (Warnings.Misplaced_attribute txt)\n | _ -> ()\n\nlet check_attribute_on_module e {Parsetree.attr_name = { txt; loc }; _} =\n match txt with\n | \"inline\" | \"ocaml.inline\" -> begin\n match e.mod_desc with\n | Tmod_functor _ -> ()\n | _ ->\n Location.prerr_warning loc\n (Warnings.Misplaced_attribute txt)\n end\n | \"inlined\" | \"ocaml.inlined\" ->\n (* Removed by the Texp_apply cases *)\n Location.prerr_warning loc\n (Warnings.Misplaced_attribute txt)\n | _ -> ()\n\nlet add_function_attributes lam loc attr =\n let lam =\n add_inline_attribute lam loc attr\n in\n let lam =\n add_specialise_attribute lam loc attr\n in\n let lam =\n add_local_attribute lam loc attr\n in\n let lam =\n add_tmc_attribute lam loc attr\n in\n let lam =\n (* last because poll overrides inline and local *)\n add_poll_attribute lam loc attr\n in\n lam\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Jerome Vouillon, 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 Asttypes\nopen Types\nopen Typedtree\nopen Lambda\nopen Translobj\nopen Translcore\nopen Debuginfo.Scoped_location\n\n(* XXX Rajouter des evenements... | Add more events... *)\n\ntype error = Tags of label * label\n\nexception Error of Location.t * error\n\nlet lfunction params body =\n if params = [] then body else\n match body with\n | Lfunction {kind = Curried; params = params'; body = body'; attr; loc}\n when List.length params + List.length params' <= Lambda.max_arity() ->\n lfunction ~kind:Curried ~params:(params @ params')\n ~return:Pgenval\n ~body:body'\n ~attr\n ~loc\n | _ ->\n lfunction ~kind:Curried ~params ~return:Pgenval\n ~body\n ~attr:default_function_attribute\n ~loc:Loc_unknown\n\nlet lapply ap =\n match ap.ap_func with\n Lapply ap' ->\n Lapply {ap with ap_func = ap'.ap_func; ap_args = ap'.ap_args @ ap.ap_args}\n | _ ->\n Lapply ap\n\nlet mkappl (func, args) =\n Lapply {\n ap_loc=Loc_unknown;\n ap_func=func;\n ap_args=args;\n ap_tailcall=Default_tailcall;\n ap_inlined=Default_inline;\n ap_specialised=Default_specialise;\n };;\n\nlet lsequence l1 l2 =\n if l2 = lambda_unit then l1 else Lsequence(l1, l2)\n\nlet lfield v i = Lprim(Pfield i, [Lvar v], Loc_unknown)\n\nlet transl_label l = share (Const_immstring l)\n\nlet transl_meth_list lst =\n if lst = [] then Lconst (const_int 0) else\n share (Const_block\n (0, List.map (fun lab -> Const_immstring lab) lst))\n\nlet set_inst_var ~scopes obj id expr =\n Lprim(Psetfield_computed (Typeopt.maybe_pointer expr, Assignment),\n [Lvar obj; Lvar id; transl_exp ~scopes expr], Loc_unknown)\n\nlet transl_val tbl create name =\n mkappl (oo_prim (if create then \"new_variable\" else \"get_variable\"),\n [Lvar tbl; transl_label name])\n\nlet transl_vals tbl create strict vals rem =\n List.fold_right\n (fun (name, id) rem ->\n Llet(strict, Pgenval, id, transl_val tbl create name, rem))\n vals rem\n\nlet meths_super tbl meths inh_meths =\n List.fold_right\n (fun (nm, id) rem ->\n try\n (nm, id,\n mkappl(oo_prim \"get_method\", [Lvar tbl; Lvar (Meths.find nm meths)]))\n :: rem\n with Not_found -> rem)\n inh_meths []\n\nlet bind_super tbl (vals, meths) cl_init =\n transl_vals tbl false StrictOpt vals\n (List.fold_right (fun (_nm, id, def) rem ->\n Llet(StrictOpt, Pgenval, id, def, rem))\n meths cl_init)\n\nlet create_object cl obj init =\n let obj' = Ident.create_local \"self\" in\n let (inh_init, obj_init, has_init) = init obj' in\n if obj_init = lambda_unit then\n (inh_init,\n mkappl (oo_prim (if has_init then \"create_object_and_run_initializers\"\n else\"create_object_opt\"),\n [obj; Lvar cl]))\n else begin\n (inh_init,\n Llet(Strict, Pgenval, obj',\n mkappl (oo_prim \"create_object_opt\", [obj; Lvar cl]),\n Lsequence(obj_init,\n if not has_init then Lvar obj' else\n mkappl (oo_prim \"run_initializers_opt\",\n [obj; Lvar obj'; Lvar cl]))))\n end\n\nlet name_pattern default p =\n match p.pat_desc with\n | Tpat_var (id, _) -> id\n | Tpat_alias(_, id, _) -> id\n | _ -> Ident.create_local default\n\nlet rec build_object_init ~scopes cl_table obj params inh_init obj_init cl =\n match cl.cl_desc with\n Tcl_ident (path, _, _) ->\n let obj_init = Ident.create_local \"obj_init\" in\n let envs, inh_init = inh_init in\n let env =\n match envs with None -> []\n | Some envs ->\n [Lprim(Pfield (List.length inh_init + 1),\n [Lvar envs],\n Loc_unknown)]\n in\n let loc = of_location ~scopes cl.cl_loc in\n let path_lam = transl_class_path loc cl.cl_env path in\n ((envs, (path, path_lam, obj_init) :: inh_init),\n mkappl(Lvar obj_init, env @ [obj]))\n | Tcl_structure str ->\n create_object cl_table obj (fun obj ->\n let (inh_init, obj_init, has_init) =\n List.fold_right\n (fun field (inh_init, obj_init, has_init) ->\n match field.cf_desc with\n Tcf_inherit (_, cl, _, _, _) ->\n let (inh_init, obj_init') =\n build_object_init ~scopes cl_table (Lvar obj) [] inh_init\n (fun _ -> lambda_unit) cl\n in\n (inh_init, lsequence obj_init' obj_init, true)\n | Tcf_val (_, _, id, Tcfk_concrete (_, exp), _) ->\n (inh_init,\n lsequence (set_inst_var ~scopes obj id exp) obj_init,\n has_init)\n | Tcf_method _ | Tcf_val _ | Tcf_constraint _ | Tcf_attribute _->\n (inh_init, obj_init, has_init)\n | Tcf_initializer _ ->\n (inh_init, obj_init, true)\n )\n str.cstr_fields\n (inh_init, obj_init obj, false)\n in\n (inh_init,\n List.fold_right\n (fun (id, expr) rem ->\n lsequence (Lifused (id, set_inst_var ~scopes obj id expr)) rem)\n params obj_init,\n has_init))\n | Tcl_fun (_, pat, vals, cl, partial) ->\n let (inh_init, obj_init) =\n build_object_init ~scopes cl_table obj (vals @ params)\n inh_init obj_init cl\n in\n (inh_init,\n let build params rem =\n let param = name_pattern \"param\" pat in\n Lambda.lfunction\n ~kind:Curried ~params:((param, Pgenval)::params)\n ~return:Pgenval\n ~attr:default_function_attribute\n ~loc:(of_location ~scopes pat.pat_loc)\n ~body:(Matching.for_function ~scopes pat.pat_loc\n None (Lvar param) [pat, rem] partial)\n in\n begin match obj_init with\n Lfunction {kind = Curried; params; body = rem} -> build params rem\n | rem -> build [] rem\n end)\n | Tcl_apply (cl, oexprs) ->\n let (inh_init, obj_init) =\n build_object_init ~scopes cl_table obj params inh_init obj_init cl\n in\n (inh_init, transl_apply ~scopes obj_init oexprs Loc_unknown)\n | Tcl_let (rec_flag, defs, vals, cl) ->\n let (inh_init, obj_init) =\n build_object_init ~scopes cl_table obj (vals @ params)\n inh_init obj_init cl\n in\n (inh_init, Translcore.transl_let ~scopes rec_flag defs obj_init)\n | Tcl_open (_, cl)\n | Tcl_constraint (cl, _, _, _, _) ->\n build_object_init ~scopes cl_table obj params inh_init obj_init cl\n\nlet rec build_object_init_0\n ~scopes cl_table params cl copy_env subst_env top ids =\n match cl.cl_desc with\n Tcl_let (_rec_flag, _defs, vals, cl) ->\n build_object_init_0\n ~scopes cl_table (vals@params) cl copy_env subst_env top ids\n | _ ->\n let self = Ident.create_local \"self\" in\n let env = Ident.create_local \"env\" in\n let obj = if ids = [] then lambda_unit else Lvar self in\n let envs = if top then None else Some env in\n let ((_,inh_init), obj_init) =\n build_object_init ~scopes cl_table obj params (envs,[]) copy_env cl in\n let obj_init =\n if ids = [] then obj_init else lfunction [self, Pgenval] obj_init in\n (inh_init, lfunction [env, Pgenval] (subst_env env inh_init obj_init))\n\n\nlet bind_method tbl lab id cl_init =\n Llet(Strict, Pgenval, id, mkappl (oo_prim \"get_method_label\",\n [Lvar tbl; transl_label lab]),\n cl_init)\n\nlet bind_methods tbl meths vals cl_init =\n let methl = Meths.fold (fun lab id tl -> (lab,id) :: tl) meths [] in\n let len = List.length methl and nvals = List.length vals in\n if len < 2 && nvals = 0 then Meths.fold (bind_method tbl) meths cl_init else\n if len = 0 && nvals < 2 then transl_vals tbl true Strict vals cl_init else\n let ids = Ident.create_local \"ids\" in\n let i = ref (len + nvals) in\n let getter, names =\n if nvals = 0 then \"get_method_labels\", [] else\n \"new_methods_variables\", [transl_meth_list (List.map fst vals)]\n in\n Llet(Strict, Pgenval, ids,\n mkappl (oo_prim getter,\n [Lvar tbl; transl_meth_list (List.map fst methl)] @ names),\n List.fold_right\n (fun (_lab,id) lam -> decr i; Llet(StrictOpt, Pgenval, id,\n lfield ids !i, lam))\n (methl @ vals) cl_init)\n\nlet output_methods tbl methods lam =\n match methods with\n [] -> lam\n | [lab; code] ->\n lsequence (mkappl(oo_prim \"set_method\", [Lvar tbl; lab; code])) lam\n | _ ->\n lsequence (mkappl(oo_prim \"set_methods\",\n [Lvar tbl; Lprim(Pmakeblock(0,Immutable,None),\n methods, Loc_unknown)]))\n lam\n\nlet rec ignore_cstrs cl =\n match cl.cl_desc with\n Tcl_constraint (cl, _, _, _, _) -> ignore_cstrs cl\n | Tcl_apply (cl, _) -> ignore_cstrs cl\n | _ -> cl\n\nlet rec index a = function\n [] -> raise Not_found\n | b :: l ->\n if b = a then 0 else 1 + index a l\n\nlet bind_id_as_val (id, _) = (\"\", id)\n\nlet rec build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl =\n match cl.cl_desc with\n | Tcl_ident _ ->\n begin match inh_init with\n | (_, path_lam, obj_init)::inh_init ->\n (inh_init,\n Llet (Strict, Pgenval, obj_init,\n mkappl(Lprim(Pfield 1, [path_lam], Loc_unknown), Lvar cla ::\n if top then [Lprim(Pfield 3, [path_lam], Loc_unknown)]\n else []),\n bind_super cla super cl_init))\n | _ ->\n assert false\n end\n | Tcl_structure str ->\n let cl_init = bind_super cla super cl_init in\n let (inh_init, cl_init, methods, values) =\n List.fold_right\n (fun field (inh_init, cl_init, methods, values) ->\n match field.cf_desc with\n Tcf_inherit (_, cl, _, vals, meths) ->\n let cl_init = output_methods cla methods cl_init in\n let inh_init, cl_init =\n build_class_init ~scopes cla false\n (vals, meths_super cla str.cstr_meths meths)\n inh_init cl_init msubst top cl in\n (inh_init, cl_init, [], values)\n | Tcf_val (name, _, id, _, over) ->\n let values =\n if over then values else (name.txt, id) :: values\n in\n (inh_init, cl_init, methods, values)\n | Tcf_method (_, _, Tcfk_virtual _)\n | Tcf_constraint _\n ->\n (inh_init, cl_init, methods, values)\n | Tcf_method (name, _, Tcfk_concrete (_, exp)) ->\n let scopes = enter_method_definition ~scopes name.txt in\n let met_code =\n msubst true (transl_scoped_exp ~scopes exp) in\n let met_code =\n if !Clflags.native_code && List.length met_code = 1 then\n (* Force correct naming of method for profiles *)\n let met = Ident.create_local (\"method_\" ^ name.txt) in\n [Llet(Strict, Pgenval, met, List.hd met_code, Lvar met)]\n else met_code\n in\n (inh_init, cl_init,\n Lvar(Meths.find name.txt str.cstr_meths) :: met_code @ methods,\n values)\n | Tcf_initializer exp ->\n (inh_init,\n Lsequence(mkappl (oo_prim \"add_initializer\",\n Lvar cla :: msubst false\n (transl_exp ~scopes exp)),\n cl_init),\n methods, values)\n | Tcf_attribute _ ->\n (inh_init, cl_init, methods, values))\n str.cstr_fields\n (inh_init, cl_init, [], [])\n in\n let cl_init = output_methods cla methods cl_init in\n (inh_init, bind_methods cla str.cstr_meths values cl_init)\n | Tcl_fun (_, _pat, vals, cl, _) ->\n let (inh_init, cl_init) =\n build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl\n in\n let vals = List.map bind_id_as_val vals in\n (inh_init, transl_vals cla true StrictOpt vals cl_init)\n | Tcl_apply (cl, _exprs) ->\n build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl\n | Tcl_let (_rec_flag, _defs, vals, cl) ->\n let (inh_init, cl_init) =\n build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl\n in\n let vals = List.map bind_id_as_val vals in\n (inh_init, transl_vals cla true StrictOpt vals cl_init)\n | Tcl_constraint (cl, _, vals, meths, concr_meths) ->\n let virt_meths =\n List.filter (fun lab -> not (MethSet.mem lab concr_meths)) meths in\n let concr_meths = MethSet.elements concr_meths in\n let narrow_args =\n [Lvar cla;\n transl_meth_list vals;\n transl_meth_list virt_meths;\n transl_meth_list concr_meths] in\n let cl = ignore_cstrs cl in\n begin match cl.cl_desc, inh_init with\n | Tcl_ident (path, _, _), (path', path_lam, obj_init)::inh_init ->\n assert (Path.same path path');\n let inh = Ident.create_local \"inh\"\n and ofs = List.length vals + 1\n and valids, methids = super in\n let cl_init =\n List.fold_left\n (fun init (nm, id, _) ->\n Llet(StrictOpt, Pgenval, id,\n lfield inh (index nm concr_meths + ofs),\n init))\n cl_init methids in\n let cl_init =\n List.fold_left\n (fun init (nm, id) ->\n Llet(StrictOpt, Pgenval, id,\n lfield inh (index nm vals + 1), init))\n cl_init valids in\n (inh_init,\n Llet (Strict, Pgenval, inh,\n mkappl(oo_prim \"inherits\", narrow_args @\n [path_lam;\n Lconst(const_int (if top then 1 else 0))]),\n Llet(StrictOpt, Pgenval, obj_init, lfield inh 0, cl_init)))\n | _ ->\n let core cl_init =\n build_class_init\n ~scopes cla true super inh_init cl_init msubst top cl\n in\n if cstr then core cl_init else\n let (inh_init, cl_init) =\n core (Lsequence (mkappl (oo_prim \"widen\", [Lvar cla]), cl_init))\n in\n (inh_init,\n Lsequence(mkappl (oo_prim \"narrow\", narrow_args),\n cl_init))\n end\n | Tcl_open (_, cl) ->\n build_class_init ~scopes cla cstr super inh_init cl_init msubst top cl\n\nlet rec build_class_lets ~scopes cl =\n match cl.cl_desc with\n Tcl_let (rec_flag, defs, _vals, cl') ->\n let env, wrap = build_class_lets ~scopes cl' in\n (env, fun x ->\n Translcore.transl_let ~scopes rec_flag defs (wrap x))\n | _ ->\n (cl.cl_env, fun x -> x)\n\nlet rec get_class_meths cl =\n match cl.cl_desc with\n Tcl_structure cl ->\n Meths.fold (fun _ -> Ident.Set.add) cl.cstr_meths Ident.Set.empty\n | Tcl_ident _ -> Ident.Set.empty\n | Tcl_fun (_, _, _, cl, _)\n | Tcl_let (_, _, _, cl)\n | Tcl_apply (cl, _)\n | Tcl_open (_, cl)\n | Tcl_constraint (cl, _, _, _, _) -> get_class_meths cl\n\n(*\n XXX Il devrait etre peu couteux d'ecrire des classes :\n | Writing classes should be cheap\n class c x y = d e f\n*)\nlet rec transl_class_rebind ~scopes obj_init cl vf =\n match cl.cl_desc with\n Tcl_ident (path, _, _) ->\n if vf = Concrete then begin\n try if (Env.find_class path cl.cl_env).cty_new = None then raise Exit\n with Not_found -> raise Exit\n end;\n let cl_loc = of_location ~scopes cl.cl_loc in\n let path_lam = transl_class_path cl_loc cl.cl_env path in\n (path, path_lam, obj_init)\n | Tcl_fun (_, pat, _, cl, partial) ->\n let path, path_lam, obj_init =\n transl_class_rebind ~scopes obj_init cl vf in\n let build params rem =\n let param = name_pattern \"param\" pat in\n Lambda.lfunction\n ~kind:Curried ~params:((param, Pgenval)::params)\n ~return:Pgenval\n ~attr:default_function_attribute\n ~loc:(of_location ~scopes pat.pat_loc)\n ~body:(Matching.for_function ~scopes pat.pat_loc\n None (Lvar param) [pat, rem] partial)\n in\n (path, path_lam,\n match obj_init with\n Lfunction {kind = Curried; params; body} -> build params body\n | rem -> build [] rem)\n | Tcl_apply (cl, oexprs) ->\n let path, path_lam, obj_init =\n transl_class_rebind ~scopes obj_init cl vf in\n (path, path_lam, transl_apply ~scopes obj_init oexprs Loc_unknown)\n | Tcl_let (rec_flag, defs, _vals, cl) ->\n let path, path_lam, obj_init =\n transl_class_rebind ~scopes obj_init cl vf in\n (path, path_lam, Translcore.transl_let ~scopes rec_flag defs obj_init)\n | Tcl_structure _ -> raise Exit\n | Tcl_constraint (cl', _, _, _, _) ->\n let path, path_lam, obj_init =\n transl_class_rebind ~scopes obj_init cl' vf in\n let rec check_constraint = function\n Cty_constr(path', _, _) when Path.same path path' -> ()\n | Cty_arrow (_, _, cty) -> check_constraint cty\n | _ -> raise Exit\n in\n check_constraint cl.cl_type;\n (path, path_lam, obj_init)\n | Tcl_open (_, cl) ->\n transl_class_rebind ~scopes obj_init cl vf\n\nlet rec transl_class_rebind_0 ~scopes (self:Ident.t) obj_init cl vf =\n match cl.cl_desc with\n Tcl_let (rec_flag, defs, _vals, cl) ->\n let path, path_lam, obj_init =\n transl_class_rebind_0 ~scopes self obj_init cl vf\n in\n (path, path_lam, Translcore.transl_let ~scopes rec_flag defs obj_init)\n | _ ->\n let path, path_lam, obj_init =\n transl_class_rebind ~scopes obj_init cl vf in\n (path, path_lam, lfunction [self, Pgenval] obj_init)\n\nlet transl_class_rebind ~scopes cl vf =\n try\n let obj_init = Ident.create_local \"obj_init\"\n and self = Ident.create_local \"self\" in\n let obj_init0 =\n lapply {\n ap_loc=Loc_unknown;\n ap_func=Lvar obj_init;\n ap_args=[Lvar self];\n ap_tailcall=Default_tailcall;\n ap_inlined=Default_inline;\n ap_specialised=Default_specialise;\n }\n in\n let _, path_lam, obj_init' =\n transl_class_rebind_0 ~scopes self obj_init0 cl vf in\n let id = (obj_init' = lfunction [self, Pgenval] obj_init0) in\n if id then path_lam else\n\n let cla = Ident.create_local \"class\"\n and new_init = Ident.create_local \"new_init\"\n and env_init = Ident.create_local \"env_init\"\n and table = Ident.create_local \"table\"\n and envs = Ident.create_local \"envs\" in\n Llet(\n Strict, Pgenval, new_init, lfunction [obj_init, Pgenval] obj_init',\n Llet(\n Alias, Pgenval, cla, path_lam,\n Lprim(Pmakeblock(0, Immutable, None),\n [mkappl(Lvar new_init, [lfield cla 0]);\n lfunction [table, Pgenval]\n (Llet(Strict, Pgenval, env_init,\n mkappl(lfield cla 1, [Lvar table]),\n lfunction [envs, Pgenval]\n (mkappl(Lvar new_init,\n [mkappl(Lvar env_init, [Lvar envs])]))));\n lfield cla 2;\n lfield cla 3],\n Loc_unknown)))\n with Exit ->\n lambda_unit\n\n(* Rewrite a closure using builtins. Improves native code size. *)\n\nlet const_path local = function\n Lvar id -> not (List.mem id local)\n | Lconst _ -> true\n | Lfunction {kind = Curried; body} ->\n let fv = free_variables body in\n List.for_all (fun x -> not (Ident.Set.mem x fv)) local\n | _ -> false\n\nlet rec builtin_meths self env env2 body =\n let const_path = const_path (env::self) in\n let conv = function\n (* Lvar s when List.mem s self -> \"_self\", [] *)\n | p when const_path p -> \"const\", [p]\n | Lprim(Parrayrefu _, [Lvar s; Lvar n], _) when List.mem s self ->\n \"var\", [Lvar n]\n | Lprim(Pfield n, [Lvar e], _) when Ident.same e env ->\n \"env\", [Lvar env2; Lconst(const_int n)]\n | Lsend(Self, met, Lvar s, [], _) when List.mem s self ->\n \"meth\", [met]\n | _ -> raise Not_found\n in\n match body with\n | Llet(_str, _k, s', Lvar s, body) when List.mem s self ->\n builtin_meths (s'::self) env env2 body\n | Lapply{ap_func = f; ap_args = [arg]} when const_path f ->\n let s, args = conv arg in (\"app_\"^s, f :: args)\n | Lapply{ap_func = f; ap_args = [arg; p]} when const_path f && const_path p ->\n let s, args = conv arg in\n (\"app_\"^s^\"_const\", f :: args @ [p])\n | Lapply{ap_func = f; ap_args = [p; arg]} when const_path f && const_path p ->\n let s, args = conv arg in\n (\"app_const_\"^s, f :: p :: args)\n | Lsend(Self, Lvar n, Lvar s, [arg], _) when List.mem s self ->\n let s, args = conv arg in\n (\"meth_app_\"^s, Lvar n :: args)\n | Lsend(Self, met, Lvar s, [], _) when List.mem s self ->\n (\"get_meth\", [met])\n | Lsend(Public, met, arg, [], _) ->\n let s, args = conv arg in\n (\"send_\"^s, met :: args)\n | Lsend(Cached, met, arg, [_;_], _) ->\n let s, args = conv arg in\n (\"send_\"^s, met :: args)\n | Lfunction {kind = Curried; params = [x, _]; body} ->\n let rec enter self = function\n | Lprim(Parraysetu _, [Lvar s; Lvar n; Lvar x'], _)\n when Ident.same x x' && List.mem s self ->\n (\"set_var\", [Lvar n])\n | Llet(_str, _k, s', Lvar s, body) when List.mem s self ->\n enter (s'::self) body\n | _ -> raise Not_found\n in enter self body\n | Lfunction _ -> raise Not_found\n | _ ->\n let s, args = conv body in (\"get_\"^s, args)\n\nmodule M = struct\n open CamlinternalOO\n let builtin_meths self env env2 body =\n let builtin, args = builtin_meths self env env2 body in\n (* if not arr then [mkappl(oo_prim builtin, args)] else *)\n let tag = match builtin with\n \"get_const\" -> GetConst\n | \"get_var\" -> GetVar\n | \"get_env\" -> GetEnv\n | \"get_meth\" -> GetMeth\n | \"set_var\" -> SetVar\n | \"app_const\" -> AppConst\n | \"app_var\" -> AppVar\n | \"app_env\" -> AppEnv\n | \"app_meth\" -> AppMeth\n | \"app_const_const\" -> AppConstConst\n | \"app_const_var\" -> AppConstVar\n | \"app_const_env\" -> AppConstEnv\n | \"app_const_meth\" -> AppConstMeth\n | \"app_var_const\" -> AppVarConst\n | \"app_env_const\" -> AppEnvConst\n | \"app_meth_const\" -> AppMethConst\n | \"meth_app_const\" -> MethAppConst\n | \"meth_app_var\" -> MethAppVar\n | \"meth_app_env\" -> MethAppEnv\n | \"meth_app_meth\" -> MethAppMeth\n | \"send_const\" -> SendConst\n | \"send_var\" -> SendVar\n | \"send_env\" -> SendEnv\n | \"send_meth\" -> SendMeth\n | _ -> assert false\n in Lconst(const_int (Obj.magic tag)) :: args\nend\nopen M\n\n\n(*\n Class translation.\n Three subcases:\n * reapplication of a known class -> transl_class_rebind\n * class without local dependencies -> direct translation\n * with local dependencies -> generate a stubs tree,\n with a node for every local classes inherited\n A class is a 4-tuple:\n (obj_init, class_init, env_init, env)\n obj_init: creation function (unit -> obj)\n class_init: inheritance function (table -> env_init)\n (one by source code)\n env_init: parameterisation by the local environment\n (env -> params -> obj_init)\n (one for each combination of inherited class_init )\n env: local environment\n If ids=0 (immediate object), then only env_init is conserved.\n*)\n\n(*\nlet prerr_ids msg ids =\n let names = List.map Ident.unique_toplevel_name ids in\n prerr_endline (String.concat \" \" (msg :: names))\n*)\n\nlet free_methods l =\n let fv = ref Ident.Set.empty in\n let rec free l =\n Lambda.iter_head_constructor free l;\n match l with\n | Lsend(Self, Lvar meth, _, _, _) ->\n fv := Ident.Set.add meth !fv\n | Lsend _ -> ()\n | Lfunction{params} ->\n List.iter (fun (param, _) -> fv := Ident.Set.remove param !fv) params\n | Llet(_, _k, id, _arg, _body)\n | Lmutlet(_k, id, _arg, _body) ->\n fv := Ident.Set.remove id !fv\n | Lletrec(decl, _body) ->\n List.iter (fun (id, _exp) -> fv := Ident.Set.remove id !fv) decl\n | Lstaticcatch(_e1, (_,vars), _e2) ->\n List.iter (fun (id, _) -> fv := Ident.Set.remove id !fv) vars\n | Ltrywith(_e1, exn, _e2) ->\n fv := Ident.Set.remove exn !fv\n | Lfor(v, _e1, _e2, _dir, _e3) ->\n fv := Ident.Set.remove v !fv\n | Lassign _\n | Lvar _ | Lmutvar _ | Lconst _ | Lapply _\n | Lprim _ | Lswitch _ | Lstringswitch _ | Lstaticraise _\n | Lifthenelse _ | Lsequence _ | Lwhile _\n | Levent _ | Lifused _ -> ()\n in free l; !fv\n\nlet transl_class ~scopes ids cl_id pub_meths cl vflag =\n (* First check if it is not only a rebind *)\n let rebind = transl_class_rebind ~scopes cl vflag in\n if rebind <> lambda_unit then rebind else\n\n (* Prepare for heavy environment handling *)\n let scopes = enter_class_definition ~scopes cl_id in\n let tables = Ident.create_local (Ident.name cl_id ^ \"_tables\") in\n let (top_env, req) = oo_add_class tables in\n let top = not req in\n let cl_env, llets = build_class_lets ~scopes cl in\n let new_ids = if top then [] else Env.diff top_env cl_env in\n let env2 = Ident.create_local \"env\" in\n let meth_ids = get_class_meths cl in\n let subst env lam i0 new_ids' =\n let fv = free_variables lam in\n (* prerr_ids \"cl_id =\" [cl_id]; prerr_ids \"fv =\" (Ident.Set.elements fv); *)\n let fv = List.fold_right Ident.Set.remove !new_ids' fv in\n (* We need to handle method ids specially, as they do not appear\n in the typing environment (PR#3576, PR#4560) *)\n (* very hacky: we add and remove free method ids on the fly,\n depending on the visit order... *)\n method_ids :=\n Ident.Set.diff (Ident.Set.union (free_methods lam) !method_ids) meth_ids;\n (* prerr_ids \"meth_ids =\" (Ident.Set.elements meth_ids);\n prerr_ids \"method_ids =\" (Ident.Set.elements !method_ids); *)\n let new_ids = List.fold_right Ident.Set.add new_ids !method_ids in\n let fv = Ident.Set.inter fv new_ids in\n new_ids' := !new_ids' @ Ident.Set.elements fv;\n (* prerr_ids \"new_ids' =\" !new_ids'; *)\n let i = ref (i0-1) in\n List.fold_left\n (fun subst id ->\n incr i; Ident.Map.add id (lfield env !i) subst)\n Ident.Map.empty !new_ids'\n in\n let new_ids_meths = ref [] in\n let no_env_update _ _ env = env in\n let msubst arr = function\n Lfunction {kind = Curried; params = (self, Pgenval) :: args; body} ->\n let env = Ident.create_local \"env\" in\n let body' =\n if new_ids = [] then body else\n Lambda.subst no_env_update (subst env body 0 new_ids_meths) body in\n begin try\n (* Doesn't seem to improve size for bytecode *)\n (* if not !Clflags.native_code then raise Not_found; *)\n if not arr || !Clflags.debug then raise Not_found;\n builtin_meths [self] env env2 (lfunction args body')\n with Not_found ->\n [lfunction ((self, Pgenval) :: args)\n (if not (Ident.Set.mem env (free_variables body')) then body' else\n Llet(Alias, Pgenval, env,\n Lprim(Pfield_computed,\n [Lvar self; Lvar env2],\n Loc_unknown),\n body'))]\n end\n | _ -> assert false\n in\n let new_ids_init = ref [] in\n let env1 = Ident.create_local \"env\" and env1' = Ident.create_local \"env'\" in\n let copy_env self =\n if top then lambda_unit else\n Lifused(env2, Lprim(Psetfield_computed (Pointer, Assignment),\n [Lvar self; Lvar env2; Lvar env1'],\n Loc_unknown))\n and subst_env envs l lam =\n if top then lam else\n (* must be called only once! *)\n let lam = Lambda.subst no_env_update (subst env1 lam 1 new_ids_init) lam in\n Llet(Alias, Pgenval, env1, (if l = [] then Lvar envs else lfield envs 0),\n Llet(Alias, Pgenval, env1',\n (if !new_ids_init = [] then Lvar env1 else lfield env1 0),\n lam))\n in\n\n (* Now we start compiling the class *)\n let cla = Ident.create_local \"class\" in\n let (inh_init, obj_init) =\n build_object_init_0 ~scopes cla [] cl copy_env subst_env top ids in\n let inh_init' = List.rev inh_init in\n let (inh_init', cl_init) =\n build_class_init ~scopes cla true ([],[]) inh_init' obj_init msubst top cl\n in\n assert (inh_init' = []);\n let table = Ident.create_local \"table\"\n and class_init = Ident.create_local (Ident.name cl_id ^ \"_init\")\n and env_init = Ident.create_local \"env_init\"\n and obj_init = Ident.create_local \"obj_init\" in\n let pub_meths =\n List.sort\n (fun s s' -> compare (Btype.hash_variant s) (Btype.hash_variant s'))\n pub_meths in\n let tags = List.map Btype.hash_variant pub_meths in\n let rev_map = List.combine tags pub_meths in\n List.iter2\n (fun tag name ->\n let name' = List.assoc tag rev_map in\n if name' <> name then raise(Error(cl.cl_loc, Tags(name, name'))))\n tags pub_meths;\n let ltable table lam =\n Llet(Strict, Pgenval, table,\n mkappl (oo_prim \"create_table\", [transl_meth_list pub_meths]), lam)\n and ldirect obj_init =\n Llet(Strict, Pgenval, obj_init, cl_init,\n Lsequence(mkappl (oo_prim \"init_class\", [Lvar cla]),\n mkappl (Lvar obj_init, [lambda_unit])))\n in\n (* Simplest case: an object defined at toplevel (ids=[]) *)\n if top && ids = [] then llets (ltable cla (ldirect obj_init)) else\n\n let concrete = (vflag = Concrete)\n and lclass lam =\n let cl_init = llets (Lambda.lfunction\n ~kind:Curried\n ~attr:default_function_attribute\n ~loc:Loc_unknown\n ~return:Pgenval\n ~params:[cla, Pgenval] ~body:cl_init) in\n Llet(Strict, Pgenval, class_init, cl_init, lam (free_variables cl_init))\n and lbody fv =\n if List.for_all (fun id -> not (Ident.Set.mem id fv)) ids then\n mkappl (oo_prim \"make_class\",[transl_meth_list pub_meths;\n Lvar class_init])\n else\n ltable table (\n Llet(\n Strict, Pgenval, env_init, mkappl (Lvar class_init, [Lvar table]),\n Lsequence(\n mkappl (oo_prim \"init_class\", [Lvar table]),\n Lprim(Pmakeblock(0, Immutable, None),\n [mkappl (Lvar env_init, [lambda_unit]);\n Lvar class_init; Lvar env_init; lambda_unit],\n Loc_unknown))))\n and lbody_virt lenvs =\n Lprim(Pmakeblock(0, Immutable, None),\n [lambda_unit; Lambda.lfunction\n ~kind:Curried\n ~attr:default_function_attribute\n ~loc:Loc_unknown\n ~return:Pgenval\n ~params:[cla, Pgenval] ~body:cl_init;\n lambda_unit; lenvs],\n Loc_unknown)\n in\n (* Still easy: a class defined at toplevel *)\n if top && concrete then lclass lbody else\n if top then llets (lbody_virt lambda_unit) else\n\n (* Now for the hard stuff: prepare for table caching *)\n let envs = Ident.create_local \"envs\"\n and cached = Ident.create_local \"cached\" in\n let lenvs =\n if !new_ids_meths = [] && !new_ids_init = [] && inh_init = []\n then lambda_unit\n else Lvar envs in\n let lenv =\n let menv =\n if !new_ids_meths = [] then lambda_unit else\n Lprim(Pmakeblock(0, Immutable, None),\n List.map (fun id -> Lvar id) !new_ids_meths,\n Loc_unknown) in\n if !new_ids_init = [] then menv else\n Lprim(Pmakeblock(0, Immutable, None),\n menv :: List.map (fun id -> Lvar id) !new_ids_init,\n Loc_unknown)\n and linh_envs =\n List.map\n (fun (_, path_lam, _) -> Lprim(Pfield 3, [path_lam], Loc_unknown))\n (List.rev inh_init)\n in\n let make_envs lam =\n Llet(StrictOpt, Pgenval, envs,\n (if linh_envs = [] then lenv else\n Lprim(Pmakeblock(0, Immutable, None),\n lenv :: linh_envs, Loc_unknown)),\n lam)\n and def_ids cla lam =\n Llet(StrictOpt, Pgenval, env2,\n mkappl (oo_prim \"new_variable\", [Lvar cla; transl_label \"\"]),\n lam)\n in\n let inh_paths =\n List.filter\n (fun (path, _, _) -> List.mem (Path.head path) new_ids) inh_init\n in\n let inh_keys =\n List.map\n (fun (_, path_lam, _) -> Lprim(Pfield 1, [path_lam], Loc_unknown))\n inh_paths\n in\n let lclass lam =\n Llet(Strict, Pgenval, class_init,\n Lambda.lfunction\n ~kind:Curried ~params:[cla, Pgenval]\n ~return:Pgenval\n ~attr:default_function_attribute\n ~loc:Loc_unknown\n ~body:(def_ids cla cl_init), lam)\n and lcache lam =\n if inh_keys = [] then Llet(Alias, Pgenval, cached, Lvar tables, lam) else\n Llet(Strict, Pgenval, cached,\n mkappl (oo_prim \"lookup_tables\",\n [Lvar tables; Lprim(Pmakeblock(0, Immutable, None),\n inh_keys, Loc_unknown)]),\n lam)\n and lset cached i lam =\n Lprim(Psetfield(i, Pointer, Assignment),\n [Lvar cached; lam], Loc_unknown)\n in\n let ldirect () =\n ltable cla\n (Llet(Strict, Pgenval, env_init, def_ids cla cl_init,\n Lsequence(mkappl (oo_prim \"init_class\", [Lvar cla]),\n lset cached 0 (Lvar env_init))))\n and lclass_virt () =\n lset cached 0\n (Lambda.lfunction\n ~kind:Curried\n ~attr:default_function_attribute\n ~loc:Loc_unknown\n ~return:Pgenval\n ~params:[cla, Pgenval]\n ~body:(def_ids cla cl_init))\n in\n let lupdate_cache =\n if ids = [] then ldirect () else\n if not concrete then lclass_virt () else\n lclass (\n mkappl (oo_prim \"make_class_store\",\n [transl_meth_list pub_meths;\n Lvar class_init; Lvar cached])) in\n let lcheck_cache =\n if !Clflags.native_code && !Clflags.afl_instrument then\n (* When afl-fuzz instrumentation is enabled, ignore the cache\n so that the program's behaviour does not change between runs *)\n lupdate_cache\n else\n Lifthenelse(lfield cached 0, lambda_unit, lupdate_cache) in\n llets (\n lcache (\n Lsequence(lcheck_cache,\n make_envs (\n if ids = [] then mkappl (lfield cached 0, [lenvs]) else\n Lprim(Pmakeblock(0, Immutable, None),\n (if concrete then\n [mkappl (lfield cached 0, [lenvs]);\n lfield cached 1;\n lfield cached 0;\n lenvs]\n else [lambda_unit; lfield cached 0; lambda_unit; lenvs]),\n Loc_unknown\n )))))\n\n(* Wrapper for class compilation *)\n(*\n let cl_id = ci.ci_id_class in\n(* TODO: cl_id is used somewhere else as typesharp ? *)\n let _arity = List.length ci.ci_params in\n let pub_meths = m in\n let cl = ci.ci_expr in\n let vflag = vf in\n*)\n\nlet transl_class ~scopes ids id pub_meths cl vf =\n oo_wrap cl.cl_env false (transl_class ~scopes ids id pub_meths cl) vf\n\nlet () =\n transl_object := (fun ~scopes id meths cl ->\n transl_class ~scopes [] id meths cl Concrete)\n\n(* Error report *)\n\nopen Format\n\nlet report_error ppf = function\n | Tags (lab1, lab2) ->\n fprintf ppf \"Method labels `%s' and `%s' are incompatible.@ %s\"\n lab1 lab2 \"Change one of them.\"\n\nlet () =\n Location.register_error_of_exn\n (function\n | Error (loc, err) ->\n Some (Location.error_of_printer ~loc report_error err)\n | _ ->\n None\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(* Translation from typed abstract syntax to lambda terms,\n for the module language *)\n\nopen Misc\nopen Asttypes\nopen Path\nopen Types\nopen Typedtree\nopen Lambda\nopen Translobj\nopen Translcore\nopen Translclass\nopen Debuginfo.Scoped_location\n\ntype unsafe_component =\n | Unsafe_module_binding\n | Unsafe_functor\n | Unsafe_non_function\n | Unsafe_typext\n\ntype unsafe_info =\n | Unsafe of { reason:unsafe_component; loc:Location.t; subid:Ident.t }\n | Unnamed\ntype error =\n Circular_dependency of (Ident.t * unsafe_info) list\n| Conflicting_inline_attributes\n\nexception Error of Location.t * error\n\nlet cons_opt x_opt xs =\n match x_opt with\n | None -> xs\n | Some x -> x :: xs\n\n(* Keep track of the root path (from the root of the namespace to the\n currently compiled module expression). Useful for naming extensions. *)\n\nlet global_path glob = Some(Pident glob)\nlet functor_path path param =\n match path with\n None -> None\n | Some p -> Some(Papply(p, Pident param))\nlet field_path path field =\n match path with\n None -> None\n | Some p -> Some(Pdot(p, Ident.name field))\n\n(* Compile type extensions *)\n\nlet transl_type_extension ~scopes env rootpath tyext body =\n List.fold_right\n (fun ext body ->\n let lam =\n transl_extension_constructor ~scopes env\n (field_path rootpath ext.ext_id) ext\n in\n Llet(Strict, Pgenval, ext.ext_id, lam, body))\n tyext.tyext_constructors\n body\n\n(* Compile a coercion *)\n\nlet rec apply_coercion loc strict restr arg =\n match restr with\n Tcoerce_none ->\n arg\n | Tcoerce_structure(pos_cc_list, id_pos_list) ->\n name_lambda strict arg (fun id ->\n let get_field pos =\n if pos < 0 then lambda_unit\n else Lprim(Pfield pos,[Lvar id], loc)\n in\n let lam =\n Lprim(Pmakeblock(0, Immutable, None),\n List.map (apply_coercion_field loc get_field) pos_cc_list,\n loc)\n in\n wrap_id_pos_list loc id_pos_list get_field lam)\n | Tcoerce_functor(cc_arg, cc_res) ->\n let param = Ident.create_local \"funarg\" in\n let carg = apply_coercion loc Alias cc_arg (Lvar param) in\n apply_coercion_result loc strict arg [param, Pgenval] [carg] cc_res\n | Tcoerce_primitive { pc_loc = _; pc_desc; pc_env; pc_type; } ->\n Translprim.transl_primitive loc pc_desc pc_env pc_type None\n | Tcoerce_alias (env, path, cc) ->\n let lam = transl_module_path loc env path in\n name_lambda strict arg\n (fun _ -> apply_coercion loc Alias cc lam)\n\nand apply_coercion_field loc get_field (pos, cc) =\n apply_coercion loc Alias cc (get_field pos)\n\nand apply_coercion_result loc strict funct params args cc_res =\n match cc_res with\n | Tcoerce_functor(cc_arg, cc_res) ->\n let param = Ident.create_local \"funarg\" in\n let arg = apply_coercion loc Alias cc_arg (Lvar param) in\n apply_coercion_result loc strict funct\n ((param, Pgenval) :: params) (arg :: args) cc_res\n | _ ->\n name_lambda strict funct\n (fun id ->\n lfunction\n ~kind:Curried\n ~params:(List.rev params)\n ~return:Pgenval\n ~attr:{ default_function_attribute with\n is_a_functor = true;\n stub = true; }\n ~loc\n ~body:(apply_coercion\n loc Strict cc_res\n (Lapply{\n ap_loc=loc;\n ap_func=Lvar id;\n ap_args=List.rev args;\n ap_tailcall=Default_tailcall;\n ap_inlined=Default_inline;\n ap_specialised=Default_specialise;\n })))\n\nand wrap_id_pos_list loc id_pos_list get_field lam =\n let fv = free_variables lam in\n (*Format.eprintf \"%a@.\" Printlambda.lambda lam;\n Ident.Set.iter (fun id -> Format.eprintf \"%a \" Ident.print id) fv;\n Format.eprintf \"@.\";*)\n let (lam,s) =\n List.fold_left (fun (lam, s) (id',pos,c) ->\n if Ident.Set.mem id' fv then\n let id'' = Ident.create_local (Ident.name id') in\n (Llet(Alias, Pgenval, id'',\n apply_coercion loc Alias c (get_field pos),lam),\n Ident.Map.add id' id'' s)\n else (lam, s))\n (lam, Ident.Map.empty) id_pos_list\n in\n if s == Ident.Map.empty then lam else Lambda.rename s lam\n\n\n(* Compose two coercions\n apply_coercion c1 (apply_coercion c2 e) behaves like\n apply_coercion (compose_coercions c1 c2) e. *)\n\nlet rec compose_coercions c1 c2 =\n match (c1, c2) with\n (Tcoerce_none, c2) -> c2\n | (c1, Tcoerce_none) -> c1\n | (Tcoerce_structure (pc1, ids1), Tcoerce_structure (pc2, ids2)) ->\n let v2 = Array.of_list pc2 in\n let ids1 =\n List.map (fun (id,pos1,c1) ->\n let (pos2,c2) = v2.(pos1) in (id, pos2, compose_coercions c1 c2))\n ids1\n in\n Tcoerce_structure\n (List.map\n (fun pc ->\n match pc with\n | _, (Tcoerce_primitive _ | Tcoerce_alias _) ->\n (* These cases do not take an argument (the position is -1),\n so they do not need adjusting. *)\n pc\n | (p1, c1) ->\n let (p2, c2) = v2.(p1) in\n (p2, compose_coercions c1 c2))\n pc1,\n ids1 @ ids2)\n | (Tcoerce_functor(arg1, res1), Tcoerce_functor(arg2, res2)) ->\n Tcoerce_functor(compose_coercions arg2 arg1,\n compose_coercions res1 res2)\n | (c1, Tcoerce_alias (env, path, c2)) ->\n Tcoerce_alias (env, path, compose_coercions c1 c2)\n | (_, _) ->\n fatal_error \"Translmod.compose_coercions\"\n\n(*\nlet apply_coercion a b c =\n Format.eprintf \"@[<2>apply_coercion@ %a@]@.\" Includemod.print_coercion b;\n apply_coercion a b c\n\nlet compose_coercions c1 c2 =\n let c3 = compose_coercions c1 c2 in\n let open Includemod in\n Format.eprintf \"@[<2>compose_coercions@ (%a)@ (%a) =@ %a@]@.\"\n print_coercion c1 print_coercion c2 print_coercion c3;\n c3\n*)\n\n(* Record the primitive declarations occurring in the module compiled *)\n\nlet primitive_declarations = ref ([] : Primitive.description list)\nlet record_primitive = function\n | {val_kind=Val_prim p;val_loc} ->\n Translprim.check_primitive_arity val_loc p;\n primitive_declarations := p :: !primitive_declarations\n | _ -> ()\n\n(* Utilities for compiling \"module rec\" definitions *)\n\nlet mod_prim = Lambda.transl_prim \"CamlinternalMod\"\n\nlet undefined_location loc =\n let (fname, line, char) = Location.get_pos_info loc.Location.loc_start in\n Lconst(Const_block(0,\n [Const_base(Const_string (fname, loc, None));\n const_int line;\n const_int char]))\n\nexception Initialization_failure of unsafe_info\n\nlet init_shape id modl =\n let rec init_shape_mod subid loc env mty =\n match Mtype.scrape env mty with\n Mty_ident _\n | Mty_alias _ ->\n raise (Initialization_failure\n (Unsafe {reason=Unsafe_module_binding;loc;subid}))\n | Mty_signature sg ->\n Const_block(0, [Const_block(0, init_shape_struct env sg)])\n | Mty_functor _ ->\n (* can we do better? *)\n raise (Initialization_failure\n (Unsafe {reason=Unsafe_functor;loc;subid}))\n and init_shape_struct env sg =\n match sg with\n [] -> []\n | Sig_value(subid, {val_kind=Val_reg; val_type=ty; val_loc=loc},_) :: rem ->\n let init_v =\n match get_desc (Ctype.expand_head env ty) with\n Tarrow(_,_,_,_) ->\n const_int 0 (* camlinternalMod.Function *)\n | Tconstr(p, _, _) when Path.same p Predef.path_lazy_t ->\n const_int 1 (* camlinternalMod.Lazy *)\n | _ ->\n let not_a_function =\n Unsafe {reason=Unsafe_non_function; loc; subid }\n in\n raise (Initialization_failure not_a_function) in\n init_v :: init_shape_struct env rem\n | Sig_value(_, {val_kind=Val_prim _}, _) :: rem ->\n init_shape_struct env rem\n | Sig_value _ :: _rem ->\n assert false\n | Sig_type(id, tdecl, _, _) :: rem ->\n init_shape_struct (Env.add_type ~check:false id tdecl env) rem\n | Sig_typext (subid, {ext_loc=loc},_,_) :: _ ->\n raise (Initialization_failure (Unsafe {reason=Unsafe_typext;loc;subid}))\n | Sig_module(id, Mp_present, md, _, _) :: rem ->\n init_shape_mod id md.md_loc env md.md_type ::\n init_shape_struct (Env.add_module_declaration ~check:false\n id Mp_present md env) rem\n | Sig_module(id, Mp_absent, md, _, _) :: rem ->\n init_shape_struct\n (Env.add_module_declaration ~check:false\n id Mp_absent md env) rem\n | Sig_modtype(id, minfo, _) :: rem ->\n init_shape_struct (Env.add_modtype id minfo env) rem\n | Sig_class _ :: rem ->\n const_int 2 (* camlinternalMod.Class *)\n :: init_shape_struct env rem\n | Sig_class_type _ :: rem ->\n init_shape_struct env rem\n in\n try\n Ok(undefined_location modl.mod_loc,\n Lconst(init_shape_mod id modl.mod_loc modl.mod_env modl.mod_type))\n with Initialization_failure reason -> Result.Error(reason)\n\n(* Reorder bindings to honor dependencies. *)\n\ntype binding_status =\n | Undefined\n | Inprogress of int option (** parent node *)\n | Defined\n\ntype id_or_ignore_loc =\n | Id of Ident.t\n | Ignore_loc of Lambda.scoped_location\n\nlet extract_unsafe_cycle id status init cycle_start =\n let info i = match init.(i) with\n | Result.Error r ->\n begin match id.(i) with\n | Id id -> id, r\n | Ignore_loc _ ->\n assert false (* Can't refer to something without a name. *)\n end\n | Ok _ -> assert false in\n let rec collect stop l i = match status.(i) with\n | Inprogress None | Undefined | Defined -> assert false\n | Inprogress Some i when i = stop -> info i :: l\n | Inprogress Some i -> collect stop (info i::l) i in\n collect cycle_start [] cycle_start\n\nlet reorder_rec_bindings bindings =\n let id = Array.of_list (List.map (fun (id,_,_,_) -> id) bindings)\n and loc = Array.of_list (List.map (fun (_,loc,_,_) -> loc) bindings)\n and init = Array.of_list (List.map (fun (_,_,init,_) -> init) bindings)\n and rhs = Array.of_list (List.map (fun (_,_,_,rhs) -> rhs) bindings) in\n let fv = Array.map Lambda.free_variables rhs in\n let num_bindings = Array.length id in\n let status = Array.make num_bindings Undefined in\n let res = ref [] in\n let is_unsafe i = match init.(i) with\n | Ok _ -> false\n | Result.Error _ -> true in\n let init_res i = match init.(i) with\n | Result.Error _ -> None\n | Ok(a,b) -> Some(a,b) in\n let rec emit_binding parent i =\n match status.(i) with\n Defined -> ()\n | Inprogress _ ->\n status.(i) <- Inprogress parent;\n let cycle = extract_unsafe_cycle id status init i in\n raise(Error(loc.(i), Circular_dependency cycle))\n | Undefined ->\n if is_unsafe i then begin\n status.(i) <- Inprogress parent;\n for j = 0 to num_bindings - 1 do\n match id.(j) with\n | Id id when Ident.Set.mem id fv.(i) -> emit_binding (Some i) j\n | _ -> ()\n done\n end;\n res := (id.(i), init_res i, rhs.(i)) :: !res;\n status.(i) <- Defined in\n for i = 0 to num_bindings - 1 do\n match status.(i) with\n Undefined -> emit_binding None i\n | Inprogress _ -> assert false\n | Defined -> ()\n done;\n List.rev !res\n\n(* Generate lambda-code for a reordered list of bindings *)\n\nlet eval_rec_bindings bindings cont =\n let rec bind_inits = function\n [] ->\n bind_strict bindings\n | (Ignore_loc _, _, _) :: rem\n | (_, None, _) :: rem ->\n bind_inits rem\n | (Id id, Some(loc, shape), _rhs) :: rem ->\n Llet(Strict, Pgenval, id,\n Lapply{\n ap_loc=Loc_unknown;\n ap_func=mod_prim \"init_mod\";\n ap_args=[loc; shape];\n ap_tailcall=Default_tailcall;\n ap_inlined=Default_inline;\n ap_specialised=Default_specialise;\n },\n bind_inits rem)\n and bind_strict = function\n [] ->\n patch_forwards bindings\n | (Ignore_loc loc, None, rhs) :: rem ->\n Lsequence(Lprim(Pignore, [rhs], loc), bind_strict rem)\n | (Id id, None, rhs) :: rem ->\n Llet(Strict, Pgenval, id, rhs, bind_strict rem)\n | (_id, Some _, _rhs) :: rem ->\n bind_strict rem\n and patch_forwards = function\n [] ->\n cont\n | (Ignore_loc _, _, _rhs) :: rem\n | (_, None, _rhs) :: rem ->\n patch_forwards rem\n | (Id id, Some(_loc, shape), rhs) :: rem ->\n Lsequence(\n Lapply {\n ap_loc=Loc_unknown;\n ap_func=mod_prim \"update_mod\";\n ap_args=[shape; Lvar id; rhs];\n ap_tailcall=Default_tailcall;\n ap_inlined=Default_inline;\n ap_specialised=Default_specialise;\n },\n patch_forwards rem)\n in\n bind_inits bindings\n\nlet compile_recmodule ~scopes compile_rhs bindings cont =\n eval_rec_bindings\n (reorder_rec_bindings\n (List.map\n (fun {mb_id=id; mb_name; mb_expr=modl; mb_loc=loc; _} ->\n let id_or_ignore_loc, shape =\n match id with\n | None ->\n let loc = of_location ~scopes mb_name.loc in\n Ignore_loc loc, Result.Error Unnamed\n | Some id -> Id id, init_shape id modl\n in\n (id_or_ignore_loc, modl.mod_loc, shape, compile_rhs id modl loc))\n bindings))\n cont\n\n(* Code to translate class entries in a structure *)\n\nlet transl_class_bindings ~scopes cl_list =\n let ids = List.map (fun (ci, _) -> ci.ci_id_class) cl_list in\n (ids,\n List.map\n (fun ({ci_id_class=id; ci_expr=cl; ci_virt=vf}, meths) ->\n (id, transl_class ~scopes ids id meths cl vf))\n cl_list)\n\n(* Compile one or more functors, merging curried functors to produce\n multi-argument functors. Any [@inline] attribute on a functor that is\n merged must be consistent with any other [@inline] attribute(s) on the\n functor(s) being merged with. Such an attribute will be placed on the\n resulting merged functor. *)\n\nlet merge_inline_attributes attr1 attr2 loc =\n match Lambda.merge_inline_attributes attr1 attr2 with\n | Some attr -> attr\n | None -> raise (Error (to_location loc, Conflicting_inline_attributes))\n\nlet merge_functors ~scopes mexp coercion root_path =\n let rec merge ~scopes mexp coercion path acc inline_attribute =\n let finished = acc, mexp, path, coercion, inline_attribute in\n match mexp.mod_desc with\n | Tmod_functor (param, body) ->\n let inline_attribute' =\n Translattribute.get_inline_attribute mexp.mod_attributes\n in\n let arg_coercion, res_coercion =\n match coercion with\n | Tcoerce_none -> Tcoerce_none, Tcoerce_none\n | Tcoerce_functor (arg_coercion, res_coercion) ->\n arg_coercion, res_coercion\n | _ -> fatal_error \"Translmod.merge_functors: bad coercion\"\n in\n let loc = of_location ~scopes mexp.mod_loc in\n let path, param =\n match param with\n | Unit -> None, Ident.create_local \"*\"\n | Named (None, _, _) ->\n let id = Ident.create_local \"_\" in\n functor_path path id, id\n | Named (Some id, _, _) -> functor_path path id, id\n in\n let inline_attribute =\n merge_inline_attributes inline_attribute inline_attribute' loc\n in\n merge ~scopes body res_coercion path ((param, loc, arg_coercion) :: acc)\n inline_attribute\n | _ -> finished\n in\n merge ~scopes mexp coercion root_path [] Default_inline\n\nlet rec compile_functor ~scopes mexp coercion root_path loc =\n let functor_params_rev, body, body_path, res_coercion, inline_attribute =\n merge_functors ~scopes mexp coercion root_path\n in\n assert (List.length functor_params_rev >= 1); (* cf. [transl_module] *)\n let params, body =\n List.fold_left (fun (params, body) (param, loc, arg_coercion) ->\n let param' = Ident.rename param in\n let arg = apply_coercion loc Alias arg_coercion (Lvar param') in\n let params = (param', Pgenval) :: params in\n let body = Llet (Alias, Pgenval, param, arg, body) in\n params, body)\n ([], transl_module ~scopes res_coercion body_path body)\n functor_params_rev\n in\n lfunction\n ~kind:Curried\n ~params\n ~return:Pgenval\n ~attr:{\n inline = inline_attribute;\n specialise = Default_specialise;\n local = Default_local;\n poll = Default_poll;\n is_a_functor = true;\n stub = false;\n tmc_candidate = false;\n }\n ~loc\n ~body\n\n(* Compile a module expression *)\n\nand transl_module ~scopes cc rootpath mexp =\n List.iter (Translattribute.check_attribute_on_module mexp)\n mexp.mod_attributes;\n let loc = of_location ~scopes mexp.mod_loc in\n match mexp.mod_desc with\n | Tmod_ident (path,_) ->\n apply_coercion loc Strict cc\n (transl_module_path loc mexp.mod_env path)\n | Tmod_structure str ->\n fst (transl_struct ~scopes loc [] cc rootpath str)\n | Tmod_functor _ ->\n oo_wrap mexp.mod_env true (fun () ->\n compile_functor ~scopes mexp cc rootpath loc) ()\n | Tmod_apply(funct, arg, ccarg) ->\n let inlined_attribute, funct =\n Translattribute.get_and_remove_inlined_attribute_on_module funct\n in\n oo_wrap mexp.mod_env true\n (apply_coercion loc Strict cc)\n (Lapply{\n ap_loc=loc;\n ap_func=transl_module ~scopes Tcoerce_none None funct;\n ap_args=[transl_module ~scopes ccarg None arg];\n ap_tailcall=Default_tailcall;\n ap_inlined=inlined_attribute;\n ap_specialised=Default_specialise})\n | Tmod_constraint(arg, _, _, ccarg) ->\n transl_module ~scopes (compose_coercions cc ccarg) rootpath arg\n | Tmod_unpack(arg, _) ->\n apply_coercion loc Strict cc (Translcore.transl_exp ~scopes arg)\n\nand transl_struct ~scopes loc fields cc rootpath {str_final_env; str_items; _} =\n transl_structure ~scopes loc fields cc rootpath str_final_env str_items\n\n(* The function transl_structure is called by the bytecode compiler.\n Some effort is made to compile in top to bottom order, in order to display\n warning by increasing locations. *)\nand transl_structure ~scopes loc fields cc rootpath final_env = function\n [] ->\n let body, size =\n match cc with\n Tcoerce_none ->\n Lprim(Pmakeblock(0, Immutable, None),\n List.map (fun id -> Lvar id) (List.rev fields), loc),\n List.length fields\n | Tcoerce_structure(pos_cc_list, id_pos_list) ->\n (* Do not ignore id_pos_list ! *)\n (*Format.eprintf \"%a@.@[\" Includemod.print_coercion cc;\n List.iter (fun l -> Format.eprintf \"%a@ \" Ident.print l)\n fields;\n Format.eprintf \"@]@.\";*)\n let v = Array.of_list (List.rev fields) in\n let get_field pos =\n if pos < 0 then lambda_unit\n else Lvar v.(pos)\n in\n let ids = List.fold_right Ident.Set.add fields Ident.Set.empty in\n let lam =\n Lprim(Pmakeblock(0, Immutable, None),\n List.map\n (fun (pos, cc) ->\n match cc with\n Tcoerce_primitive p ->\n Translprim.transl_primitive\n (of_location ~scopes p.pc_loc)\n p.pc_desc p.pc_env p.pc_type None\n | _ -> apply_coercion loc Strict cc (get_field pos))\n pos_cc_list, loc)\n and id_pos_list =\n List.filter (fun (id,_,_) -> not (Ident.Set.mem id ids))\n id_pos_list\n in\n wrap_id_pos_list loc id_pos_list get_field lam,\n List.length pos_cc_list\n | _ ->\n fatal_error \"Translmod.transl_structure\"\n in\n (* This debugging event provides information regarding the structure\n items. It is ignored by the OCaml debugger but is used by\n Js_of_ocaml to preserve variable names. *)\n (if !Clflags.debug && not !Clflags.native_code then\n Levent(body,\n {lev_loc = loc;\n lev_kind = Lev_pseudo;\n lev_repr = None;\n lev_env = final_env})\n else\n body),\n size\n | item :: rem ->\n match item.str_desc with\n | Tstr_eval (expr, _) ->\n let body, size =\n transl_structure ~scopes loc fields cc rootpath final_env rem\n in\n Lsequence(transl_exp ~scopes expr, body), size\n | Tstr_value(rec_flag, pat_expr_list) ->\n (* Translate bindings first *)\n let mk_lam_let =\n transl_let ~scopes ~in_structure:true rec_flag pat_expr_list in\n let ext_fields =\n List.rev_append (let_bound_idents pat_expr_list) fields in\n (* Then, translate remainder of struct *)\n let body, size =\n transl_structure ~scopes loc ext_fields cc rootpath final_env rem\n in\n mk_lam_let body, size\n | Tstr_primitive descr ->\n record_primitive descr.val_val;\n transl_structure ~scopes loc fields cc rootpath final_env rem\n | Tstr_type _ ->\n transl_structure ~scopes loc fields cc rootpath final_env rem\n | Tstr_typext(tyext) ->\n let ids = List.map (fun ext -> ext.ext_id) tyext.tyext_constructors in\n let body, size =\n transl_structure ~scopes loc (List.rev_append ids fields)\n cc rootpath final_env rem\n in\n transl_type_extension ~scopes item.str_env rootpath tyext body, size\n | Tstr_exception ext ->\n let id = ext.tyexn_constructor.ext_id in\n let path = field_path rootpath id in\n let body, size =\n transl_structure ~scopes loc (id::fields) cc rootpath final_env rem\n in\n Llet(Strict, Pgenval, id,\n transl_extension_constructor ~scopes\n item.str_env\n path\n ext.tyexn_constructor, body),\n size\n | Tstr_module ({mb_presence=Mp_present} as mb) ->\n let id = mb.mb_id in\n (* Translate module first *)\n let subscopes = match id with\n | None -> scopes\n | Some id -> enter_module_definition ~scopes id in\n let module_body =\n transl_module ~scopes:subscopes Tcoerce_none\n (Option.bind id (field_path rootpath)) mb.mb_expr\n in\n let module_body =\n Translattribute.add_inline_attribute module_body mb.mb_loc\n mb.mb_attributes\n in\n (* Translate remainder second *)\n let body, size =\n transl_structure ~scopes loc (cons_opt id fields)\n cc rootpath final_env rem\n in\n begin match id with\n | None ->\n Lsequence (Lprim(Pignore, [module_body],\n of_location ~scopes mb.mb_name.loc), body),\n size\n | Some id ->\n let module_body =\n Levent (module_body, {\n lev_loc = of_location ~scopes mb.mb_loc;\n lev_kind = Lev_module_definition id;\n lev_repr = None;\n lev_env = Env.empty;\n })\n in\n Llet(pure_module mb.mb_expr, Pgenval, id, module_body, body), size\n end\n | Tstr_module ({mb_presence=Mp_absent} as mb) ->\n List.iter (Translattribute.check_attribute_on_module mb.mb_expr)\n mb.mb_attributes;\n List.iter (Translattribute.check_attribute_on_module mb.mb_expr)\n mb.mb_expr.mod_attributes;\n transl_structure ~scopes loc fields cc rootpath final_env rem\n | Tstr_recmodule bindings ->\n let ext_fields =\n List.rev_append (List.filter_map (fun mb -> mb.mb_id) bindings)\n fields\n in\n let body, size =\n transl_structure ~scopes loc ext_fields cc rootpath final_env rem\n in\n let lam =\n compile_recmodule ~scopes (fun id modl loc ->\n match id with\n | None -> transl_module ~scopes Tcoerce_none None modl\n | Some id ->\n let module_body =\n transl_module\n ~scopes:(enter_module_definition ~scopes id)\n Tcoerce_none (field_path rootpath id) modl\n in\n Levent (module_body, {\n lev_loc = of_location ~scopes loc;\n lev_kind = Lev_module_definition id;\n lev_repr = None;\n lev_env = Env.empty;\n })\n ) bindings body\n in\n lam, size\n | Tstr_class cl_list ->\n let (ids, class_bindings) = transl_class_bindings ~scopes cl_list in\n let body, size =\n transl_structure ~scopes loc (List.rev_append ids fields)\n cc rootpath final_env rem\n in\n Lletrec(class_bindings, body), size\n | Tstr_include incl ->\n let ids = bound_value_identifiers incl.incl_type in\n let modl = incl.incl_mod in\n let mid = Ident.create_local \"include\" in\n let rec rebind_idents pos newfields = function\n [] ->\n transl_structure ~scopes loc newfields cc rootpath final_env rem\n | id :: ids ->\n let body, size =\n rebind_idents (pos + 1) (id :: newfields) ids\n in\n Llet(Alias, Pgenval, id,\n Lprim(Pfield pos, [Lvar mid],\n of_location ~scopes incl.incl_loc), body),\n size\n in\n let body, size = rebind_idents 0 fields ids in\n Llet(pure_module modl, Pgenval, mid,\n transl_module ~scopes Tcoerce_none None modl, body),\n size\n\n | Tstr_open od ->\n let pure = pure_module od.open_expr in\n (* this optimization shouldn't be needed because Simplif would\n actually remove the [Llet] when it's not used.\n But since [scan_used_globals] runs before Simplif, we need to do\n it. *)\n begin match od.open_bound_items with\n | [] when pure = Alias ->\n transl_structure ~scopes loc fields cc rootpath final_env rem\n | _ ->\n let ids = bound_value_identifiers od.open_bound_items in\n let mid = Ident.create_local \"open\" in\n let rec rebind_idents pos newfields = function\n [] -> transl_structure\n ~scopes loc newfields cc rootpath final_env rem\n | id :: ids ->\n let body, size =\n rebind_idents (pos + 1) (id :: newfields) ids\n in\n Llet(Alias, Pgenval, id,\n Lprim(Pfield pos, [Lvar mid],\n of_location ~scopes od.open_loc), body),\n size\n in\n let body, size = rebind_idents 0 fields ids in\n Llet(pure, Pgenval, mid,\n transl_module ~scopes Tcoerce_none None od.open_expr, body),\n size\n end\n | Tstr_modtype _\n | Tstr_class_type _\n | Tstr_attribute _ ->\n transl_structure ~scopes loc fields cc rootpath final_env rem\n\n(* Update forward declaration in Translcore *)\nlet _ =\n Translcore.transl_module := transl_module\n\n(* Introduce dependencies on modules referenced only by \"external\". *)\n\nlet scan_used_globals lam =\n let globals = ref Ident.Set.empty in\n let rec scan lam =\n Lambda.iter_head_constructor scan lam;\n match lam with\n Lprim ((Pgetglobal id | Psetglobal id), _, _) ->\n globals := Ident.Set.add id !globals\n | _ -> ()\n in\n scan lam; !globals\n\nlet required_globals ~flambda body =\n let globals = scan_used_globals body in\n let add_global id req =\n if not flambda && Ident.Set.mem id globals then\n req\n else\n Ident.Set.add id req\n in\n let required =\n List.fold_left\n (fun acc path -> add_global (Path.head path) acc)\n (if flambda then globals else Ident.Set.empty)\n (Translprim.get_used_primitives ())\n in\n let required =\n List.fold_right add_global (Env.get_required_globals ()) required\n in\n Env.reset_required_globals ();\n Translprim.clear_used_primitives ();\n required\n\n(* Compile an implementation *)\n\nlet transl_implementation_flambda module_name (str, cc) =\n reset_labels ();\n primitive_declarations := [];\n Translprim.clear_used_primitives ();\n let module_id = Ident.create_persistent module_name in\n let scopes = enter_module_definition ~scopes:empty_scopes module_id in\n let body, size =\n Translobj.transl_label_init\n (fun () -> transl_struct ~scopes Loc_unknown [] cc\n (global_path module_id) str)\n in\n { module_ident = module_id;\n main_module_block_size = size;\n required_globals = required_globals ~flambda:true body;\n code = body }\n\nlet transl_implementation module_name (str, cc) =\n let implementation =\n transl_implementation_flambda module_name (str, cc)\n in\n let code =\n Lprim (Psetglobal implementation.module_ident, [implementation.code],\n Loc_unknown)\n in\n { implementation with code }\n\n(* Build the list of value identifiers defined by a toplevel structure\n (excluding primitive declarations). *)\n\nlet rec defined_idents = function\n [] -> []\n | item :: rem ->\n match item.str_desc with\n | Tstr_eval _ -> defined_idents rem\n | Tstr_value(_rec_flag, pat_expr_list) ->\n let_bound_idents pat_expr_list @ defined_idents rem\n | Tstr_primitive _ -> defined_idents rem\n | Tstr_type _ -> defined_idents rem\n | Tstr_typext tyext ->\n List.map (fun ext -> ext.ext_id) tyext.tyext_constructors\n @ defined_idents rem\n | Tstr_exception ext -> ext.tyexn_constructor.ext_id :: defined_idents rem\n | Tstr_module {mb_id = Some id; mb_presence=Mp_present} ->\n id :: defined_idents rem\n | Tstr_module ({mb_id = None}\n |{mb_presence=Mp_absent}) -> defined_idents rem\n | Tstr_recmodule decls ->\n List.filter_map (fun mb -> mb.mb_id) decls @ defined_idents rem\n | Tstr_modtype _ -> defined_idents rem\n | Tstr_open od ->\n bound_value_identifiers od.open_bound_items @ defined_idents rem\n | Tstr_class cl_list ->\n List.map (fun (ci, _) -> ci.ci_id_class) cl_list @ defined_idents rem\n | Tstr_class_type _ -> defined_idents rem\n | Tstr_include incl ->\n bound_value_identifiers incl.incl_type @ defined_idents rem\n | Tstr_attribute _ -> defined_idents rem\n\n(* second level idents (module M = struct ... let id = ... end),\n and all sub-levels idents *)\nlet rec more_idents = function\n [] -> []\n | item :: rem ->\n match item.str_desc with\n | Tstr_eval _ -> more_idents rem\n | Tstr_value _ -> more_idents rem\n | Tstr_primitive _ -> more_idents rem\n | Tstr_type _ -> more_idents rem\n | Tstr_typext _ -> more_idents rem\n | Tstr_exception _ -> more_idents rem\n | Tstr_recmodule _ -> more_idents rem\n | Tstr_modtype _ -> more_idents rem\n | Tstr_open od ->\n let rest = more_idents rem in\n begin match od.open_expr.mod_desc with\n | Tmod_structure str -> all_idents str.str_items @ rest\n | _ -> rest\n end\n | Tstr_class _ -> more_idents rem\n | Tstr_class_type _ -> more_idents rem\n | Tstr_include{incl_mod={mod_desc =\n Tmod_constraint ({mod_desc = Tmod_structure str},\n _, _, _)}} ->\n all_idents str.str_items @ more_idents rem\n | Tstr_include _ -> more_idents rem\n | Tstr_module\n {mb_presence=Mp_present; mb_expr={mod_desc = Tmod_structure str}}\n | Tstr_module\n {mb_presence=Mp_present;\n mb_expr={mod_desc=\n Tmod_constraint ({mod_desc = Tmod_structure str}, _, _, _)}} ->\n all_idents str.str_items @ more_idents rem\n | Tstr_module _ -> more_idents rem\n | Tstr_attribute _ -> more_idents rem\n\nand all_idents = function\n [] -> []\n | item :: rem ->\n match item.str_desc with\n | Tstr_eval _ -> all_idents rem\n | Tstr_value(_rec_flag, pat_expr_list) ->\n let_bound_idents pat_expr_list @ all_idents rem\n | Tstr_primitive _ -> all_idents rem\n | Tstr_type _ -> all_idents rem\n | Tstr_typext tyext ->\n List.map (fun ext -> ext.ext_id) tyext.tyext_constructors\n @ all_idents rem\n | Tstr_exception ext -> ext.tyexn_constructor.ext_id :: all_idents rem\n | Tstr_recmodule decls ->\n List.filter_map (fun mb -> mb.mb_id) decls @ all_idents rem\n | Tstr_modtype _ -> all_idents rem\n | Tstr_open od ->\n let rest = all_idents rem in\n begin match od.open_expr.mod_desc with\n | Tmod_structure str ->\n bound_value_identifiers od.open_bound_items\n @ all_idents str.str_items\n @ rest\n | _ -> bound_value_identifiers od.open_bound_items @ rest\n end\n | Tstr_class cl_list ->\n List.map (fun (ci, _) -> ci.ci_id_class) cl_list @ all_idents rem\n | Tstr_class_type _ -> all_idents rem\n\n | Tstr_include{incl_type; incl_mod={mod_desc =\n Tmod_constraint ({mod_desc = Tmod_structure str},\n _, _, _)}} ->\n bound_value_identifiers incl_type\n @ all_idents str.str_items\n @ all_idents rem\n | Tstr_include incl ->\n bound_value_identifiers incl.incl_type @ all_idents rem\n\n | Tstr_module\n { mb_id = Some id;\n mb_presence=Mp_present;\n mb_expr={mod_desc = Tmod_structure str} }\n | Tstr_module\n { mb_id = Some id;\n mb_presence = Mp_present;\n mb_expr =\n {mod_desc =\n Tmod_constraint ({mod_desc = Tmod_structure str}, _, _, _)}} ->\n id :: all_idents str.str_items @ all_idents rem\n | Tstr_module {mb_id = Some id;mb_presence=Mp_present} ->\n id :: all_idents rem\n | Tstr_module ({mb_id = None} | {mb_presence=Mp_absent}) -> all_idents rem\n | Tstr_attribute _ -> all_idents rem\n\n\n(* A variant of transl_structure used to compile toplevel structure definitions\n for the native-code compiler. Store the defined values in the fields\n of the global as soon as they are defined, in order to reduce register\n pressure. Also rewrites the defining expressions so that they\n refer to earlier fields of the structure through the fields of\n the global, not by their names.\n \"map\" is a table from defined idents to (pos in global block, coercion).\n \"prim\" is a list of (pos in global block, primitive declaration). *)\n\nlet transl_store_subst = ref Ident.Map.empty\n (** In the native toplevel, this reference is threaded through successive\n calls of transl_store_structure *)\n\nlet nat_toplevel_name id =\n try match Ident.Map.find id !transl_store_subst with\n | Lprim(Pfield pos, [Lprim(Pgetglobal glob, [], _)], _) -> (glob,pos)\n | _ -> raise Not_found\n with Not_found ->\n fatal_error(\"Translmod.nat_toplevel_name: \" ^ Ident.unique_name id)\n\nlet field_of_str loc str =\n let ids = Array.of_list (defined_idents str.str_items) in\n fun (pos, cc) ->\n match cc with\n | Tcoerce_primitive { pc_loc = _; pc_desc; pc_env; pc_type; } ->\n Translprim.transl_primitive loc pc_desc pc_env pc_type None\n | Tcoerce_alias (env, path, cc) ->\n let lam = transl_module_path loc env path in\n apply_coercion loc Alias cc lam\n | _ -> apply_coercion loc Strict cc (Lvar ids.(pos))\n\n\nlet transl_store_structure ~scopes glob map prims aliases str =\n let no_env_update _ _ env = env in\n let rec transl_store ~scopes rootpath subst cont = function\n [] ->\n transl_store_subst := subst;\n Lambda.subst no_env_update subst cont\n | item :: rem ->\n match item.str_desc with\n | Tstr_eval (expr, _attrs) ->\n Lsequence(Lambda.subst no_env_update subst\n (transl_exp ~scopes expr),\n transl_store ~scopes rootpath subst cont rem)\n | Tstr_value(rec_flag, pat_expr_list) ->\n let ids = let_bound_idents pat_expr_list in\n let lam =\n transl_let ~scopes ~in_structure:true rec_flag pat_expr_list\n (store_idents Loc_unknown ids)\n in\n Lsequence(Lambda.subst no_env_update subst lam,\n transl_store ~scopes rootpath\n (add_idents false ids subst) cont rem)\n | Tstr_primitive descr ->\n record_primitive descr.val_val;\n transl_store ~scopes rootpath subst cont rem\n | Tstr_type _ ->\n transl_store ~scopes rootpath subst cont rem\n | Tstr_typext(tyext) ->\n let ids =\n List.map (fun ext -> ext.ext_id) tyext.tyext_constructors\n in\n let lam =\n transl_type_extension ~scopes item.str_env rootpath tyext\n (store_idents Loc_unknown ids)\n in\n Lsequence(Lambda.subst no_env_update subst lam,\n transl_store ~scopes rootpath\n (add_idents false ids subst) cont rem)\n | Tstr_exception ext ->\n let id = ext.tyexn_constructor.ext_id in\n let path = field_path rootpath id in\n let loc = of_location ~scopes ext.tyexn_constructor.ext_loc in\n let lam =\n transl_extension_constructor ~scopes\n item.str_env\n path\n ext.tyexn_constructor\n in\n Lsequence(Llet(Strict, Pgenval, id,\n Lambda.subst no_env_update subst lam,\n store_ident loc id),\n transl_store ~scopes rootpath\n (add_ident false id subst) cont rem)\n | Tstr_module\n {mb_id=None; mb_name; mb_presence=Mp_present; mb_expr=modl;\n mb_loc=loc; mb_attributes} ->\n let lam =\n Translattribute.add_inline_attribute\n (transl_module ~scopes Tcoerce_none None modl)\n loc mb_attributes\n in\n Lsequence(\n Lprim(Pignore,[Lambda.subst no_env_update subst lam],\n of_location ~scopes mb_name.loc),\n transl_store ~scopes rootpath subst cont rem\n )\n | Tstr_module{mb_id=Some id;mb_loc=loc;mb_presence=Mp_present;\n mb_expr={mod_desc = Tmod_structure str} as mexp;\n mb_attributes} ->\n List.iter (Translattribute.check_attribute_on_module mexp)\n mb_attributes;\n let loc = of_location ~scopes loc in\n let lam =\n transl_store\n ~scopes:(enter_module_definition ~scopes id)\n (field_path rootpath id) subst\n lambda_unit str.str_items\n in\n (* Careful: see next case *)\n let subst = !transl_store_subst in\n Lsequence(lam,\n Llet(Strict, Pgenval, id,\n Lambda.subst no_env_update subst\n (Lprim(Pmakeblock(0, Immutable, None),\n List.map (fun id -> Lvar id)\n (defined_idents str.str_items), loc)),\n Lsequence(store_ident loc id,\n transl_store ~scopes rootpath\n (add_ident true id subst)\n cont rem)))\n | Tstr_module{\n mb_id=Some id;mb_loc=loc;mb_presence=Mp_present;\n mb_expr= {\n mod_desc = Tmod_constraint (\n {mod_desc = Tmod_structure str} as mexp, _, _,\n (Tcoerce_structure (map, _) as _cc))};\n mb_attributes\n } ->\n (* Format.printf \"coerc id %s: %a@.\" (Ident.unique_name id)\n Includemod.print_coercion cc; *)\n List.iter (Translattribute.check_attribute_on_module mexp)\n mb_attributes;\n let loc = of_location ~scopes loc in\n let lam =\n transl_store\n ~scopes:(enter_module_definition ~scopes id)\n (field_path rootpath id) subst\n lambda_unit str.str_items\n in\n (* Careful: see next case *)\n let subst = !transl_store_subst in\n let field = field_of_str loc str in\n Lsequence(lam,\n Llet(Strict, Pgenval, id,\n Lambda.subst no_env_update subst\n (Lprim(Pmakeblock(0, Immutable, None),\n List.map field map, loc)),\n Lsequence(store_ident loc id,\n transl_store ~scopes rootpath\n (add_ident true id subst)\n cont rem)))\n | Tstr_module\n {mb_id=Some id; mb_presence=Mp_present; mb_expr=modl;\n mb_loc=loc; mb_attributes} ->\n let lam =\n Translattribute.add_inline_attribute\n (transl_module\n ~scopes:(enter_module_definition ~scopes id)\n Tcoerce_none (field_path rootpath id) modl)\n loc mb_attributes\n in\n (* Careful: the module value stored in the global may be different\n from the local module value, in case a coercion is applied.\n If so, keep using the local module value (id) in the remainder of\n the compilation unit (add_ident true returns subst unchanged).\n If not, we can use the value from the global\n (add_ident true adds id -> Pgetglobal... to subst). *)\n Llet(Strict, Pgenval, id, Lambda.subst no_env_update subst lam,\n Lsequence(store_ident (of_location ~scopes loc) id,\n transl_store ~scopes rootpath\n (add_ident true id subst)\n cont rem))\n | Tstr_module ({mb_presence=Mp_absent} as mb) ->\n List.iter (Translattribute.check_attribute_on_module mb.mb_expr)\n mb.mb_attributes;\n List.iter (Translattribute.check_attribute_on_module mb.mb_expr)\n mb.mb_expr.mod_attributes;\n transl_store ~scopes rootpath subst cont rem\n | Tstr_recmodule bindings ->\n let ids = List.filter_map (fun mb -> mb.mb_id) bindings in\n compile_recmodule ~scopes\n (fun id modl _loc ->\n Lambda.subst no_env_update subst\n (match id with\n | None ->\n transl_module ~scopes Tcoerce_none None modl\n | Some id ->\n transl_module\n ~scopes:(enter_module_definition ~scopes id)\n Tcoerce_none (field_path rootpath id) modl))\n bindings\n (Lsequence(store_idents Loc_unknown ids,\n transl_store ~scopes rootpath\n (add_idents true ids subst) cont rem))\n | Tstr_class cl_list ->\n let (ids, class_bindings) = transl_class_bindings ~scopes cl_list in\n let lam =\n Lletrec(class_bindings, store_idents Loc_unknown ids)\n in\n Lsequence(Lambda.subst no_env_update subst lam,\n transl_store ~scopes rootpath (add_idents false ids subst)\n cont rem)\n\n | Tstr_include{\n incl_loc=loc;\n incl_mod= {\n mod_desc = Tmod_constraint (\n ({mod_desc = Tmod_structure str} as mexp), _, _,\n (Tcoerce_structure (map, _)))};\n incl_attributes;\n incl_type;\n } ->\n List.iter (Translattribute.check_attribute_on_module mexp)\n incl_attributes;\n (* Shouldn't we use mod_attributes instead of incl_attributes?\n Same question for the Tstr_module cases above, btw. *)\n let lam =\n transl_store ~scopes None subst lambda_unit str.str_items\n (* It is tempting to pass rootpath instead of None\n in order to give a more precise name to exceptions\n in the included structured, but this would introduce\n a difference of behavior compared to bytecode. *)\n in\n let subst = !transl_store_subst in\n let field = field_of_str (of_location ~scopes loc) str in\n let ids0 = bound_value_identifiers incl_type in\n let rec loop ids args =\n match ids, args with\n | [], [] ->\n transl_store ~scopes rootpath (add_idents true ids0 subst)\n cont rem\n | id :: ids, arg :: args ->\n Llet(Alias, Pgenval, id,\n Lambda.subst no_env_update subst (field arg),\n Lsequence(store_ident (of_location ~scopes loc) id,\n loop ids args))\n | _ -> assert false\n in\n Lsequence(lam, loop ids0 map)\n\n\n | Tstr_include incl ->\n let ids = bound_value_identifiers incl.incl_type in\n let modl = incl.incl_mod in\n let mid = Ident.create_local \"include\" in\n let loc = incl.incl_loc in\n let rec store_idents pos = function\n | [] -> transl_store\n ~scopes rootpath (add_idents true ids subst) cont rem\n | id :: idl ->\n Llet(Alias, Pgenval, id, Lprim(Pfield pos, [Lvar mid],\n of_location ~scopes loc),\n Lsequence(store_ident (of_location ~scopes loc) id,\n store_idents (pos + 1) idl))\n in\n Llet(Strict, Pgenval, mid,\n Lambda.subst no_env_update subst\n (transl_module ~scopes Tcoerce_none None modl),\n store_idents 0 ids)\n | Tstr_open od ->\n begin match od.open_expr.mod_desc with\n | Tmod_structure str ->\n let lam =\n transl_store ~scopes rootpath subst lambda_unit str.str_items\n in\n let loc = of_location ~scopes od.open_loc in\n let ids = Array.of_list (defined_idents str.str_items) in\n let ids0 = bound_value_identifiers od.open_bound_items in\n let subst = !transl_store_subst in\n let rec store_idents pos = function\n | [] -> transl_store ~scopes rootpath\n (add_idents true ids0 subst) cont rem\n | id :: idl ->\n Llet(Alias, Pgenval, id, Lvar ids.(pos),\n Lsequence(store_ident loc id,\n store_idents (pos + 1) idl))\n in\n Lsequence(lam, Lambda.subst no_env_update subst\n (store_idents 0 ids0))\n | _ ->\n let pure = pure_module od.open_expr in\n (* this optimization shouldn't be needed because Simplif would\n actually remove the [Llet] when it's not used.\n But since [scan_used_globals] runs before Simplif, we need to\n do it. *)\n match od.open_bound_items with\n | [] when pure = Alias ->\n transl_store ~scopes rootpath subst cont rem\n | _ ->\n let ids = bound_value_identifiers od.open_bound_items in\n let mid = Ident.create_local \"open\" in\n let loc = of_location ~scopes od.open_loc in\n let rec store_idents pos = function\n [] -> transl_store ~scopes rootpath\n (add_idents true ids subst) cont rem\n | id :: idl ->\n Llet(Alias, Pgenval, id, Lprim(Pfield pos, [Lvar mid],\n loc),\n Lsequence(store_ident loc id,\n store_idents (pos + 1) idl))\n in\n Llet(\n pure, Pgenval, mid,\n Lambda.subst no_env_update subst\n (transl_module ~scopes Tcoerce_none None od.open_expr),\n store_idents 0 ids)\n end\n | Tstr_modtype _\n | Tstr_class_type _\n | Tstr_attribute _ ->\n transl_store ~scopes rootpath subst cont rem\n\n and store_ident loc id =\n try\n let (pos, cc) = Ident.find_same id map in\n let init_val = apply_coercion loc Alias cc (Lvar id) in\n Lprim(Psetfield(pos, Pointer, Root_initialization),\n [Lprim(Pgetglobal glob, [], loc); init_val],\n loc)\n with Not_found ->\n fatal_error(\"Translmod.store_ident: \" ^ Ident.unique_name id)\n\n and store_idents loc idlist =\n make_sequence (store_ident loc) idlist\n\n and add_ident may_coerce id subst =\n try\n let (pos, cc) = Ident.find_same id map in\n match cc with\n Tcoerce_none ->\n Ident.Map.add id\n (Lprim(Pfield pos,\n [Lprim(Pgetglobal glob, [], Loc_unknown)],\n Loc_unknown))\n subst\n | _ ->\n if may_coerce then subst else assert false\n with Not_found ->\n assert false\n\n and add_idents may_coerce idlist subst =\n List.fold_right (add_ident may_coerce) idlist subst\n\n and store_primitive (pos, prim) cont =\n Lsequence(Lprim(Psetfield(pos, Pointer, Root_initialization),\n [Lprim(Pgetglobal glob, [], Loc_unknown);\n Translprim.transl_primitive Loc_unknown\n prim.pc_desc prim.pc_env prim.pc_type None],\n Loc_unknown),\n cont)\n\n and store_alias (pos, env, path, cc) =\n let path_lam = transl_module_path Loc_unknown env path in\n let init_val = apply_coercion Loc_unknown Strict cc path_lam in\n Lprim(Psetfield(pos, Pointer, Root_initialization),\n [Lprim(Pgetglobal glob, [], Loc_unknown);\n init_val],\n Loc_unknown)\n in\n let aliases = make_sequence store_alias aliases in\n List.fold_right store_primitive prims\n (transl_store ~scopes (global_path glob) !transl_store_subst aliases str)\n\n(* Transform a coercion and the list of value identifiers defined by\n a toplevel structure into a table [id -> (pos, coercion)],\n with [pos] being the position in the global block where the value of\n [id] must be stored, and [coercion] the coercion to be applied to it.\n A given identifier may appear several times\n in the coercion (if it occurs several times in the signature); remember\n to assign it the position of its last occurrence.\n Identifiers that are not exported are assigned positions at the\n end of the block (beyond the positions of all exported idents).\n Also compute the total size of the global block,\n and the list of all primitives exported as values. *)\n\nlet build_ident_map restr idlist more_ids =\n let rec natural_map pos map prims aliases = function\n | [] ->\n (map, prims, aliases, pos)\n | id :: rem ->\n natural_map (pos+1)\n (Ident.add id (pos, Tcoerce_none) map) prims aliases rem\n in\n let (map, prims, aliases, pos) =\n match restr with\n | Tcoerce_none ->\n natural_map 0 Ident.empty [] [] idlist\n | Tcoerce_structure (pos_cc_list, _id_pos_list) ->\n (* ignore _id_pos_list as the ids are already bound *)\n let idarray = Array.of_list idlist in\n let rec export_map pos map prims aliases undef = function\n | [] ->\n natural_map pos map prims aliases undef\n | (_source_pos, Tcoerce_primitive p) :: rem ->\n export_map (pos + 1) map\n ((pos, p) :: prims) aliases undef rem\n | (_source_pos, Tcoerce_alias(env, path, cc)) :: rem ->\n export_map (pos + 1) map prims\n ((pos, env, path, cc) :: aliases) undef rem\n | (source_pos, cc) :: rem ->\n let id = idarray.(source_pos) in\n export_map (pos + 1) (Ident.add id (pos, cc) map)\n prims aliases (list_remove id undef) rem\n in\n export_map 0 Ident.empty [] [] idlist pos_cc_list\n | _ ->\n fatal_error \"Translmod.build_ident_map\"\n in\n natural_map pos map prims aliases more_ids\n\n(* Compile an implementation using transl_store_structure\n (for the native-code compiler). *)\n\nlet transl_store_gen ~scopes module_name ({ str_items = str }, restr) topl =\n reset_labels ();\n primitive_declarations := [];\n Translprim.clear_used_primitives ();\n let module_id = Ident.create_persistent module_name in\n let (map, prims, aliases, size) =\n build_ident_map restr (defined_idents str) (more_idents str) in\n let f = function\n | [ { str_desc = Tstr_eval (expr, _attrs) } ] when topl ->\n assert (size = 0);\n Lambda.subst (fun _ _ env -> env) !transl_store_subst\n (transl_exp ~scopes expr)\n | str -> transl_store_structure ~scopes module_id map prims aliases str\n in\n transl_store_label_init module_id size f str\n (*size, transl_label_init (transl_store_structure module_id map prims str)*)\n\nlet transl_store_phrases module_name str =\n let scopes =\n enter_module_definition ~scopes:empty_scopes\n (Ident.create_persistent module_name)\n in\n transl_store_gen ~scopes module_name (str,Tcoerce_none) true\n\nlet transl_store_implementation module_name (str, restr) =\n let s = !transl_store_subst in\n transl_store_subst := Ident.Map.empty;\n let module_ident = Ident.create_persistent module_name in\n let scopes = enter_module_definition ~scopes:empty_scopes module_ident in\n let (i, code) = transl_store_gen ~scopes module_name (str, restr) false in\n transl_store_subst := s;\n { Lambda.main_module_block_size = i;\n code;\n (* module_ident is not used by closure, but this allow to share\n the type with the flambda version *)\n module_ident;\n required_globals = required_globals ~flambda:true code }\n\n(* Compile a toplevel phrase *)\n\nlet toploop_ident = Ident.create_persistent \"Toploop\"\nlet toploop_getvalue_pos = 0 (* position of getvalue in module Toploop *)\nlet toploop_setvalue_pos = 1 (* position of setvalue in module Toploop *)\n\nlet aliased_idents = ref Ident.empty\n\nlet set_toplevel_unique_name id =\n aliased_idents :=\n Ident.add id (Ident.unique_toplevel_name id) !aliased_idents\n\nlet toplevel_name id =\n try Ident.find_same id !aliased_idents\n with Not_found -> Ident.name id\n\nlet toploop_getvalue id =\n Lapply{\n ap_loc=Loc_unknown;\n ap_func=Lprim(Pfield toploop_getvalue_pos,\n [Lprim(Pgetglobal toploop_ident, [], Loc_unknown)],\n Loc_unknown);\n ap_args=[Lconst(Const_base(\n Const_string (toplevel_name id, Location.none, None)))];\n ap_tailcall=Default_tailcall;\n ap_inlined=Default_inline;\n ap_specialised=Default_specialise;\n }\n\nlet toploop_setvalue id lam =\n Lapply{\n ap_loc=Loc_unknown;\n ap_func=Lprim(Pfield toploop_setvalue_pos,\n [Lprim(Pgetglobal toploop_ident, [], Loc_unknown)],\n Loc_unknown);\n ap_args=\n [Lconst(Const_base(\n Const_string(toplevel_name id, Location.none, None)));\n lam];\n ap_tailcall=Default_tailcall;\n ap_inlined=Default_inline;\n ap_specialised=Default_specialise;\n }\n\nlet toploop_setvalue_id id = toploop_setvalue id (Lvar id)\n\nlet close_toplevel_term (lam, ()) =\n Ident.Set.fold (fun id l -> Llet(Strict, Pgenval, id,\n toploop_getvalue id, l))\n (free_variables lam) lam\n\nlet transl_toplevel_item ~scopes item =\n match item.str_desc with\n Tstr_eval (expr, _)\n | Tstr_value(Nonrecursive,\n [{vb_pat = {pat_desc=Tpat_any};vb_expr = expr}]) ->\n (* special compilation for toplevel \"let _ = expr\", so\n that Toploop can display the result of the expression.\n Otherwise, the normal compilation would result\n in a Lsequence returning unit. *)\n transl_exp ~scopes expr\n | Tstr_value(rec_flag, pat_expr_list) ->\n let idents = let_bound_idents pat_expr_list in\n transl_let ~scopes ~in_structure:true rec_flag pat_expr_list\n (make_sequence toploop_setvalue_id idents)\n | Tstr_typext(tyext) ->\n let idents =\n List.map (fun ext -> ext.ext_id) tyext.tyext_constructors\n in\n (* we need to use unique name in case of multiple\n definitions of the same extension constructor in the toplevel *)\n List.iter set_toplevel_unique_name idents;\n transl_type_extension ~scopes item.str_env None tyext\n (make_sequence toploop_setvalue_id idents)\n | Tstr_exception ext ->\n set_toplevel_unique_name ext.tyexn_constructor.ext_id;\n toploop_setvalue ext.tyexn_constructor.ext_id\n (transl_extension_constructor ~scopes\n item.str_env None ext.tyexn_constructor)\n | Tstr_module {mb_id=None; mb_presence=Mp_present; mb_expr=modl} ->\n transl_module ~scopes Tcoerce_none None modl\n | Tstr_module {mb_id=Some id; mb_presence=Mp_present; mb_expr=modl} ->\n (* we need to use the unique name for the module because of issues\n with \"open\" (PR#8133) *)\n set_toplevel_unique_name id;\n let lam = transl_module\n ~scopes:(enter_module_definition ~scopes id)\n Tcoerce_none (Some(Pident id)) modl in\n toploop_setvalue id lam\n | Tstr_recmodule bindings ->\n let idents = List.filter_map (fun mb -> mb.mb_id) bindings in\n compile_recmodule ~scopes\n (fun id modl _loc ->\n match id with\n | None ->\n transl_module ~scopes Tcoerce_none None modl\n | Some id ->\n transl_module\n ~scopes:(enter_module_definition ~scopes id)\n Tcoerce_none (Some (Pident id)) modl)\n bindings\n (make_sequence toploop_setvalue_id idents)\n | Tstr_class cl_list ->\n (* we need to use unique names for the classes because there might\n be a value named identically *)\n let (ids, class_bindings) = transl_class_bindings ~scopes cl_list in\n List.iter set_toplevel_unique_name ids;\n Lletrec(class_bindings, make_sequence toploop_setvalue_id ids)\n | Tstr_include incl ->\n let ids = bound_value_identifiers incl.incl_type in\n let modl = incl.incl_mod in\n let mid = Ident.create_local \"include\" in\n let rec set_idents pos = function\n [] ->\n lambda_unit\n | id :: ids ->\n Lsequence(toploop_setvalue id\n (Lprim(Pfield pos, [Lvar mid], Loc_unknown)),\n set_idents (pos + 1) ids) in\n Llet(Strict, Pgenval, mid,\n transl_module ~scopes Tcoerce_none None modl, set_idents 0 ids)\n | Tstr_primitive descr ->\n record_primitive descr.val_val;\n lambda_unit\n | Tstr_open od ->\n let pure = pure_module od.open_expr in\n (* this optimization shouldn't be needed because Simplif would\n actually remove the [Llet] when it's not used.\n But since [scan_used_globals] runs before Simplif, we need to do\n it. *)\n begin match od.open_bound_items with\n | [] when pure = Alias -> lambda_unit\n | _ ->\n let ids = bound_value_identifiers od.open_bound_items in\n let mid = Ident.create_local \"open\" in\n let rec set_idents pos = function\n [] ->\n lambda_unit\n | id :: ids ->\n Lsequence(toploop_setvalue id\n (Lprim(Pfield pos, [Lvar mid], Loc_unknown)),\n set_idents (pos + 1) ids)\n in\n Llet(pure, Pgenval, mid,\n transl_module ~scopes Tcoerce_none None od.open_expr,\n set_idents 0 ids)\n end\n | Tstr_module ({mb_presence=Mp_absent} as mb) ->\n List.iter (Translattribute.check_attribute_on_module mb.mb_expr)\n mb.mb_attributes;\n List.iter (Translattribute.check_attribute_on_module mb.mb_expr)\n mb.mb_expr.mod_attributes;\n lambda_unit\n | Tstr_modtype _\n | Tstr_type _\n | Tstr_class_type _\n | Tstr_attribute _ ->\n lambda_unit\n\nlet transl_toplevel_item_and_close ~scopes itm =\n close_toplevel_term\n (transl_label_init (fun () -> transl_toplevel_item ~scopes itm, ()))\n\nlet transl_toplevel_definition str =\n reset_labels ();\n Translprim.clear_used_primitives ();\n make_sequence\n (transl_toplevel_item_and_close ~scopes:empty_scopes)\n str.str_items\n\n(* Compile the initialization code for a packed library *)\n\nlet get_component = function\n None -> Lconst const_unit\n | Some id -> Lprim(Pgetglobal id, [], Loc_unknown)\n\nlet transl_package_flambda component_names coercion =\n let size =\n match coercion with\n | Tcoerce_none -> List.length component_names\n | Tcoerce_structure (l, _) -> List.length l\n | Tcoerce_functor _\n | Tcoerce_primitive _\n | Tcoerce_alias _ -> assert false\n in\n size,\n apply_coercion Loc_unknown Strict coercion\n (Lprim(Pmakeblock(0, Immutable, None),\n List.map get_component component_names,\n Loc_unknown))\n\nlet transl_package component_names target_name coercion =\n let components =\n Lprim(Pmakeblock(0, Immutable, None),\n List.map get_component component_names, Loc_unknown) in\n Lprim(Psetglobal target_name,\n [apply_coercion Loc_unknown Strict coercion components],\n Loc_unknown)\n (*\n let components =\n match coercion with\n Tcoerce_none ->\n List.map get_component component_names\n | Tcoerce_structure (pos_cc_list, id_pos_list) ->\n (* ignore id_pos_list as the ids are already bound *)\n let g = Array.of_list component_names in\n List.map\n (fun (pos, cc) -> apply_coercion Strict cc (get_component g.(pos)))\n pos_cc_list\n | _ ->\n assert false in\n Lprim(Psetglobal target_name, [Lprim(Pmakeblock(0, Immutable), components)])\n *)\n\nlet transl_store_package component_names target_name coercion =\n let rec make_sequence fn pos arg =\n match arg with\n [] -> lambda_unit\n | hd :: tl -> Lsequence(fn pos hd, make_sequence fn (pos + 1) tl) in\n match coercion with\n Tcoerce_none ->\n (List.length component_names,\n make_sequence\n (fun pos id ->\n Lprim(Psetfield(pos, Pointer, Root_initialization),\n [Lprim(Pgetglobal target_name, [], Loc_unknown);\n get_component id],\n Loc_unknown))\n 0 component_names)\n | Tcoerce_structure (pos_cc_list, _id_pos_list) ->\n let components =\n Lprim(Pmakeblock(0, Immutable, None),\n List.map get_component component_names,\n Loc_unknown)\n in\n let blk = Ident.create_local \"block\" in\n (List.length pos_cc_list,\n Llet (Strict, Pgenval, blk,\n apply_coercion Loc_unknown Strict coercion components,\n make_sequence\n (fun pos _id ->\n Lprim(Psetfield(pos, Pointer, Root_initialization),\n [Lprim(Pgetglobal target_name, [], Loc_unknown);\n Lprim(Pfield pos, [Lvar blk], Loc_unknown)],\n Loc_unknown))\n 0 pos_cc_list))\n (*\n (* ignore id_pos_list as the ids are already bound *)\n let id = Array.of_list component_names in\n (List.length pos_cc_list,\n make_sequence\n (fun dst (src, cc) ->\n Lprim(Psetfield(dst, false),\n [Lprim(Pgetglobal target_name, []);\n apply_coercion Strict cc (get_component id.(src))]))\n 0 pos_cc_list)\n *)\n | _ -> assert false\n\n(* Error report *)\n\nopen Format\n\nlet print_cycle ppf cycle =\n let print_ident ppf (x,_) = Format.pp_print_string ppf (Ident.name x) in\n let pp_sep ppf () = fprintf ppf \"@ -> \" in\n Format.fprintf ppf \"%a%a%s\"\n (Format.pp_print_list ~pp_sep print_ident) cycle\n pp_sep ()\n (Ident.name @@ fst @@ List.hd cycle)\n(* we repeat the first element to make the cycle more apparent *)\n\nlet explanation_submsg (id, unsafe_info) =\n match unsafe_info with\n | Unnamed -> assert false (* can't be part of a cycle. *)\n | Unsafe {reason;loc;subid} ->\n let print fmt =\n let printer = Format.dprintf fmt (Ident.name id) (Ident.name subid) in\n Location.mkloc printer loc in\n match reason with\n | Unsafe_module_binding ->\n print \"Module %s defines an unsafe module, %s .\"\n | Unsafe_functor -> print \"Module %s defines an unsafe functor, %s .\"\n | Unsafe_typext ->\n print \"Module %s defines an unsafe extension constructor, %s .\"\n | Unsafe_non_function -> print \"Module %s defines an unsafe value, %s .\"\n\nlet report_error loc = function\n | Circular_dependency cycle ->\n let[@manual.ref \"s:recursive-modules\"] chapter, section = 10, 2 in\n Location.errorf ~loc ~sub:(List.map explanation_submsg cycle)\n \"Cannot safely evaluate the definition of the following cycle@ \\\n of recursively-defined modules:@ %a.@ \\\n There are no safe modules in this cycle@ (see manual section %d.%d).\"\n print_cycle cycle chapter section\n | Conflicting_inline_attributes ->\n Location.errorf \"@[Conflicting 'inline' attributes@]\"\n\nlet () =\n Location.register_error_of_exn\n (function\n | Error (loc, err) -> Some (report_error loc err)\n | _ ->\n None\n )\n\nlet reset () =\n primitive_declarations := [];\n transl_store_subst := Ident.Map.empty;\n aliased_idents := Ident.empty;\n Env.reset_required_globals ();\n Translprim.clear_used_primitives ()\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\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 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","(* protocol_version.ml *)\n\n(* see RFC 0049 for details *)\n\nopen Core_kernel\nmodule Wire_types = Mina_wire_types.Protocol_version\n\nmodule Make_sig (A : Wire_types.Types.S) = struct\n module type S = Protocol_version_intf.Full with type Stable.V2.t = A.V2.t\nend\n\nmodule Make_str (A : Wire_types.Concrete) = struct\n [%%versioned\n module Stable = struct\n module V2 = struct\n type t = A.V2.t = { transaction : int; network : int; patch : int }\n [@@deriving compare, equal, sexp, yojson, fields]\n\n let to_latest = Fn.id\n end\n end]\n\n include Comparable.Make (Stable.V2)\n\n let create = Fields.create\n\n let of_string_exn s =\n let is_digit_string s = String.for_all s ~f:Char.is_digit in\n match String.split s ~on:'.' with\n | [ transaction; network; patch ] ->\n if\n not\n ( is_digit_string transaction\n && is_digit_string network && is_digit_string patch )\n then failwith \"Unexpected nondigits in input\" ;\n { transaction = Int.of_string transaction\n ; network = Int.of_string network\n ; patch = Int.of_string patch\n }\n | _ ->\n failwith\n \"Protocol_version.of_string_exn: expected string of form nn.nn.nn\"\n\n let of_string_opt s = try Some (of_string_exn s) with _ -> None\n\n let to_string t = sprintf \"%u.%u.%u\" t.transaction t.network t.patch\n\n let current_transaction = Node_config_version.protocol_version_transaction\n\n let current_network = Node_config_version.protocol_version_network\n\n let current_patch = Node_config_version.protocol_version_patch\n\n let current =\n { transaction = current_transaction\n ; network = current_network\n ; patch = current_patch\n }\n\n let (proposed_protocol_version_opt : t option ref) = ref None\n\n let set_proposed_opt t_opt = proposed_protocol_version_opt := t_opt\n\n let get_proposed_opt () = !proposed_protocol_version_opt\n\n let compatible_with_daemon (t : t) =\n (* patch not considered for compatibility *)\n Int.equal t.transaction current.transaction\n && Int.equal t.network current.network\n\n (* when an external transition is deserialized, might contain\n negative numbers\n *)\n let is_valid t = Int.(t.transaction >= 1 && t.network >= 0 && t.patch >= 0)\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\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 rec go = function\n | Constant c, Some scale ->\n c * scale\n | Constant c, None ->\n c\n | Var v, Some scale ->\n context v * scale\n | Var v, None ->\n context v\n | Scale (s, t), Some scale ->\n go (t, Some (scale * s))\n | Scale (s, t), None ->\n go (t, Some s)\n | Add (t1, t2), Some scale ->\n (go (t1, None) + go (t2, None)) * scale\n | Add (t1, t2), None ->\n go (t1, None) + go (t2, None)\n in\n go (t0, None)\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 option\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 = List.find_map_exn !cases ~f:(fun m -> try f m with _ -> None)\n\n let sexp_of_t f1 f2 t =\n case (fun (module M) -> M.of_basic t |> Option.map ~f:(M.sexp_of_t f1 f2))\n\n let t_of_sexp f1 f2 s =\n case (fun (module M) -> Some (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.of_basic t |> Option.map ~f:(M.eval fm f))\n\n let map t ~f =\n case (fun (module M) ->\n M.of_basic t |> Option.map ~f:(fun t -> M.to_basic (M.map 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 -> Some x | _ -> None\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 t = Some t\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%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 match\n As_prover.Provider.run p (get_value s) (Run_state.handler s)\n with\n | Some x ->\n x\n | None ->\n failwith\n ( \"Unhandled request: \"\n ^ Core_kernel.String.concat ~sep:\"\\n\" (Run_state.stack 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 lazy\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 (Lazy.force 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 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 type ('input_var, 'return_var, 'result) manual_callbacks =\n { run_circuit : 'a. ('input_var -> unit -> 'a) -> 'a\n ; finish_computation : 'return_var -> 'result\n }\n\n let constraint_system_manual ~input_typ ~return_typ =\n let builder =\n Run.Constraint_system_builder.build ~input_typ ~return_typ\n in\n (* FIXME: This behaves badly with exceptions. *)\n let cached_state = ref None in\n let cached_active_counters = ref None in\n let run_circuit circuit =\n (* Check the status. *)\n if\n Option.is_some !cached_state || Option.is_some !cached_active_counters\n then failwith \"Already generating constraint system\" ;\n (* Partial [finalize_is_running]. *)\n cached_state := Some !state ;\n builder.run_computation (fun input state' ->\n (* Partial [as_stateful]. *)\n state := state' ;\n (* Partial [mark_active]. *)\n let counters = !active_counters in\n cached_active_counters := Some counters ;\n active_counters := this_functor_id :: counters ;\n (* Start the circuit. *)\n circuit input () )\n in\n let finish_computation return_var =\n (* Check the status. *)\n if\n Option.is_none !cached_state || Option.is_none !cached_active_counters\n then failwith \"Constraint system not in a finalizable state\" ;\n (* Partial [mark_active]. *)\n active_counters := Option.value_exn !cached_active_counters ;\n (* Create an invalid state, to avoid re-runs. *)\n cached_active_counters := None ;\n (* Partial [as_stateful]. *)\n let state' = !state in\n let res = builder.finish_computation (state', return_var) in\n (* Partial [finalize_is_running]. *)\n state := Option.value_exn !cached_state ;\n res\n in\n { run_circuit; finish_computation }\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 generate_witness_manual ?handlers ~input_typ ~return_typ input =\n let builder =\n Run.Witness_builder.auxiliary_input ?handlers ~input_typ ~return_typ\n input\n in\n (* FIXME: This behaves badly with exceptions. *)\n let cached_state = ref None in\n let cached_active_counters = ref None in\n let run_circuit circuit =\n (* Check the status. *)\n if\n Option.is_some !cached_state || Option.is_some !cached_active_counters\n then failwith \"Already generating constraint system\" ;\n (* Partial [finalize_is_running]. *)\n cached_state := Some !state ;\n builder.run_computation (fun input state' ->\n (* Partial [as_stateful]. *)\n state := state' ;\n (* Partial [mark_active]. *)\n let counters = !active_counters in\n cached_active_counters := Some counters ;\n active_counters := this_functor_id :: counters ;\n (* Start the circuit. *)\n circuit input () )\n in\n let finish_computation return_var =\n (* Check the status. *)\n if\n Option.is_none !cached_state || Option.is_none !cached_active_counters\n then failwith \"Constraint system not in a finalizable state\" ;\n (* Partial [mark_active]. *)\n active_counters := Option.value_exn !cached_active_counters ;\n (* Create an invalid state, to avoid re-runs. *)\n cached_active_counters := None ;\n (* Partial [as_stateful]. *)\n let state' = !state in\n let res = builder.finish_witness_generation (state', return_var) in\n (* Partial [finalize_is_running]. *)\n state := Option.value_exn !cached_state ;\n res\n in\n { run_circuit; finish_computation }\n\n (* start an as_prover / exists block and return a function to finish it and witness a given list of fields *)\n let as_prover_manual (size_to_witness : int) :\n (field array option -> Field.t array) Staged.t =\n let s = !state in\n let old_as_prover = Run_state.as_prover s in\n (* enter the as_prover block *)\n Run_state.set_as_prover s true ;\n\n let finish_computation (values_to_witness : field array option) =\n (* leave the as_prover block *)\n Run_state.set_as_prover s old_as_prover ;\n\n (* return variables *)\n match (Run_state.has_witness s, values_to_witness) with\n (* in compile mode, we return empty vars *)\n | false, None ->\n Core_kernel.Array.init size_to_witness ~f:(fun _ ->\n Run_state.alloc_var s () )\n (* in prover mode, we expect values to turn into vars *)\n | true, Some values_to_witness ->\n let store_value =\n (* If we're nested in a prover block, create constants instead of\n storing. *)\n if old_as_prover then Field.constant\n else Run_state.store_field_elt s\n in\n Core_kernel.Array.map values_to_witness ~f:store_value\n (* the other cases are invalid *)\n | false, Some _ ->\n failwith \"Did not expect values to witness\"\n | true, None ->\n failwith \"Expected values to witness\"\n in\n Staged.stage finish_computation\n\n let request_manual (req : unit -> 'a Request.t) () : 'a =\n Request.Handler.run (Run_state.handler !state) (req ())\n |> Option.value_exn ~message:\"Unhandled request\"\n\n module Async_generic (Promise : Base.Monad.S) = struct\n let run_prover ~(else_ : unit -> 'a) (f : unit -> 'a Promise.t) :\n 'a Promise.t =\n if Run_state.has_witness !state then (\n let old = Run_state.as_prover !state in\n Run_state.set_as_prover !state true ;\n let%map.Promise result = f () in\n Run_state.set_as_prover !state old ;\n result )\n else Promise.return (else_ ())\n\n let as_prover (f : unit -> unit Promise.t) : unit Promise.t =\n run_prover ~else_:(fun () -> ()) f\n\n let unit_request req = as_prover (request_manual req)\n end\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","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 = 'f Mina_wire_types.Pickles_types.Shifted_value.Type1.V1.t =\n | 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_minus_1 = Nat.N4\nmodule Lookup_sorted_minus_1_vec = Vector.Vector_4\nmodule Lookup_sorted = Nat.N5\nmodule Lookup_sorted_vec = Vector.Vector_5\n\nmodule Features = struct\n module Full = 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 ; uses_lookups : 'bool\n ; table_width_at_least_1 : 'bool\n ; table_width_at_least_2 : 'bool\n ; table_width_3 : 'bool\n ; lookups_per_row_3 : 'bool\n ; lookups_per_row_4 : 'bool\n ; lookup_pattern_xor : 'bool\n ; lookup_pattern_range_check : 'bool\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n\n let get_feature_flag (feature_flags : _ t)\n (feature : Kimchi_types.feature_flag) =\n match feature with\n | RangeCheck0 ->\n Some feature_flags.range_check0\n | RangeCheck1 ->\n Some feature_flags.range_check1\n | ForeignFieldAdd ->\n Some feature_flags.foreign_field_add\n | ForeignFieldMul ->\n Some feature_flags.foreign_field_mul\n | Xor ->\n Some feature_flags.xor\n | Rot ->\n Some feature_flags.rot\n | LookupTables ->\n Some feature_flags.uses_lookups\n | RuntimeLookupTables ->\n Some feature_flags.runtime_tables\n | TableWidth 3 ->\n Some feature_flags.table_width_3\n | TableWidth 2 ->\n Some feature_flags.table_width_at_least_2\n | TableWidth i when i <= 1 ->\n Some feature_flags.table_width_at_least_1\n | TableWidth _ ->\n None\n | LookupsPerRow 4 ->\n Some feature_flags.lookups_per_row_4\n | LookupsPerRow i when i <= 3 ->\n Some feature_flags.lookups_per_row_3\n | LookupsPerRow _ ->\n None\n | LookupPattern Lookup ->\n Some feature_flags.lookup\n | LookupPattern Xor ->\n Some feature_flags.lookup_pattern_xor\n | LookupPattern RangeCheck ->\n Some feature_flags.lookup_pattern_range_check\n | LookupPattern ForeignFieldMul ->\n Some feature_flags.foreign_field_mul\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 ; uses_lookups\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 } ~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 ; uses_lookups = f uses_lookups\n ; table_width_at_least_1 = f table_width_at_least_1\n ; table_width_at_least_2 = f table_width_at_least_2\n ; table_width_3 = f table_width_3\n ; lookups_per_row_3 = f lookups_per_row_3\n ; lookups_per_row_4 = f lookups_per_row_4\n ; lookup_pattern_xor = f lookup_pattern_xor\n ; lookup_pattern_range_check = f lookup_pattern_range_check\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 ; uses_lookups = f x1.uses_lookups x2.uses_lookups\n ; table_width_at_least_1 =\n f x1.table_width_at_least_1 x2.table_width_at_least_1\n ; table_width_at_least_2 =\n f x1.table_width_at_least_2 x2.table_width_at_least_2\n ; table_width_3 = f x1.table_width_3 x2.table_width_3\n ; lookups_per_row_3 = f x1.lookups_per_row_3 x2.lookups_per_row_3\n ; lookups_per_row_4 = f x1.lookups_per_row_4 x2.lookups_per_row_4\n ; lookup_pattern_xor = f x1.lookup_pattern_xor x2.lookup_pattern_xor\n ; lookup_pattern_range_check =\n f x1.lookup_pattern_range_check x2.lookup_pattern_range_check\n }\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 ; uses_lookups = Opt.Flag.No\n ; table_width_at_least_1 = Opt.Flag.No\n ; table_width_at_least_2 = Opt.Flag.No\n ; table_width_3 = Opt.Flag.No\n ; lookups_per_row_3 = Opt.Flag.No\n ; lookups_per_row_4 = Opt.Flag.No\n ; lookup_pattern_xor = Opt.Flag.No\n ; lookup_pattern_range_check = Opt.Flag.No\n }\n\n let maybe =\n { range_check0 = Opt.Flag.Maybe\n ; range_check1 = Opt.Flag.Maybe\n ; foreign_field_add = Opt.Flag.Maybe\n ; foreign_field_mul = Opt.Flag.Maybe\n ; xor = Opt.Flag.Maybe\n ; rot = Opt.Flag.Maybe\n ; lookup = Opt.Flag.Maybe\n ; runtime_tables = Opt.Flag.Maybe\n ; uses_lookups = Opt.Flag.Maybe\n ; table_width_at_least_1 = Opt.Flag.Maybe\n ; table_width_at_least_2 = Opt.Flag.Maybe\n ; table_width_3 = Opt.Flag.Maybe\n ; lookups_per_row_3 = Opt.Flag.Maybe\n ; lookups_per_row_4 = Opt.Flag.Maybe\n ; lookup_pattern_xor = Opt.Flag.Maybe\n ; lookup_pattern_range_check = Opt.Flag.Maybe\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 ; uses_lookups = false\n ; table_width_at_least_1 = false\n ; table_width_at_least_2 = false\n ; table_width_3 = false\n ; lookups_per_row_3 = false\n ; lookups_per_row_4 = false\n ; lookup_pattern_xor = false\n ; lookup_pattern_range_check = false\n }\n end\n\n [%%versioned\n module Stable = struct\n module V1 = struct\n type 'bool t =\n 'bool Mina_wire_types.Pickles_types.Plonk_types.Features.V1.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 let of_full\n ({ range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n ; uses_lookups = _\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 } :\n 'bool Full.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 to_full ~or_:( ||| ) ?(any = List.reduce_exn ~f:( ||| ))\n { range_check0\n ; range_check1\n ; foreign_field_add\n ; foreign_field_mul\n ; xor\n ; rot\n ; lookup\n ; runtime_tables\n } : _ Full.t =\n let lookup_pattern_range_check =\n (* RangeCheck, Rot gates use RangeCheck lookup pattern *)\n range_check0 ||| range_check1 ||| rot\n in\n let lookup_pattern_xor =\n (* Xor lookup pattern *)\n 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 table_width_3 ||| lookup\n in\n let table_width_at_least_1 =\n (* RangeCheck, ForeignFieldMul have max_joint_size = 1 *)\n any\n [ table_width_at_least_2\n ; 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 any [ lookup_pattern_xor; lookup_pattern_range_check; foreign_field_mul ]\n in\n let lookups_per_row_3 =\n (* Lookup has max_lookups_per_row = 3 *)\n lookups_per_row_4 ||| lookup\n in\n { uses_lookups = 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 ; 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 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 maybe =\n { range_check0 = Opt.Flag.Maybe\n ; range_check1 = Opt.Flag.Maybe\n ; foreign_field_add = Opt.Flag.Maybe\n ; foreign_field_mul = Opt.Flag.Maybe\n ; xor = Opt.Flag.Maybe\n ; rot = Opt.Flag.Maybe\n ; lookup = Opt.Flag.Maybe\n ; runtime_tables = Opt.Flag.Maybe\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 = 'a Mina_wire_types.Pickles_types.Plonk_types.Evals.V2.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 (* NB: Equivalent checks are run in-circuit below. *)\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 =\n f.xor || range_check_lookup || f.foreign_field_mul\n in\n let lookups_per_row_3 = lookups_per_row_4 || f.lookup in\n let lookups_per_row_2 = lookups_per_row_3 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 always_present =\n List.map ~f:Opt.just\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\n List.map ~f:Opt.just 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\n (* NB: Equivalent checks are done out-of-circuit above. *)\n let validate_feature_flags ~true_ ~false_ ~or_:( ||| ) ~assert_equal\n ~feature_flags:(f : 'boolean 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 opt_flag = function\n | Opt.Just _ ->\n true_\n | Opt.Maybe (b, _) ->\n b\n | Opt.Nothing ->\n false_\n in\n let enable_if x flag = assert_equal (opt_flag x) flag in\n let range_check_lookup = f.range_check0 ||| f.range_check1 ||| f.rot in\n let lookups_per_row_4 =\n f.xor ||| range_check_lookup ||| f.foreign_field_mul\n in\n let lookups_per_row_3 = lookups_per_row_4 ||| f.lookup in\n let lookups_per_row_2 = lookups_per_row_3 in\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.iteri lookup_sorted ~f:(fun i 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 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 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\n ({ uses_lookups; lookups_per_row_3; lookups_per_row_4; _ } as\n feature_flags :\n _ Features.Full.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 lookup_sorted =\n let lookups_per_row_3 = opt lookups_per_row_3 in\n let lookups_per_row_4 = opt lookups_per_row_4 in\n Vector.typ'\n [ lookups_per_row_3\n ; lookups_per_row_3\n ; lookups_per_row_3\n ; lookups_per_row_3\n ; lookups_per_row_4\n ]\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_lookups\n ; opt uses_lookups\n ; lookup_sorted\n ; opt feature_flags.runtime_tables\n ; opt feature_flags.runtime_tables\n ; opt feature_flags.lookup_pattern_xor\n ; opt feature_flags.lookup\n ; opt feature_flags.lookup_pattern_range_check\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 ( 'f\n , 'f_multi )\n Mina_wire_types.Pickles_types.Plonk_types.All_evals\n .With_public_input\n .V1\n .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 [@@@no_toplevel_latest_type]\n\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 type ('f, 'f_multi) t =\n ('f, 'f_multi) Mina_wire_types.Pickles_types.Plonk_types.All_evals.V1.t =\n { evals : ('f_multi * 'f_multi, 'f_multi * 'f_multi) With_public_input.t\n ; ft_eval1 : 'f\n }\n [@@deriving sexp, compare, yojson, hash, equal, hlist]\n\n module In_circuit = struct\n type ('f, 'f_multi, 'bool) t =\n { evals :\n ( 'f_multi * 'f_multi\n , 'f_multi * 'f_multi\n , 'bool )\n 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:f2)\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 ~num_chunks feature_flags =\n let open Impl.Typ in\n let single = array ~length:num_chunks field in\n let dummy = Array.init num_chunks ~f:(fun _ -> Impl.Field.Constant.zero) in\n let evals =\n With_public_input.typ\n (module Impl)\n feature_flags (tuple2 single single) (tuple2 single single)\n ~dummy:(dummy, dummy)\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 ( 'g\n , 'fq )\n Mina_wire_types.Pickles_types.Plonk_types.Openings.Bulletproof.V1\n .t =\n { lr : ('g * 'g) Bounded_types.ArrayN16.Stable.V1.t\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 ( 'g\n , 'fq\n , 'fqv )\n Mina_wire_types.Pickles_types.Plonk_types.Openings.V2.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 =\n { unshifted : 'g_opt Bounded_types.ArrayN16.Stable.V1.t\n ; shifted : 'g_opt\n }\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 Bounded_types.ArrayN16.Stable.V1.t\n [@@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 [@@@no_toplevel_latest_type]\n\n module V1 = struct\n type 'g t =\n 'g Mina_wire_types.Pickles_types.Plonk_types.Messages.Lookup.V1.t =\n { sorted : 'g Bounded_types.ArrayN16.Stable.V1.t\n ; aggreg : 'g\n ; runtime : 'g option\n }\n [@@deriving fields, sexp, compare, yojson, hash, equal, hlist]\n end\n end]\n\n type 'g t =\n { sorted : 'g Lookup_sorted_minus_1_vec.t\n ; sorted_5th_column : 'g option\n ; aggreg : 'g\n ; runtime : 'g option\n }\n [@@deriving fields, sexp, compare, yojson, hash, equal, hlist]\n\n module In_circuit = struct\n type ('g, 'bool) t =\n { sorted : 'g Lookup_sorted_minus_1_vec.t\n ; sorted_5th_column : ('g, 'bool) Opt.t\n ; aggreg : 'g\n ; runtime : ('g, 'bool) Opt.t\n }\n [@@deriving hlist]\n end\n\n let dummy z =\n { aggreg = z\n ; sorted = Vector.init Lookup_sorted_minus_1.n ~f:(fun _ -> z)\n ; sorted_5th_column = None\n ; runtime = None\n }\n\n let typ bool_typ e ~lookups_per_row_4 ~runtime_tables ~dummy =\n Snarky_backendless.Typ.of_hlistable\n [ Vector.typ e Lookup_sorted_minus_1.n\n ; Opt.typ bool_typ lookups_per_row_4 e ~dummy\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 ~(uses_lookup : Opt.Flag.t)\n ~(lookups_per_row_4 : Opt.Flag.t) ~(runtime_tables : Opt.Flag.t)\n ~dummy:z elt =\n Opt.typ bool_typ uses_lookup ~dummy:(dummy z)\n (typ bool_typ ~lookups_per_row_4 ~runtime_tables ~dummy:z elt)\n end\n\n [%%versioned\n module Stable = struct\n [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type 'g t = 'g Mina_wire_types.Pickles_types.Plonk_types.Messages.V2.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 type 'g 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 : 'g Without_degree_bound.t Lookup.t option\n }\n [@@deriving sexp, compare, yojson, fields, hash, equal, hlist]\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 ({ runtime_tables; uses_lookups; lookups_per_row_4; _ } :\n Opt.Flag.t Features.Full.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 ~uses_lookup:uses_lookups\n ~lookups_per_row_4 ~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 [@@@no_toplevel_latest_type]\n\n module V2 = struct\n type ('g, 'fq, 'fqv) t =\n ('g, 'fq, 'fqv) Mina_wire_types.Pickles_types.Plonk_types.Proof.V2.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]\n\n type ('g, 'fq, 'fqv) t =\n { messages : 'g Messages.t; openings : ('g, 'fq, 'fqv) Openings.t }\n [@@deriving sexp, compare, yojson, hash, equal]\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 Bounded_types.ArrayN16.Stable.V1.t\n [@@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 module Proof_cache = Proof_cache\n module Cache = Cache\n module Storables = Compile.Storables\n module Ro = Ro\n\n type chunking_data = Verify.Instance.chunking_data =\n { num_chunks : int; domain_size : int; zk_rows : int }\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 a1, ..., an can be seen as previous statements, i.e.\n\n prev_statement_1 ∈ A1, ..., prev_statement_n ∈ An\n f [ prev_statement_1; ...; prev_statement_n ] new_statement = true\n -------------------------------------------------------------------\n new_statement ∈ A\n\n In the case of a blockchain, the description of the sets A1, ..., An, A can\n be blockchain state, and f would be a function updating the state:\n\n prev_blockchain_state ∈ A\n update_blockchain_state [prev_blockchain_state] new_blockchain_state = true\n ---------------------------------------------------------------------------\n new_blockchain_state ∈ A\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 elements 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 ; length = 0\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_promise tag : t Promise.t =\n let d = Types_map.lookup_compiled tag.Tag.id in\n let%bind.Promise wrap_key = Lazy.force d.wrap_key in\n let%map.Promise wrap_vk = Lazy.force d.wrap_vk in\n let actual_wrap_domain_size =\n Common.actual_wrap_domain_size\n ~log_2_domain_size:wrap_vk.domain.log_size_of_group\n in\n ( { wrap_vk = Some wrap_vk\n ; wrap_index =\n Plonk_verification_key_evals.map wrap_key ~f:(fun x -> x.(0))\n ; max_proofs_verified =\n Pickles_base.Proofs_verified.of_nat_exn\n (Nat.Add.n d.max_proofs_verified)\n ; actual_wrap_domain_size\n }\n : t )\n\n let of_compiled tag = of_compiled_promise tag |> Promise.to_deferred\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 Plonk_types.(Features.to_full ~or_:Opt.Flag.( ||| ) feature_flags)\n ; num_chunks = 1\n ; zk_rows = 3\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, None, 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 ?storables ?proof_cache ?disk_keys\n ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ?constraint_constants ~choices () =\n compile_with_wrap_main_override_promise ?self ?cache ?storables ?proof_cache\n ?disk_keys ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ\n ~branches ~max_proofs_verified ~name ?constraint_constants ~choices ()\n\n let compile ?self ?cache ?storables ?proof_cache ?disk_keys\n ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ?constraint_constants ~choices () =\n let choices ~self =\n let choices = choices ~self in\n let rec go :\n type a b c d e f g h i j.\n (a, b, c, d, e, f, g, h, i, j) H4_6.T(Inductive_rule).t\n -> (a, b, c, d, e, f, g, h, i, j) H4_6.T(Inductive_rule.Promise).t =\n function\n | [] ->\n []\n | { identifier; prevs; main; feature_flags } :: rest ->\n { identifier\n ; prevs\n ; main = (fun x -> Promise.return (main x))\n ; feature_flags\n }\n :: go rest\n in\n go choices\n in\n let self, cache_handle, proof_module, provers =\n compile_promise ?self ?cache ?storables ?proof_cache ?disk_keys\n ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ?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 let compile_async ?self ?cache ?storables ?proof_cache ?disk_keys\n ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ?constraint_constants ~choices () =\n let choices ~self =\n let choices = choices ~self in\n let rec go :\n type a b c d e f g h i j.\n (a, b, c, d, e, f, g, h, i, j) H4_6.T(Inductive_rule.Deferred).t\n -> (a, b, c, d, e, f, g, h, i, j) H4_6.T(Inductive_rule.Promise).t =\n function\n | [] ->\n []\n | { identifier; prevs; main; feature_flags } :: rest ->\n { identifier\n ; prevs\n ; main =\n (fun x ->\n Promise.create (fun callback ->\n Deferred.don't_wait_for\n (let%map res = main x in\n callback res ) ) )\n ; feature_flags\n }\n :: go rest\n in\n go choices\n in\n let self, cache_handle, proof_module, provers =\n compile_promise ?self ?cache ?storables ?proof_cache ?disk_keys\n ?override_wrap_domain ?num_chunks ~public_input ~auxiliary_typ ~branches\n ~max_proofs_verified ~name ?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 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 ~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 Promise.return\n { Inductive_rule.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 ~choices:(fun ~self:_ ->\n [ { identifier = \"main\"\n ; prevs = []\n ; feature_flags = Plonk_types.Features.none_bool\n ; main =\n (fun _ ->\n dummy_constraints () ;\n Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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.Promise.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 Promise.return\n { Inductive_rule.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 =\n Inductive_rule.Promise.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.Proving_key.t * Dirty.t) Promise.t Lazy.t\n * (Kimchi_bindings.Protocol.VerifierIndex.Fp.t * Dirty.t) Promise.t\n 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 ; length = (* This is a dummy, it gets filled in on read/write. *) 0\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.Full.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 ~num_chunks:1\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 ~num_chunks:1\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 ~chain_to:(Promise.return ())\n (* TODO? *)\n in\n let step_domains = Vector.singleton inner_step_data.domains in\n let all_step_domains =\n let%map.Promise () =\n (* Wait for promises to resolve. *)\n Vector.fold ~init:(Promise.return ()) step_domains\n ~f:(fun acc step_domain ->\n let%bind.Promise _ = step_domain in\n acc )\n in\n Vector.map\n ~f:(fun x -> Option.value_exn @@ Promise.peek x)\n step_domains\n in\n\n let step_keypair =\n let etyp =\n Impls.Step.input ~proofs_verified:Max_proofs_verified.n\n in\n let open Impls.Step in\n let k_p =\n lazy\n (let (T (typ, _conv, conv_inv)) = etyp in\n let%bind.Promise main =\n inner_step_data.main ~step_domains:all_step_domains\n in\n let main () () =\n let%map.Promise res = main () in\n Impls.Step.with_label \"conv_inv\" (fun () -> conv_inv res)\n in\n let constraint_builder =\n Impl.constraint_system_manual ~input_typ:Typ.unit\n ~return_typ:typ\n in\n let%map.Promise res = constraint_builder.run_circuit main in\n let cs = constraint_builder.finish_computation res 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%map.Promise 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 in\n let step_vks =\n lazy\n (let _, lazy_step_vk = step_keypair in\n let%map.Promise step_vk, _ = Lazy.force lazy_step_vk in\n Vector.singleton @@ Tick.Keypair.vk_commitments step_vk )\n in\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 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 ~feature_flags () 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 (Lazy.map ~f:Promise.return disk_key_prover)\n (Lazy.map ~f:Promise.return disk_key_verifier) )\n in\n (r, disk_key_verifier)\n in\n let wrap_vk = Lazy.map wrap_vk ~f:(Promise.map ~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%bind.Promise step_pk = Lazy.force step_pk in\n let%bind.Promise 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) ~proof_cache:None\n ~maxes:(module Maxes)\n ~auxiliary_typ:Impls.Step.Typ.unit\n ~step_domains:all_step_domains\n ~self_dlog_plonk_index:\n ((* TODO *) Plonk_verification_key_evals.map\n ~f:(fun x -> [| x |])\n wrap_vk.commitments )\n () (fst step_pk) wrap_vk.index\n in\n let%bind.Promise pairing_vk, _ = Lazy.force step_vk in\n let wrap =\n let wrap_vk = Lazy.force wrap_vk in\n let%bind.Promise proof, (), (), _ = step () 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 : _ Impls.Step.statement =\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 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_with_public_evals 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%bind.Promise 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.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 ~zk_rows:3\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.proof.openings.evals\n ; public_input =\n (let x1, x2 = x_hat in\n ([| x1 |], [| x2 |]) )\n }\n ~r ~xi ~zeta ~zetaw\n ~old_bulletproof_challenges:prev_challenges\n ~env:tick_env ~domain:tick_domain\n ~ft_eval1:proof.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 ; joint_combiner = Opt.nothing\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)) =\n Impls.Wrap.input ~feature_flags ()\n 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 joint_combiner = None\n }\n }\n }\n } )\n in\n ( { proof = Wrap_wire_proof.of_kimchi_proof next_proof.proof\n ; statement =\n Types.Wrap.Statement.to_minimal\n ~to_option:Opt.to_option next_statement\n ; prev_evals =\n { Plonk_types.All_evals.evals =\n { public_input =\n (let x1, x2 = x_hat in\n ([| x1 |], [| x2 |]) )\n ; evals = proof.proof.openings.evals\n }\n ; ft_eval1 = proof.proof.openings.ft_eval1\n }\n }\n : _ P.Base.Wrap.t )\n in\n let%bind.Promise wrap_pk = Lazy.force wrap_pk in\n let%bind.Promise wrap_vk = wrap_vk in\n wrap ~max_proofs_verified:Max_proofs_verified.n\n full_signature.maxes\n ~dlog_plonk_index:\n ((* TODO *) Plonk_verification_key_evals.map\n ~f:(fun x -> [| x |])\n 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 (fst wrap_pk) 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 =\n Lazy.map wrap_vk\n ~f:\n (Promise.map ~f:(fun x ->\n (* TODO *)\n Plonk_verification_key_evals.map\n ~f:(fun x -> [| x |])\n (Verification_key.commitments x) ) )\n ; wrap_vk =\n Lazy.map wrap_vk ~f:(Promise.map ~f:Verification_key.index)\n ; wrap_domains\n ; step_domains\n ; num_chunks = 1\n ; zk_rows = 3\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 let%bind.Promise verification_key = Lazy.force verification_key in\n verify_promise\n (module Max_proofs_verified)\n (module A_value)\n verification_key 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\"\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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n No_recursion.tag\n in\n step\n ~handler:\n (handler No_recursion.example_input\n (Side_loaded.Proof.of_proof\n No_recursion.example_proof )\n vk )\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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n Fake_1_recursion.tag\n in\n step\n ~handler:\n (handler Fake_1_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_1_recursion.example_proof )\n vk )\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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n Fake_2_recursion.tag\n in\n step\n ~handler:\n (handler Fake_2_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_2_recursion.example_proof )\n vk )\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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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 ~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 Promise.return\n { Inductive_rule.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.(map none ~f:(fun _ -> 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 ~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 Promise.return\n { Inductive_rule.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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n No_recursion.tag\n in\n step\n ~handler:\n (handler No_recursion.example_input\n (Side_loaded.Proof.of_proof\n No_recursion.example_proof )\n vk )\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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n Fake_1_recursion.tag\n in\n step\n ~handler:\n (handler Fake_1_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_1_recursion.example_proof )\n vk )\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 let%bind.Promise vk =\n Side_loaded.Verification_key.of_compiled_promise\n Fake_2_recursion.tag\n in\n step\n ~handler:\n (handler Fake_2_recursion.example_input\n (Side_loaded.Proof.of_proof\n Fake_2_recursion.example_proof )\n vk )\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 'comm Mina_wire_types.Pickles_types.Plonk_verification_key_evals.V2.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\nmodule Step = struct\n type ('comm, 'opt_comm) t =\n { sigma_comm : 'comm Plonk_types.Permuts_vec.t\n ; coefficients_comm : 'comm Plonk_types.Columns_vec.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 ; xor_comm : 'opt_comm\n ; range_check0_comm : 'opt_comm\n ; range_check1_comm : 'opt_comm\n ; foreign_field_add_comm : 'opt_comm\n ; foreign_field_mul_comm : 'opt_comm\n ; rot_comm : 'opt_comm\n ; lookup_table_comm : 'opt_comm Plonk_types.Lookup_sorted_minus_1_vec.t\n ; lookup_table_ids : 'opt_comm\n ; runtime_tables_selector : 'opt_comm\n ; lookup_selector_lookup : 'opt_comm\n ; lookup_selector_xor : 'opt_comm\n ; lookup_selector_range_check : 'opt_comm\n ; lookup_selector_ffmul : 'opt_comm\n }\n [@@deriving sexp, equal, compare, hash, yojson, hlist, fields]\n\n let 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 ; xor_comm\n ; range_check0_comm\n ; range_check1_comm\n ; foreign_field_add_comm\n ; foreign_field_mul_comm\n ; rot_comm\n ; lookup_table_comm\n ; lookup_table_ids\n ; runtime_tables_selector\n ; lookup_selector_lookup\n ; lookup_selector_xor\n ; lookup_selector_range_check\n ; lookup_selector_ffmul\n } ~f ~f_opt =\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 ; xor_comm = f_opt xor_comm\n ; range_check0_comm = f_opt range_check0_comm\n ; range_check1_comm = f_opt range_check1_comm\n ; foreign_field_add_comm = f_opt foreign_field_add_comm\n ; foreign_field_mul_comm = f_opt foreign_field_mul_comm\n ; rot_comm = f_opt rot_comm\n ; lookup_table_comm = Vector.map ~f:f_opt lookup_table_comm\n ; lookup_table_ids = f_opt lookup_table_ids\n ; runtime_tables_selector = f_opt runtime_tables_selector\n ; lookup_selector_lookup = f_opt lookup_selector_lookup\n ; lookup_selector_xor = f_opt lookup_selector_xor\n ; lookup_selector_range_check = f_opt lookup_selector_range_check\n ; lookup_selector_ffmul = f_opt lookup_selector_ffmul\n }\n\n let map2 t1 t2 ~f ~f_opt =\n { sigma_comm = Vector.map2 ~f t1.sigma_comm t2.sigma_comm\n ; coefficients_comm =\n 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 ; xor_comm = f_opt t1.xor_comm t2.xor_comm\n ; range_check0_comm = f_opt t1.range_check0_comm t2.range_check0_comm\n ; range_check1_comm = f_opt t1.range_check1_comm t2.range_check1_comm\n ; foreign_field_add_comm =\n f_opt t1.foreign_field_add_comm t2.foreign_field_add_comm\n ; foreign_field_mul_comm =\n f_opt t1.foreign_field_mul_comm t2.foreign_field_mul_comm\n ; rot_comm = f_opt t1.rot_comm t2.rot_comm\n ; lookup_table_comm =\n Vector.map2 ~f:f_opt t1.lookup_table_comm t2.lookup_table_comm\n ; lookup_table_ids = f_opt t1.lookup_table_ids t2.lookup_table_ids\n ; runtime_tables_selector =\n f_opt t1.runtime_tables_selector t2.runtime_tables_selector\n ; lookup_selector_lookup =\n f_opt t1.lookup_selector_lookup t2.lookup_selector_lookup\n ; lookup_selector_xor = f_opt t1.lookup_selector_xor t2.lookup_selector_xor\n ; lookup_selector_range_check =\n f_opt t1.lookup_selector_range_check t2.lookup_selector_range_check\n ; lookup_selector_ffmul =\n f_opt t1.lookup_selector_ffmul t2.lookup_selector_ffmul\n }\n\n let typ g g_opt =\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 ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\n ; Vector.typ g_opt Plonk_types.Lookup_sorted_minus_1.n\n ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\n ; g_opt\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 forget_optional_commitments\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 ; xor_comm = _\n ; range_check0_comm = _\n ; range_check1_comm = _\n ; foreign_field_add_comm = _\n ; foreign_field_mul_comm = _\n ; rot_comm = _\n ; lookup_table_comm = _\n ; lookup_table_ids = _\n ; runtime_tables_selector = _\n ; lookup_selector_lookup = _\n ; lookup_selector_xor = _\n ; lookup_selector_range_check = _\n ; lookup_selector_ffmul = _\n } : _ Stable.Latest.t =\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 }\nend\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","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 (* to prevent giving a reference to the internal state *)\n let copy x = (P.copy [| x |]).(0) in\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 copy t.state.(0) )\n else (\n t.sponge_state <- Squeezed (n + 1) ;\n copy t.state.(n) )\n | Absorbed _ ->\n t.state <- block_cipher t.params t.state ;\n t.sponge_state <- Squeezed 1 ;\n copy 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\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\ntype '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\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, hash, equal]\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 with_public_evals =\n (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.proof_with_public\n\n type t = (Curve.Affine.Backend.t, Scalar_field.t) Kimchi_types.prover_proof\n\n val create :\n Index.t\n -> primary:Scalar_field.Vector.t\n -> auxiliary:Scalar_field.Vector.t\n -> prev_chals:Scalar_field.t array\n -> prev_comms:Curve.Affine.Backend.t array\n -> with_public_evals\n\n val create_async :\n Index.t\n -> primary:Scalar_field.Vector.t\n -> auxiliary:Scalar_field.Vector.t\n -> prev_chals:Scalar_field.t array\n -> prev_comms:Curve.Affine.Backend.t array\n -> with_public_evals Promise.t\n\n val verify : Verifier_index.t -> with_public_evals -> bool\n\n val batch_verify :\n Verifier_index.t array -> with_public_evals 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 =\n { challenges : 'fq Bounded_types.ArrayN16.Stable.V1.t; 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 Bounded_types.ArrayN16.Stable.V1.t )\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 Bounded_types.ArrayN16.Stable.V1.t )\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.Stable.Latest 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 module T = struct\n type t = (G.Affine.t, Fq.t, Fq.t array) Pickles_types.Plonk_types.Proof.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.t\n -> openings:\n (G.Affine.t, Fq.t, Fq.t array) Pickles_types.Plonk_types.Openings.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 struct\n include Allocation_functor.Make.Basic (T)\n include Allocation_functor.Make.Partial.Sexp (T)\n include Allocation_functor.Make.Partial.Yojson (T)\n end :\n sig\n include\n Allocation_functor.Intf.Output.Basic_intf\n with type t := t\n and type 'a creator := 'a creator\n\n include\n Allocation_functor.Intf.Output.Sexp_intf\n with type t := t\n and type 'a creator := 'a creator\n\n include\n Allocation_functor.Intf.Output.Yojson_intf\n with type t := t\n and type 'a creator := 'a creator\n end )\n\n type with_public_evals =\n { proof : t\n ; public_evals : (Scalar_field.t array * Scalar_field.t array) option\n }\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\n 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 evals_to_tuple ({ zeta; zeta_omega } : _ Kimchi_types.point_evaluations) =\n (zeta, zeta_omega)\n\n let of_backend (t : Backend.t) : t =\n let proof = opening_proof_of_backend_exn t.proof in\n let evals =\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 =\n Vector.init\n Pickles_types.Plonk_types.Lookup_sorted_minus_1.n\n ~f:(fun i -> wo l.sorted.(i))\n ; sorted_5th_column =\n (* TODO: This is ugly and error-prone *)\n Option.try_with (fun () ->\n wo\n l.sorted.(Nat.to_int\n Pickles_types.Plonk_types\n .Lookup_sorted_minus_1\n .n) )\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 of_backend_with_public_evals (t : Backend.with_public_evals) :\n with_public_evals =\n { proof = of_backend t.proof\n ; public_evals = Option.map ~f:evals_to_tuple t.public_evals\n }\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 evals_of_tuple (zeta, zeta_omega) : _ Kimchi_types.point_evaluations =\n { zeta; zeta_omega }\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 { 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 =\n Array.map ~f:pcwo\n (Array.append (Vector.to_array t.sorted)\n (Option.to_array t.sorted_5th_column) )\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 to_backend_with_public_evals' (chal_polys : Challenge_polynomial.t list)\n primary_input ({ proof; public_evals } : with_public_evals) :\n Backend.with_public_evals =\n { proof = to_backend' chal_polys primary_input proof\n ; public_evals = Option.map ~f:evals_of_tuple public_evals\n }\n\n let to_backend_with_public_evals chal_polys primary_input t =\n to_backend_with_public_evals' chal_polys (List.to_array primary_input) t\n\n (* Extract challenges and commitments from the (optional) message *)\n let extract_challenges_and_commitments ~message =\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 (challenges, commitments)\n\n let create ?message pk ~primary ~auxiliary =\n let prev_chals, prev_comms = extract_challenges_and_commitments ~message in\n let res = Backend.create pk ~primary ~auxiliary ~prev_chals ~prev_comms in\n of_backend_with_public_evals res\n\n let create_async ?message pk ~primary ~auxiliary =\n let prev_chals, prev_comms = extract_challenges_and_commitments ~message in\n let%map.Promise res =\n Backend.create_async pk ~primary ~auxiliary ~prev_chals ~prev_comms\n in\n of_backend_with_public_evals res\n\n let batch_verify' (conv : 'a -> Fq.t array)\n (ts : (Verifier_index.t * with_public_evals * 'a * message option) list) =\n let logger = 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 =\n to_backend_with_public_evals'\n (Option.value ~default:[] m)\n (conv xs) t\n 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_with_public_evals'\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 compare : t -> t -> int\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 let zero = of_int 0 in\n let one = of_int 1 in\n fun n ->\n if equal n zero then Bignum_bigint.zero\n else if equal n one then Bignum_bigint.one\n else\n Bytes.unsafe_to_string\n ~no_mutation_while_string_reachable:(to_bytes n)\n |> Z.of_bits |> Bignum_bigint.of_zarith_bigint\n\n let hash_fold_t s x = Bignum_bigint.hash_fold_t s (to_bignum_bigint x)\n\n let hash = Hash.of_fold hash_fold_t\n\n let compare = compare\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 | AddFixedLookupTable of { id : int32; data : 'f array array }\n | AddRuntimeTableCfg of { id : int32; first_column : 'f array }\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 | AddFixedLookupTable { id; data } ->\n (* TODO: see a possible better API -\n https://github.com/MinaProtocol/mina/issues/13984 *)\n AddFixedLookupTable { id; data }\n | AddRuntimeTableCfg { id; first_column } ->\n AddRuntimeTableCfg { id; first_column }\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 equal zero res\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\ntype 'f fixed_lookup_tables =\n | Unfinalized_fixed_lookup_tables_rev of 'f Kimchi_types.lookup_table list\n | Compiled_fixed_lookup_tables of 'f Kimchi_types.lookup_table array\n\ntype 'f runtime_tables_cfg =\n | Unfinalized_runtime_tables_cfg_rev of 'f Kimchi_types.runtime_table_cfg list\n | Compiled_runtime_tables_cfg of 'f Kimchi_types.runtime_table_cfg array\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 (* Witnesses values corresponding to each runtime lookups *)\n ; mutable runtime_lookups_rev : (V.t * (V.t * V.t)) list\n (* The user-provided lookup tables associated with this circuit. *)\n ; mutable fixed_lookup_tables : 'f fixed_lookup_tables\n (* The user-provided runtime table configurations associated with this\n circuit. *)\n ; mutable runtime_tables_cfg : 'f runtime_tables_cfg\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\nlet get_concatenated_fixed_lookup_table_size sys =\n match sys.fixed_lookup_tables with\n | Unfinalized_fixed_lookup_tables_rev _ ->\n failwith\n \"Cannot get the fixed lookup tables before finalizing the constraint \\\n system\"\n | Compiled_fixed_lookup_tables flts ->\n let get_table_size (flt : _ Kimchi_types.lookup_table) =\n if Array.length flt.data = 0 then 0\n else Array.length (Array.get flt.data 0)\n in\n Array.fold_left (fun acc flt -> acc + get_table_size flt) 0 flts\n\nlet get_concatenated_runtime_lookup_table_size sys =\n match sys.runtime_tables_cfg with\n | Unfinalized_runtime_tables_cfg_rev _ ->\n failwith\n \"Cannot get the runtime table configurations before finalizing the \\\n constraint system\"\n | Compiled_runtime_tables_cfg rt_cfgs ->\n Array.fold_left\n (fun acc (rt_cfg : _ Kimchi_types.runtime_table_cfg) ->\n acc + Array.length rt_cfg.first_column )\n 0 rt_cfgs\n\nlet finalize_fixed_lookup_tables sys =\n match sys.fixed_lookup_tables with\n | Unfinalized_fixed_lookup_tables_rev fixed_lt_rev ->\n sys.fixed_lookup_tables <-\n Compiled_fixed_lookup_tables\n (Core_kernel.Array.of_list_rev fixed_lt_rev)\n | Compiled_fixed_lookup_tables _ ->\n failwith \"Fixed lookup tables have already been finalized\"\n\nlet finalize_runtime_lookup_tables sys =\n match sys.runtime_tables_cfg with\n | Unfinalized_runtime_tables_cfg_rev rt_cfgs_rev ->\n sys.runtime_tables_cfg <-\n Compiled_runtime_tables_cfg (Core_kernel.Array.of_list_rev rt_cfgs_rev)\n | Compiled_runtime_tables_cfg _ ->\n failwith \"Runtime table configurations have already been finalized\"\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 get_concatenated_fixed_lookup_table_size : t -> int\n\n val get_concatenated_runtime_lookup_table_size : t -> int\n\n (** Finalize the fixed lookup tables. The function can not be called twice *)\n val finalize_fixed_lookup_tables : t -> unit\n\n (** Finalize the runtime lookup table configurations. The function can not be\n called twice. *)\n val finalize_runtime_lookup_tables : t -> unit\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 :\n t\n -> (int -> Fp.t)\n -> Fp.t array array * Fp.t Kimchi_types.runtime_table array\n\n val finalize : t -> unit\n\n val finalize_and_get_gates :\n t\n -> Gates.t\n * Fp.t Kimchi_types.lookup_table array\n * Fp.t Kimchi_types.runtime_table_cfg array\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 (* Used by compute_witness to build the runtime tables from the Lookup\n constraint *)\n module MapRuntimeTable = struct\n module T = struct\n type t = int32 * Fp.t [@@deriving hash, sexp, compare]\n end\n\n include T\n include Core_kernel.Hashable.Make (T)\n end\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 * Fp.t Kimchi_types.runtime_table 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\n let map_runtime_tables = MapRuntimeTable.Table.create () in\n let runtime_tables : Fp.t Kimchi_types.runtime_table array =\n match sys.runtime_tables_cfg with\n | Unfinalized_runtime_tables_cfg_rev _ ->\n failwith\n \"Attempted to generate a witness for an unfinalized constraint \\\n system\"\n | Compiled_runtime_tables_cfg cfgs ->\n Array.mapi cfgs ~f:(fun rt_idx { Kimchi_types.id; first_column } ->\n let data =\n Array.mapi first_column ~f:(fun i v ->\n ignore\n (* `add` leaves the value unchanged if the index has been\n already used. Therefore, it keeps the first value.\n This handles the case that the first column has\n duplicated index values.\n *)\n @@ MapRuntimeTable.Table.add map_runtime_tables ~key:(id, v)\n ~data:(i, rt_idx) ;\n (* default padding value for lookup *)\n Fp.zero )\n in\n let rt : Fp.t Kimchi_types.runtime_table = { id; data } in\n rt )\n in\n\n (* Fill in the used entries of the runtime lookup tables. *)\n List.iter (List.rev sys.runtime_lookups_rev) ~f:(fun (id, (idx, v)) ->\n let compute_value x = compute ([ (Fp.one, x) ], None) in\n let vid = compute_value id in\n let vidx = compute_value idx in\n let vv = compute_value v in\n (* FIXME: we should have a int32 here. We are not sure the ID will be a\n int32. We should enforce that.\n See https://github.com/MinaProtocol/mina/issues/13955\n *)\n let id_int32 = Int32.of_string @@ Fp.to_string vid in\n (* Using find allows to handle fixed lookup tables\n As the map has been built from the runtime table configurations,\n except in the case that a runtime table and a fixed table shares the\n same ID, the lookups in fixed lookup tables will return None.\n See https://github.com/MinaProtocol/mina/issues/14016\n *)\n let v =\n MapRuntimeTable.Table.find map_runtime_tables (id_int32, vidx)\n in\n if Option.is_some v then\n let i, rt_idx = Option.value_exn v in\n let rt = runtime_tables.(rt_idx) in\n (* Important note: we do not check if the value has been set before.\n Therefore, it will always use the latest value *)\n rt.data.(i) <- vv ) ;\n (* Return the witness. *)\n (res, runtime_tables)\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 ; runtime_lookups_rev = []\n ; fixed_lookup_tables = Unfinalized_fixed_lookup_tables_rev []\n ; runtime_tables_cfg = Unfinalized_runtime_tables_cfg_rev []\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 let get_concatenated_fixed_lookup_table_size (sys : t) =\n get_concatenated_fixed_lookup_table_size sys\n\n let get_concatenated_runtime_lookup_table_size (sys : t) =\n get_concatenated_runtime_lookup_table_size sys\n\n let finalize_fixed_lookup_tables = finalize_fixed_lookup_tables\n\n let finalize_runtime_lookup_tables = finalize_runtime_lookup_tables\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 ; fixed_lookup_tables = Compiled_fixed_lookup_tables fixed_lookup_tables\n ; runtime_tables_cfg = Compiled_runtime_tables_cfg runtime_tables_cfg\n ; _\n } ->\n (gates, fixed_lookup_tables, runtime_tables_cfg)\n (* Finalizing lookup tables and runtime table cfgs first *)\n | { fixed_lookup_tables = Unfinalized_fixed_lookup_tables_rev _; _ } ->\n finalize_fixed_lookup_tables sys ;\n finalize_and_get_gates sys\n | { runtime_tables_cfg = Unfinalized_runtime_tables_cfg_rev _; _ } ->\n finalize_runtime_lookup_tables sys ;\n finalize_and_get_gates sys\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 ; fixed_lookup_tables = Compiled_fixed_lookup_tables fixed_lookup_tables\n ; runtime_tables_cfg = Compiled_runtime_tables_cfg runtime_tables_cfg\n ; _\n } ->\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, fixed_lookup_tables, runtime_tables_cfg)\n\n (** Calls [finalize_and_get_gates] and ignores the result. *)\n let finalize t =\n ignore\n ( finalize_and_get_gates t\n : Gates.t\n * Fp.t Kimchi_types.lookup_table array\n * Fp.t Kimchi_types.runtime_table_cfg array )\n\n let num_constraints sys =\n let gates, _, _ = finalize_and_get_gates sys in\n Gates.len gates\n\n let to_json (sys : t) : string =\n (* TODO: add lookup tables and runtime table cfgs *)\n (* https://github.com/MinaProtocol/mina/issues/13886 *)\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 ~equal\n ~one)\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 (* -s*x + s^2*x*x = 0 *)\n add_generic_constraint ~l:x ~r:x\n [| Fp.negate s; Fp.zero; Fp.zero; Fp.square s; 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 (* table ID *)\n let red_w0 = reduce_to_v w0 in\n (* idx1 *)\n let red_w1 = reduce_to_v w1 in\n (* v1 *)\n let red_w2 = reduce_to_v w2 in\n (* idx2 *)\n let red_w3 = reduce_to_v w3 in\n (* v2 *)\n let red_w4 = reduce_to_v w4 in\n (* idx3 *)\n let red_w5 = reduce_to_v w5 in\n (* v3 *)\n let red_w6 = reduce_to_v w6 in\n let vars =\n [| Some red_w0\n ; Some red_w1\n ; Some red_w2\n ; Some red_w3\n ; Some red_w4\n ; Some red_w5\n ; Some red_w6\n |]\n in\n let lookup1 = (red_w0, (red_w1, red_w2)) in\n let lookup2 = (red_w0, (red_w3, red_w4)) in\n let lookup3 = (red_w0, (red_w5, red_w6)) in\n (* We populate with the first lookup. In the case the user uses the same\n index multiple times, the last value will be used *)\n sys.runtime_lookups_rev <-\n lookup3 :: lookup2 :: lookup1 :: sys.runtime_lookups_rev ;\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 (AddFixedLookupTable { id; data }) -> (\n match sys.fixed_lookup_tables with\n | Unfinalized_fixed_lookup_tables_rev fixed_lookup_tables ->\n let lt : Fp.t Kimchi_types.lookup_table list =\n { id; data } :: fixed_lookup_tables\n in\n sys.fixed_lookup_tables <- Unfinalized_fixed_lookup_tables_rev lt\n | Compiled_fixed_lookup_tables _ ->\n failwith\n \"Trying to add a fixed lookup tables when it has been already \\\n finalized\" )\n | Plonk_constraint.T (AddRuntimeTableCfg { id; first_column }) -> (\n match sys.runtime_tables_cfg with\n | Unfinalized_runtime_tables_cfg_rev runtime_tables_cfg ->\n let rt_cfg : Fp.t Kimchi_types.runtime_table_cfg list =\n { id; first_column } :: runtime_tables_cfg\n in\n sys.runtime_tables_cfg <- Unfinalized_runtime_tables_cfg_rev rt_cfg\n | Compiled_runtime_tables_cfg _ ->\n failwith\n \"Trying to add a runtime table configuration it has been \\\n already finalized\" )\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 type with_public_evals =\n ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.proof_with_public\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:backend_create (pk : Keypair.t) primary auxiliary\n prev_chals 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, runtime_tables =\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 backend_create pk.index witness_cols runtime_tables prev_chals prev_comms\n\n let create_async (pk : Keypair.t) ~primary ~auxiliary ~prev_chals\n ~prev_comms =\n create_aux pk primary auxiliary prev_chals prev_comms\n ~f:(fun index witness runtime_tables prev_chals prev_sgs ->\n Promise.run_in_thread (fun () ->\n Kimchi_bindings.Protocol.Proof.Fp.create index witness\n runtime_tables prev_chals 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\n ~f:Kimchi_bindings.Protocol.Proof.Fp.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\n let create_with_public_evals = with_lagrange create_with_public_evals\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 type with_public_evals =\n ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.proof_with_public\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:backend_create (pk : Keypair.t) ~primary ~auxiliary\n ~prev_chals ~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, runtime_tables =\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 backend_create pk.index witness_cols runtime_tables prev_chals prev_comms\n\n let create_async (pk : Keypair.t) ~primary ~auxiliary ~prev_chals\n ~prev_comms =\n create_aux pk ~primary ~auxiliary ~prev_chals ~prev_comms\n ~f:(fun index witness runtime_tables prev_chals prev_sgs ->\n Promise.run_in_thread (fun () ->\n Kimchi_bindings.Protocol.Proof.Fq.create index witness\n runtime_tables prev_chals 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\n ~f:Kimchi_bindings.Protocol.Proof.Fq.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\n let create_with_public_evals = with_lagrange create_with_public_evals\n end\nend)\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_exn (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 raise\n (Invalid_argument\n (Printf.sprintf \"Proofs_verified.of_nat: got %d\" (to_int n)) )\n\nlet of_int_exn (n : int) : t =\n match n with\n | 0 ->\n N0\n | 1 ->\n N1\n | 2 ->\n N2\n | _ ->\n raise\n (Invalid_argument (Printf.sprintf \"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\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 = 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\n module In_circuit = 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, 'bool) Opt.t\n ; feature_flags : 'bool Plonk_types.Features.t\n }\n end\n end\n\n open Pickles_types\n\n module In_circuit = struct\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 , 'scalar_challenge_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 ; joint_combiner : 'scalar_challenge_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 ; joint_combiner = Opt.map ~f:scalar t.joint_combiner\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)\n (module Impl : Snarky_backendless.Snark_intf.Run\n with type field = f ) ~dummy_scalar_challenge ~challenge\n ~scalar_challenge ~bool\n ~feature_flags:\n ({ Plonk_types.Features.Full.uses_lookups; _ } as 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 ; Plonk_types.Features.typ\n ~feature_flags:(Plonk_types.Features.of_full feature_flags)\n bool\n ; Opt.typ Impl.Boolean.typ uses_lookups\n ~dummy:dummy_scalar_challenge\n (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 ) ~(to_option : lookup_opt -> scalar_challenge 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 = to_option t.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_challenge ~challenge ~scalar_challenge ~feature_flags\n (fp : (fp, _, f) Snarky_backendless.Typ.t) index =\n Snarky_backendless.Typ.of_hlistable\n [ Plonk.In_circuit.typ impl ~dummy_scalar_challenge ~challenge\n ~scalar_challenge ~bool:Impl.Boolean.typ ~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_challenge ~challenge ~scalar_challenge ~feature_flags\n (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_challenge\n ~challenge ~scalar_challenge ~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 | Opt.Flag.Yes ->\n constant true\n | Opt.Flag.No ->\n constant false\n | 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 ; joint_combiner\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 =\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 joint_combiner ~f:(fun x -> Hlist.HlistId.[ x ])\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 ; joint_combiner\n ] ~option_map : _ 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 ; joint_combiner =\n option_map joint_combiner ~f:(fun Hlist.HlistId.[ x ] ->\n x )\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 ; joint_combiner = 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 ; joint_combiner\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 joint_combiner ;\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) _ ~challenge ~scalar_challenge\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 =\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 ) ~assert_16_bits\n (proofs_verified : (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 _ = Per_proof.typ impl fq ~assert_16_bits 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_zk_rows : 'a\n ; zeta_to_n_minus_1 : 'a\n ; zeta_to_srs_length : 'a Lazy.t\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_zero_knowledge_and_previous_rows : 'a\n ; joint_combiner : 'a\n ; beta : 'a\n ; gamma : 'a\n ; unnormalized_lagrange_basis : bool * 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_zk_rows = _\n ; zeta_to_n_minus_1 = _\n ; zeta_to_srs_length = _\n ; srs_length_log2 = _\n ; vanishes_on_zero_knowledge_and_previous_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_zero_knowledge_and_previous_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 (false, 0)\n * ( cell (var (LookupAggreg, Curr))\n - field\n \"0x0000000000000000000000000000000000000000000000000000000000000001\"\n ) )\n + alpha_pow 26\n * ( unnormalized_lagrange_basis (true, -1)\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 (true, -1)\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 (false, 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 (true, -1)\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 (false, 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_zk_rows = _\n ; zeta_to_n_minus_1 = _\n ; zeta_to_srs_length = _\n ; srs_length_log2 = _\n ; vanishes_on_zero_knowledge_and_previous_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","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 { state_hash : string\n ; blockchain_length : int\n ; global_slot_since_genesis : 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\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 ; length : int\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 ; length = 4096\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 assocs\n | json ->\n `Assoc [ (\"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\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 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 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)\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 = Kimchi_pasta_basic.poseidon_params_fp\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\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\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\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)) =\n Impls.Wrap.input ~feature_flags:Plonk_types.Features.Full.maybe ()\n 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 ; xor_comm = None\n ; range_check0_comm = None\n ; range_check1_comm = None\n ; foreign_field_add_comm = None\n ; foreign_field_mul_comm = None\n ; rot_comm = None\n } )\n ; shifts = Common.tock_shifts ~log2_size\n ; lookup_index = None\n ; zk_rows = 3\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 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.with_public_evals\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 { 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 Bounded_types.ArrayN16.Stable.V1.t )\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 (* NB: This should be on the *serialized type*. However, the actual\n serialized type [Repr.t] is hidden by this module, so this alias is\n effectively junk anyway..\n *)\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 ( 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.default ~num_chunks:1 (* TODO *) 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 (let evals = Lazy.force Dummy.evals in\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 = evals.evals.evals\n ; ft_eval1 = evals.ft_eval1\n } )\n }\n ; prev_evals =\n (let e =\n Plonk_types.Evals.map Evaluation_lengths.default ~f:(fun n ->\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.Stable.V2.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 { statement; prev_evals; proof }) : Repr.t =\n let lte =\n Nat.lte_exn\n (Vector.length\n statement.messages_for_next_step_proof\n .challenge_polynomial_commitments )\n W.n\n in\n let statement =\n { statement with\n messages_for_next_step_proof =\n { statement.messages_for_next_step_proof with\n challenge_polynomial_commitments =\n At_most.of_vector\n statement.messages_for_next_step_proof\n .challenge_polynomial_commitments lte\n ; old_bulletproof_challenges =\n At_most.of_vector\n statement.messages_for_next_step_proof\n .old_bulletproof_challenges lte\n }\n }\n in\n let prev_evals : _ Plonk_types.All_evals.Stable.V1.t =\n { evals =\n { prev_evals.evals with\n public_input =\n (let x1, x2 = prev_evals.evals.public_input in\n (x1.(0), x2.(0)) )\n }\n ; ft_eval1 = prev_evals.ft_eval1\n }\n in\n { statement; prev_evals; proof }\n\n let of_repr ({ statement; prev_evals; proof } : Repr.t) : t =\n let (Vector.T challenge_polynomial_commitments) =\n At_most.to_vector\n statement.messages_for_next_step_proof.challenge_polynomial_commitments\n in\n let (Vector.T old_bulletproof_challenges) =\n At_most.to_vector\n 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 let statement =\n { statement with\n messages_for_next_step_proof =\n { statement.messages_for_next_step_proof with\n challenge_polynomial_commitments\n ; old_bulletproof_challenges\n }\n }\n in\n let prev_evals : _ Plonk_types.All_evals.t =\n { evals =\n { public_input =\n (let x1, x2 = prev_evals.evals.public_input in\n ([| x1 |], [| x2 |]) )\n ; evals = prev_evals.evals.evals\n }\n ; ft_eval1 = prev_evals.ft_eval1\n }\n in\n T { statement; prev_evals; proof }\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 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 x = to_repr x\n\n let of_binable x = of_repr x\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 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 x = to_repr x\n\n let of_binable x = of_repr x\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 = Kimchi_pasta_basic.poseidon_params_fq\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 (* 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 ('comm, 'comm_opt) index' =\n ('comm, 'comm_opt) Plonk_verification_key_evals.Step.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 array, (Inner_curve.t array, Boolean.var) Opt.t) index'\n , n )\n Vector.t\n -> (Inner_curve.t array, (Inner_curve.t array, Boolean.var) Opt.t) index'\n =\n let open Tuple_lib 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 ->\n Plonk_verification_key_evals.Step.map key\n ~f:(Array.map ~f:(fun g -> Double.map g ~f:(( * ) (b :> t))))\n ~f_opt:(function\n (* Here, we split the 3 variants into 3 separate accumulators. This\n allows us to only compute the 'maybe' flag when we need to, and\n allows us to fall back to the basically-free `Nothing` when a\n feature is entirely unused, or to the less expensive `Just` if\n it is used for every circuit.\n In particular, it is important that we generate exactly\n `Nothing` when none of the optional gates are used, otherwise\n we will change the serialization of the protocol circuits.\n *)\n | Opt.Nothing ->\n ([], [], [ b ])\n | Opt.Maybe (b_x, x) ->\n ([], [ (b, b_x, x) ], [])\n | Opt.Just x ->\n ([ (b, x) ], [], []) ) )\n |> Vector.reduce_exn\n ~f:\n (Plonk_verification_key_evals.Step.map2\n ~f:(Array.map2_exn ~f:(Double.map2 ~f:( + )))\n ~f_opt:(fun (yes_1, maybe_1, no_1) (yes_2, maybe_2, no_2) ->\n (yes_1 @ yes_2, maybe_1 @ maybe_2, no_1 @ no_2) ) )\n |> Plonk_verification_key_evals.Step.map ~f:Fn.id ~f_opt:(function\n | [], [], _nones ->\n (* We only have `Nothing`s, so we can emit exactly `Nothing`\n without further computation.\n *)\n Opt.Nothing\n | justs, [], [] ->\n (* Special case: we don't need to compute the 'maybe' bool\n because we know statically that all entries are `Just`.\n *)\n let sum =\n justs\n |> List.map ~f:(fun ((b : Boolean.var), g) ->\n Array.map g ~f:(Double.map ~f:(( * ) (b :> t))) )\n |> List.reduce_exn\n ~f:(Array.map2_exn ~f:(Double.map2 ~f:( + )))\n in\n Opt.just sum\n | justs, maybes, nones ->\n let is_none =\n List.reduce nones\n ~f:(fun (b1 : Boolean.var) (b2 : Boolean.var) ->\n Boolean.Unsafe.of_cvar Field.(add (b1 :> t) (b2 :> t)) )\n in\n let none_sum =\n let num_chunks = (* TODO *) 1 in\n Option.map is_none ~f:(fun (b : Boolean.var) ->\n Array.init num_chunks ~f:(fun _ ->\n Double.map Inner_curve.one ~f:(( * ) (b :> t)) ) )\n in\n let just_is_yes, just_sum =\n justs\n |> List.map ~f:(fun ((b : Boolean.var), g) ->\n (b, Array.map g ~f:(Double.map ~f:(( * ) (b :> t)))) )\n |> List.reduce\n ~f:(fun ((b1 : Boolean.var), g1) ((b2 : Boolean.var), g2)\n ->\n ( Boolean.Unsafe.of_cvar Field.(add (b1 :> t) (b2 :> t))\n , Array.map2_exn ~f:(Double.map2 ~f:( + )) g1 g2 ) )\n |> fun x -> (Option.map ~f:fst x, Option.map ~f:snd x)\n in\n let maybe_is_yes, maybe_sum =\n maybes\n |> List.map\n ~f:(fun ((b : Boolean.var), (b_g : Boolean.var), g) ->\n ( Boolean.Unsafe.of_cvar Field.(mul (b :> t) (b_g :> t))\n , Array.map g ~f:(Double.map ~f:(( * ) (b :> t))) ) )\n |> List.reduce\n ~f:(fun ((b1 : Boolean.var), g1) ((b2 : Boolean.var), g2)\n ->\n ( Boolean.Unsafe.of_cvar Field.(add (b1 :> t) (b2 :> t))\n , Array.map2_exn ~f:(Double.map2 ~f:( + )) g1 g2 ) )\n |> fun x -> (Option.map ~f:fst x, Option.map ~f:snd x)\n in\n let is_yes =\n [| just_is_yes; maybe_is_yes |]\n |> Array.filter_map ~f:Fn.id\n |> Array.reduce_exn\n ~f:(fun (b1 : Boolean.var) (b2 : Boolean.var) ->\n Boolean.Unsafe.of_cvar ((b1 :> t) + (b2 :> t)) )\n in\n let sum =\n [| none_sum; maybe_sum; just_sum |]\n |> Array.filter_map ~f:Fn.id\n |> Array.reduce_exn\n ~f:(Array.map2_exn ~f:(Double.map2 ~f:( + )))\n in\n Opt.Maybe (is_yes, sum) )\n |> Plonk_verification_key_evals.Step.map\n ~f:(fun g -> Array.map ~f:(Double.map ~f:(Util.seal (module Impl))) g)\n ~f_opt:(function\n | Opt.Nothing ->\n Opt.Nothing\n | Opt.Maybe (b, x) ->\n Opt.Maybe\n ( Boolean.Unsafe.of_cvar (Util.seal (module Impl) (b :> t))\n , Array.map ~f:(Double.map ~f:(Util.seal (module Impl))) x )\n | Opt.Just x ->\n Opt.Just\n (Array.map ~f:(Double.map ~f:(Util.seal (module Impl))) x) )\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 let chunks =\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n in\n Array.map chunks ~f:(function\n | Finite g ->\n let g = Inner_curve.Constant.of_affine g in\n Inner_curve.constant g\n | Infinity ->\n (* Point at infinity should be impossible in the SRS *)\n assert false ) )\n |> Vector.map2\n (which_branch :> (Boolean.var, n) Vector.t)\n ~f:(fun b pts ->\n Array.map pts ~f:(fun (x, y) -> Field.((b :> t) * x, (b :> t) * y))\n )\n |> Vector.reduce_exn ~f:(Array.map2_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 let chunks =\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n in\n Array.map chunks ~f:(function\n | Finite g ->\n let g = Inner_curve.Constant.of_affine g in\n Inner_curve.Constant.scale g c |> Inner_curve.constant\n | Infinity ->\n (* Point at infinity should be impossible in the SRS *)\n assert false ) )\n |> Vector.map2\n (which_branch :> (Boolean.var, n) Vector.t)\n ~f:(fun b pts ->\n Array.map pts ~f:(fun (x, y) -> Field.((b :> t) * x, (b :> t) * y))\n )\n |> Vector.reduce_exn ~f:(Array.map2_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 :\n Inner_curve.t Double.t array =\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 (* computes 2^i *)\n let rec field2pow f i =\n if i = 1 then f\n else\n let j = i - 1 in\n Inner_curve.Constant.Scalar.(f * field2pow f j)\n in\n (* computes 2^actual_shift *)\n let two_to_actual_shift =\n field2pow (Inner_curve.Constant.Scalar.of_int 2) actual_shift\n in\n (* computes [2^actual_shift] G *)\n let field_to_two_to_shift g =\n Inner_curve.Constant.scale g two_to_actual_shift\n in\n let base_and_correction (h : Domain.t) =\n let d = Int.pow 2 (Domain.log2_size h) in\n let chunks =\n (Kimchi_bindings.Protocol.SRS.Fp.lagrange_commitment srs d i)\n .unshifted\n in\n Array.map chunks ~f:(function\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 (field_to_two_to_shift g)) )\n | Infinity ->\n (* Point at infinity should be impossible in the SRS *)\n assert false )\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 Array.map pr\n ~f:\n (Double.map ~f:(fun (x, y) ->\n Field.((b :> t) * x, (b :> t) * y) ) ) )\n |> Vector.reduce_exn\n ~f:\n (Array.map2_exn\n ~f:(Double.map2 ~f:(Double.map2 ~f:Field.( + ))) )\n |> Array.map\n ~f:(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 assert_finite : t -> unit = function\n | `Finite _ ->\n ()\n | `Maybe_finite _ ->\n failwith \"Not finite\"\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 reduce_point p =\n let point = ref (Point.underlying p.(Array.length p - 1)) in\n for i = Array.length p - 2 downto 0 do\n point := Point.add p.(i) (Scalar_challenge.endo !point xi)\n done ;\n !point\n in\n let { Curve_opt.non_zero; point } =\n Pcs_batch.combine_split_commitments batch\n ~reduce_with_degree_bound:(fun _ -> assert false)\n ~reduce_without_degree_bound:(fun x -> [ x ])\n ~scale_and_add:(fun ~(acc : Curve_opt.t) ~xi\n (p : (Point.t array, Boolean.var) Opt.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 keep p =\n let base_point =\n let p = p.(Array.length p - 1) in\n Inner_curve.(\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 in\n let point = ref base_point in\n for i = Array.length p - 2 downto 0 do\n point := Point.add p.(i) (Scalar_challenge.endo !point xi)\n done ;\n let point =\n Inner_curve.(if_ keep ~then_:!point ~else_:acc.point)\n in\n Array.iter ~f:Point.assert_finite p ;\n let non_zero = Boolean.(keep &&& true_ ||| acc.non_zero) in\n { Curve_opt.non_zero; point }\n in\n match p with\n | Opt.Nothing ->\n acc\n | Opt.Maybe (keep, p) ->\n point keep p\n | Opt.Just p ->\n point Boolean.true_ p )\n ~xi\n ~init:(function\n | Opt.Nothing ->\n None\n | Opt.Maybe (keep, p) ->\n Array.iter ~f:Point.assert_finite p ;\n Some\n { non_zero = Boolean.(keep &&& true_)\n ; point = reduce_point p\n }\n | Opt.Just p ->\n Array.iter ~f:Point.assert_finite p ;\n Some\n { non_zero = Boolean.(true_ &&& true_)\n ; point = reduce_point 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.In_circuit.alpha = alpha_0\n ; beta = beta_0\n ; gamma = gamma_0\n ; zeta = zeta_0\n ; joint_combiner = joint_combiner_0\n ; feature_flags = _\n }\n { Plonk.Minimal.In_circuit.alpha = alpha_1\n ; beta = beta_1\n ; gamma = gamma_1\n ; zeta = zeta_1\n ; joint_combiner = joint_combiner_1\n ; feature_flags = _\n } =\n with_label __LOC__ (fun () ->\n match[@warning \"-4\"] (joint_combiner_0, joint_combiner_1) with\n | Nothing, Nothing ->\n ()\n | Maybe (b0, j0), Maybe (b1, j1) ->\n Boolean.Assert.(b0 = b1) ;\n let (Typ { var_to_fields; _ }) = Scalar_challenge.typ in\n Array.iter2_exn ~f:Field.Assert.equal\n (fst @@ var_to_fields j0)\n (fst @@ var_to_fields j1)\n | Just j0, Just j1 ->\n let (Typ { var_to_fields; _ }) = Scalar_challenge.typ in\n Array.iter2_exn ~f:Field.Assert.equal\n (fst @@ var_to_fields j0)\n (fst @@ var_to_fields j1)\n | ( ((Pickles_types.Opt.Just _ | Maybe _ | Nothing) as j0)\n , ((Pickles_types.Opt.Just _ | Maybe _ | Nothing) as j1) ) ->\n let sexp_of t =\n Sexp.to_string\n @@ Types.Opt.sexp_of_t\n (fun _ -> Sexp.Atom \"\")\n (fun _ -> Sexp.Atom \"\")\n t\n in\n failwithf\n \"incompatible optional states for joint_combiners: %s vs %s\"\n (sexp_of j0) (sexp_of j1) () ) ;\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.In_circuit.t)\n (m2 : (_, Scalar_challenge.t, _) Plonk.Minimal.In_circuit.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 index_to_field_elements ~g (m : _ Plonk_verification_key_evals.Step.t) =\n let { Plonk_verification_key_evals.Step.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 ; range_check0_comm\n ; range_check1_comm\n ; foreign_field_mul_comm\n ; foreign_field_add_comm\n ; xor_comm\n ; rot_comm\n ; lookup_table_comm\n ; lookup_table_ids\n ; runtime_tables_selector\n ; lookup_selector_xor\n ; lookup_selector_lookup\n ; lookup_selector_range_check\n ; lookup_selector_ffmul\n } =\n m\n in\n let open Pickles_types in\n let g_opt = Opt.map ~f:g 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:(fun x -> Opt.just (g x))\n @ [ g_opt range_check0_comm\n ; g_opt range_check1_comm\n ; g_opt foreign_field_mul_comm\n ; g_opt foreign_field_add_comm\n ; g_opt xor_comm\n ; g_opt rot_comm\n ]\n @ List.map ~f:g_opt (Vector.to_list lookup_table_comm)\n @ [ g_opt lookup_table_ids\n ; g_opt runtime_tables_selector\n ; g_opt lookup_selector_xor\n ; g_opt lookup_selector_lookup\n ; g_opt lookup_selector_range_check\n ; g_opt lookup_selector_ffmul\n ]\n\n (** Simulate an [Opt_sponge.t] locally in a block, but without running the\n expensive optional logic that is otherwise required.\n\n Invariant: This requires that the sponge 'state' (i.e. the state after\n absorbing or squeezing) is consistent between the initial state and the\n final state when using the sponge.\n *)\n let simulate_optional_sponge_with_alignment (sponge : Sponge.t) ~f = function\n | Pickles_types.Opt.Nothing ->\n Pickles_types.Opt.Nothing\n | Pickles_types.Opt.Maybe (b, x) ->\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 (* Use the sponge *)\n let res = f sponge x in\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 Pickles_types.Opt.Maybe (b, res)\n | Pickles_types.Opt.Just x ->\n Pickles_types.Opt.Just (f sponge x)\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 : (_ array, _) Plonk_verification_key_evals.Step.t)\n ~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 List.iter\n (index_to_field_elements\n ~g:\n (Array.concat_map ~f:(fun (z : Inputs.Inner_curve.t) ->\n List.to_array (Inner_curve.to_field_elements z) ) )\n m )\n ~f:(fun x ->\n let (_ : (unit, _) Pickles_types.Opt.t) =\n simulate_optional_sponge_with_alignment index_sponge x\n ~f:(fun sponge x ->\n Array.iter ~f:(Sponge.absorb sponge) x )\n in\n () ) ;\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:(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 (_, chunks) ->\n Some (Array.map ~f:snd chunks) ) )\n ~f:(Array.map2_exn ~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:(Array.map2_exn ~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 Array.map2_exn acc g ~f:(fun acc g ->\n Inner_curve.if_ b ~then_:(Ops.add_fast g acc)\n ~else_:acc ) )\n | `Add_with_correction ((x, num_bits), chunks) ->\n Array.map2_exn acc chunks ~f:(fun acc (g, _) ->\n Ops.add_fast acc\n (Ops.scale_fast2'\n (module Other_field.With_top_bit0)\n g x ~num_bits ) ) ) ) )\n |> Array.map ~f:Inner_curve.negate\n in\n let x_hat =\n with_label \"x_hat blinding\" (fun () ->\n Array.map x_hat ~f:(fun x_hat ->\n Ops.add_fast x_hat\n (Inner_curve.constant (Lazy.force Generators.h)) ) )\n in\n Array.iter x_hat ~f:(fun x_hat ->\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 runtime_comm =\n match messages.lookup with\n | Nothing\n | Maybe (_, { runtime = Nothing; _ })\n | Just { runtime = Nothing; _ } ->\n Pickles_types.Opt.Nothing\n | Maybe (b_lookup, { runtime = Maybe (b_runtime, runtime); _ }) ->\n let b = Boolean.( &&& ) b_lookup b_runtime in\n Pickles_types.Opt.Maybe (b, runtime)\n | Maybe (b, { runtime = Just runtime; _ })\n | Just { runtime = Maybe (b, runtime); _ } ->\n Pickles_types.Opt.Maybe (b, runtime)\n | Just { runtime = Just runtime; _ } ->\n Pickles_types.Opt.Just runtime\n in\n let absorb_runtime_tables () =\n match runtime_comm with\n | Nothing ->\n ()\n | Maybe (b, runtime) ->\n let z = Array.map runtime ~f:(fun z -> (b, z)) in\n absorb sponge Without_degree_bound z\n | Just runtime ->\n let z = Array.map runtime ~f:(fun z -> (Boolean.true_, z)) in\n absorb sponge Without_degree_bound z\n in\n absorb_runtime_tables () ;\n let joint_combiner =\n let compute_joint_combiner (l : _ Messages.Lookup.In_circuit.t) =\n let absorb_sorted_1 sponge =\n let (first :: _) = l.sorted in\n let z = Array.map first ~f:(fun z -> (Boolean.true_, z)) in\n absorb sponge Without_degree_bound z\n in\n let absorb_sorted_2_to_4 () =\n let (_ :: rest) = l.sorted in\n Vector.iter rest ~f:(fun z ->\n let z = Array.map z ~f:(fun z -> (Boolean.true_, z)) in\n absorb sponge Without_degree_bound z )\n in\n let absorb_sorted_5 () =\n match l.sorted_5th_column with\n | Nothing ->\n ()\n | Maybe (b, z) ->\n let z = Array.map z ~f:(fun z -> (b, z)) in\n absorb sponge Without_degree_bound z\n | Just z ->\n let z = Array.map z ~f:(fun z -> (Boolean.true_, z)) in\n absorb sponge Without_degree_bound z\n in\n match[@warning \"-4\"]\n (m.lookup_table_comm, m.runtime_tables_selector)\n with\n | _ :: Just _ :: _, _ | _, Just _ ->\n let joint_combiner = sample_scalar () in\n absorb_sorted_1 sponge ;\n absorb_sorted_2_to_4 () ;\n absorb_sorted_5 () ;\n joint_combiner\n | _ :: Nothing :: _, Nothing ->\n absorb_sorted_1 sponge ;\n absorb_sorted_2_to_4 () ;\n absorb_sorted_5 () ;\n { inner = Field.zero }\n | _ :: Maybe (b1, _) :: _, Maybe (b2, _) ->\n let b = Boolean.(b1 ||| b2) in\n let sponge2 = Opt.copy sponge in\n let joint_combiner_if_true =\n let joint_combiner = sample_scalar () in\n absorb_sorted_1 sponge ; joint_combiner\n in\n let joint_combiner_if_false : Scalar_challenge.t =\n absorb_sorted_1 sponge2 ; { inner = Field.zero }\n in\n Opt.recombine b ~original_sponge:sponge2 sponge ;\n absorb_sorted_2_to_4 () ;\n absorb_sorted_5 () ;\n { inner =\n Field.if_ b ~then_:joint_combiner_if_true.inner\n ~else_:joint_combiner_if_false.inner\n }\n | _ :: Maybe (b, _) :: _, _ | _, Maybe (b, _) ->\n let sponge2 = Opt.copy sponge in\n let joint_combiner_if_true =\n let joint_combiner = sample_scalar () in\n absorb_sorted_1 sponge ; joint_combiner\n in\n let joint_combiner_if_false : Scalar_challenge.t =\n absorb_sorted_1 sponge2 ; { inner = Field.zero }\n in\n Opt.recombine b ~original_sponge:sponge2 sponge ;\n absorb_sorted_2_to_4 () ;\n absorb_sorted_5 () ;\n { inner =\n Field.if_ b ~then_:joint_combiner_if_true.inner\n ~else_:joint_combiner_if_false.inner\n }\n in\n match messages.lookup with\n | Nothing ->\n Types.Opt.Nothing\n | Maybe (b, l) ->\n Opt.consume_all_pending sponge ;\n let sponge2 = Opt.copy sponge in\n let joint_combiner = compute_joint_combiner l in\n Opt.consume_all_pending sponge ;\n Opt.recombine b ~original_sponge:sponge2 sponge ;\n (* We explicitly set this, because when we squeeze for [beta], we\n there will be no pending values *but* we don't want to add a\n dedicated permutation.\n *)\n sponge.needs_final_permute_if_empty <- false ;\n Types.Opt.Maybe (b, joint_combiner)\n | Just l ->\n Opt.consume_all_pending sponge ;\n Types.Opt.just (compute_joint_combiner l)\n in\n let lookup_table_comm =\n let compute_lookup_table_comm (l : _ Messages.Lookup.In_circuit.t)\n joint_combiner =\n let (first_column :: second_column :: rest) = m.lookup_table_comm in\n let second_column_with_runtime =\n match (second_column, l.runtime) with\n | Types.Opt.Nothing, comm | comm, Types.Opt.Nothing ->\n comm\n | ( Types.Opt.Maybe (has_second_column, second_column)\n , Types.Opt.Maybe (has_runtime, runtime) ) ->\n let second_with_runtime =\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) second_column runtime\n in\n Array.map2_exn second_column sum\n ~f:(fun second_column sum ->\n Inner_curve.if_ has_runtime ~then_:sum\n ~else_:second_column )\n in\n let res =\n Array.map2_exn second_with_runtime runtime\n ~f:(fun second_with_runtime runtime ->\n Inner_curve.if_ has_second_column\n ~then_:second_with_runtime ~else_:runtime )\n in\n let b = Boolean.(has_second_column ||| has_runtime) in\n Types.Opt.maybe b res\n | ( Types.Opt.Maybe (has_second_column, second_column)\n , Types.Opt.Just runtime ) ->\n let res =\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) second_column runtime\n in\n Array.map2_exn runtime sum ~f:(fun runtime sum ->\n Inner_curve.if_ has_second_column ~then_:sum\n ~else_:runtime )\n in\n Types.Opt.just res\n | ( Types.Opt.Just second_column\n , Types.Opt.Maybe (has_runtime, runtime) ) ->\n let res =\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) second_column runtime\n in\n Array.map2_exn second_column sum\n ~f:(fun second_column sum ->\n Inner_curve.if_ has_runtime ~then_:sum\n ~else_:second_column )\n in\n Types.Opt.just res\n | Types.Opt.Just second_column, Types.Opt.Just runtime ->\n Types.Opt.just\n (Array.map2_exn ~f:Inner_curve.( + ) second_column runtime)\n in\n let rest_rev =\n Vector.rev (first_column :: second_column_with_runtime :: rest)\n in\n Vector.fold ~init:m.lookup_table_ids rest_rev ~f:(fun acc comm ->\n match acc with\n | Types.Opt.Nothing ->\n comm\n | Types.Opt.Maybe (has_acc, acc) -> (\n match comm with\n | Types.Opt.Nothing ->\n Types.Opt.maybe has_acc acc\n | Types.Opt.Maybe (has_comm, comm) ->\n let scaled_acc =\n Array.map acc ~f:(fun acc ->\n Scalar_challenge.endo acc joint_combiner )\n in\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) scaled_acc comm\n in\n let acc_with_comm =\n Array.map2_exn sum comm ~f:(fun sum comm ->\n Inner_curve.if_ has_acc ~then_:sum ~else_:comm )\n in\n let res =\n Array.map2_exn acc acc_with_comm\n ~f:(fun acc acc_with_comm ->\n Inner_curve.if_ has_comm ~then_:acc_with_comm\n ~else_:acc )\n in\n let b = Boolean.(has_acc ||| has_comm) in\n Types.Opt.maybe b res\n | Types.Opt.Just comm ->\n let scaled_acc =\n Array.map acc ~f:(fun acc ->\n Scalar_challenge.endo acc joint_combiner )\n in\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) scaled_acc comm\n in\n let res =\n Array.map2_exn sum comm ~f:(fun sum comm ->\n Inner_curve.if_ has_acc ~then_:sum ~else_:comm )\n in\n Types.Opt.just res )\n | Types.Opt.Just acc -> (\n match comm with\n | Types.Opt.Nothing ->\n Types.Opt.just acc\n | Types.Opt.Maybe (has_comm, comm) ->\n let scaled_acc =\n Array.map acc ~f:(fun acc ->\n Scalar_challenge.endo acc joint_combiner )\n in\n let sum =\n Array.map2_exn ~f:Inner_curve.( + ) scaled_acc comm\n in\n let res =\n Array.map2_exn sum acc ~f:(fun sum acc ->\n Inner_curve.if_ has_comm ~then_:sum ~else_:acc )\n in\n Types.Opt.just res\n | Types.Opt.Just comm ->\n let scaled_acc =\n Array.map acc ~f:(fun acc ->\n Scalar_challenge.endo acc joint_combiner )\n in\n Types.Opt.Just\n (Array.map2_exn ~f:Inner_curve.( + ) scaled_acc comm)\n ) )\n in\n match (messages.lookup, joint_combiner) with\n | Types.Opt.Nothing, Types.Opt.Nothing ->\n Types.Opt.Nothing\n | ( Types.Opt.Maybe (b_l, l)\n , Types.Opt.Maybe (_b_joint_combiner, joint_combiner) ) -> (\n (* NB: b_l = _b_joint_combiner by construction *)\n match compute_lookup_table_comm l joint_combiner with\n | Types.Opt.Nothing ->\n Types.Opt.Nothing\n | Types.Opt.Maybe (b_lookup_table_comm, lookup_table_comm) ->\n Types.Opt.Maybe\n (Boolean.(b_l &&& b_lookup_table_comm), lookup_table_comm)\n | Types.Opt.Just lookup_table_comm ->\n Types.Opt.Maybe (b_l, lookup_table_comm) )\n | Types.Opt.Just l, Types.Opt.Just joint_combiner ->\n compute_lookup_table_comm l joint_combiner\n | ( (Types.Opt.Nothing | Maybe _ | Just _)\n , (Types.Opt.Nothing | Maybe _ | Just _) ) ->\n assert false\n in\n let lookup_sorted =\n let lookup_sorted_minus_1 =\n Nat.to_int Plonk_types.Lookup_sorted_minus_1.n\n in\n Vector.init Plonk_types.Lookup_sorted.n ~f:(fun i ->\n match messages.lookup with\n | Types.Opt.Nothing ->\n Types.Opt.Nothing\n | Types.Opt.Maybe (b, l) ->\n if i = lookup_sorted_minus_1 then l.sorted_5th_column\n else\n Types.Opt.Maybe (b, Option.value_exn (Vector.nth l.sorted i))\n | Types.Opt.Just l ->\n if i = lookup_sorted_minus_1 then l.sorted_5th_column\n else Types.Opt.Just (Option.value_exn (Vector.nth l.sorted i)) )\n in\n let beta = sample () in\n let gamma = sample () in\n let () =\n match messages.lookup with\n | Nothing ->\n ()\n | Maybe (b, l) ->\n let aggreg = Array.map l.aggreg ~f:(fun z -> (b, z)) in\n absorb sponge Without_degree_bound aggreg\n | Just l ->\n let aggreg =\n Array.map l.aggreg ~f:(fun z -> (Boolean.true_, z))\n in\n absorb sponge Without_degree_bound aggreg\n 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 ~verification_key:\n (Plonk_verification_key_evals.Step.forget_optional_commitments\n m )\n ~plonk ~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 len_1, len_1_add = Plonk_types.(Columns.add Permuts_minus_1.n) in\n let len_2, len_2_add = Plonk_types.(Columns.add len_1) in\n let _len_3, len_3_add = Nat.N9.add len_2 in\n let _len_4, len_4_add = Nat.N6.add Plonk_types.Lookup_sorted.n in\n let len_5, len_5_add =\n (* NB: Using explicit 11 because we can't get add on len_4 *)\n Nat.N11.add Nat.N8.n\n in\n let len_6, len_6_add = Nat.N45.add len_5 in\n let num_commitments_without_degree_bound = len_6 in\n let without_degree_bound =\n let append_chain len second first =\n Vector.append first second len\n in\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.map sg_old ~f:(fun (keep, p) ->\n Pickles_types.Opt.Maybe (keep, [| p |]) )\n |> append_chain\n (snd (Max_proofs_verified.add len_6))\n ( [ x_hat\n ; [| ft_comm |]\n ; z_comm\n ; m.generic_comm\n ; m.psm_comm\n ; m.complete_add_comm\n ; m.mul_comm\n ; m.emul_comm\n ; m.endomul_scalar_comm\n ]\n |> append_chain len_3_add\n (Vector.append w_comm\n (Vector.append m.coefficients_comm sigma_comm_init\n len_1_add )\n len_2_add )\n |> Vector.map ~f:Pickles_types.Opt.just\n |> append_chain len_6_add\n ( [ m.range_check0_comm\n ; m.range_check1_comm\n ; m.foreign_field_add_comm\n ; m.foreign_field_mul_comm\n ; m.xor_comm\n ; m.rot_comm\n ]\n |> append_chain len_4_add lookup_sorted\n |> append_chain len_5_add\n [ Pickles_types.Opt.map messages.lookup ~f:(fun l ->\n l.aggreg )\n ; lookup_table_comm\n ; runtime_comm\n ; m.runtime_tables_selector\n ; m.lookup_selector_xor\n ; m.lookup_selector_lookup\n ; m.lookup_selector_range_check\n ; m.lookup_selector_ffmul\n ] ) )\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:\n (Pickles_types.Opt.map\n ~f:(Array.map ~f:(fun x -> `Finite x)) )\n , [] )\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 = plonk.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 (* computes pt^{2^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 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 Array.iter ~f:(Sponge.absorb sponge) (fst evals.public_input) ;\n Array.iter ~f:(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 | Nothing ->\n ()\n | Just (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 ~zk_rows:3\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 | Nothing ->\n [||]\n | Just a ->\n Array.map a ~f:Pickles_types.Opt.just\n | Maybe (b, a) ->\n Array.map a ~f:(Pickles_types.Opt.maybe b) )\n in\n let sg_evals =\n Vector.map sg_evals ~f:(fun x -> [| Pickles_types.Opt.just 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\n ( Array.map ~f:Pickles_types.Opt.just x_hat\n :: [| Pickles_types.Opt.just ft |]\n :: 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:Pickles_types.Opt.nothing ~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","open Core_kernel\n\n[@@@warning \"-4\"]\n\ntype ('a, 'bool) t = Just of 'a | Nothing | Maybe of 'bool * 'a\n[@@deriving sexp, compare, yojson, hash, equal]\n\nlet just a = Just a\n\nlet nothing = Nothing\n\nlet maybe b x = Maybe (b, x)\n\nlet to_option : ('a, bool) t -> 'a option = function\n | Just x ->\n Some x\n | Maybe (true, x) ->\n Some x\n | Maybe (false, _x) ->\n None\n | Nothing ->\n None\n\nlet to_option_unsafe : ('a, 'bool) t -> 'a option = function\n | Just x ->\n Some x\n | Maybe (_, x) ->\n Some x\n | Nothing ->\n None\n\nlet value_exn = function\n | Just x ->\n x\n | Maybe (_, x) ->\n x\n | Nothing ->\n invalid_arg \"Opt.value_exn\"\n\nlet of_option (t : 'a option) : ('a, 'bool) t =\n match t with None -> Nothing | Some x -> Just x\n\nlet lift ?on_maybe ~nothing f = function\n | Nothing ->\n nothing\n | Just v ->\n f v\n | Maybe (b, v) -> (\n match on_maybe with None -> f v | Some g -> g b v )\n\nmodule 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\nend\n\nlet map t ~f =\n match t with\n | Nothing ->\n Nothing\n | Just x ->\n Just (f x)\n | Maybe (b, x) ->\n Maybe (b, f x)\n\nlet iter t ~f =\n match t with Nothing -> () | Just x -> f x | Maybe (_, x) -> f x\n\nopen Snarky_backendless\n\nlet 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 | Just x ->\n x\n | Maybe _ | Nothing ->\n failwith \"Opt.some_typ: expected Just\" )\n ~back:(fun x -> Just x)\n\nlet 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 | Nothing ->\n ()\n | Maybe _ | Just _ ->\n failwith \"Opt.none_typ: expected Nothing\" )\n ~back:(fun () : _ t -> Nothing)\n\nlet 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 | Nothing | Just _ ->\n failwith \"Opt.maybe_typ: expected Maybe\" )\n ~back:(fun (b, x) -> Maybe (b, x))\n\nlet 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 | Nothing ->\n (false_, dummy_var)\n | Just x ->\n (true_, x) )\n ~back:(fun (b, x) ->\n match flag with No -> Nothing | Yes -> Just x | Maybe -> Maybe (b, x)\n )\n\nlet typ (type a a_var f) bool_typ (flag : Flag.t) (a_typ : (a_var, a, f) Typ.t)\n ~(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\nmodule 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 | Nothing :: xs ->\n go acc xs\n | Just 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\nend\n","(* q > p *)\nopen Core_kernel\nmodule SC = Scalar_challenge\nopen Import\nopen Common\nopen Util\nopen Types.Step\nopen Pickles_types\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 ~reduce_without_degree_bound:Array.to_list\n ~reduce_with_degree_bound:(fun { Plonk_types.Poly_comm\n .With_degree_bound\n .unshifted\n ; shifted\n } ->\n Array.to_list unshifted @ [ shifted ] )\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 ->\n Some (`Finite x)\n | `Maybe_finite x ->\n Some (`Maybe_finite x) )\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 ~verification_key:m ~plonk ~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 :: m.mul_comm :: m.emul_comm\n :: m.endomul_scalar_comm\n :: Vector.append w_comm\n (Vector.append m.coefficients_comm sigma_comm_init\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 = None 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 (* 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 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 ~(step_domains :\n [ `Known of (Domains.t, branches) Vector.t | `Side_loaded ] ) ~zk_rows\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 Plonk_types.Evals.In_circuit.validate_feature_flags ~true_:Boolean.true_\n ~false_:Boolean.false_ ~or_:Boolean.( ||| )\n ~assert_equal:Boolean.Assert.( = ) ~feature_flags:plonk.feature_flags\n evals.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 Array.iter\n ~f:(fun x -> Sponge.absorb sponge (`Field x))\n (fst evals.public_input) ;\n Array.iter\n ~f:(fun x -> Sponge.absorb sponge (`Field x))\n (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 | Nothing ->\n ()\n | Just (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 ~zk_rows\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) -> [| Opt.Maybe (keep, eval) |])\n in\n let a =\n Evals.In_circuit.to_list e\n |> List.map ~f:(function\n | Nothing ->\n [||]\n | Just a ->\n Array.map a ~f:Opt.just\n | Maybe (b, a) ->\n Array.map a ~f:(Opt.maybe b) )\n in\n let v =\n List.append sg_evals\n (Array.map ~f:Opt.just x_hat :: [| Opt.just 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:\n (Array.concat_map ~f:(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 : Impls.Step.unfinalized_proof_var) =\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 ~option_map:Opt.map\n statement ) )\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.nothing ~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\nmodule For_tests_only = struct\n let side_loaded_domain = side_loaded_domain\nend\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 ; xor_comm : 'polyComm option\n ; range_check0_comm : 'polyComm option\n ; range_check1_comm : 'polyComm option\n ; foreign_field_add_comm : 'polyComm option\n ; foreign_field_mul_comm : 'polyComm option\n ; rot_comm : 'polyComm option\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 ; zk_rows : int\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))\n\n let of_yojson fp fq =\n verifier_index_of_yojson fp\n (fun _ -> Ok (Backend.Tock.Keypair.load_urs ()))\n (polycomm_of_yojson (or_infinity_of_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 [@of_yojson\n Verifier_index_json.of_yojson Backend.Tock.Field.of_yojson\n Backend.Tick.Field.of_yojson] )\n ; data : Data.t\n }\n [@@deriving fields, to_yojson, of_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)) =\n Impls.Wrap.input ~feature_flags:Plonk_types.Features.Full.maybe ()\n 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 ; xor_comm = None\n ; range_check0_comm = None\n ; range_check1_comm = None\n ; foreign_field_add_comm = None\n ; foreign_field_mul_comm = None\n ; rot_comm = None\n } )\n ; shifts = Common.tock_shifts ~log2_size\n ; lookup_index = None\n ; zk_rows = 3\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 of_yojson = Stable.Latest.of_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_step_commitments g =\n let open Plonk_types in\n { Plonk_verification_key_evals.Step.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 ; xor_comm = None\n ; range_check0_comm = None\n ; range_check1_comm = None\n ; foreign_field_add_comm = None\n ; foreign_field_mul_comm = None\n ; rot_comm = None\n ; lookup_table_comm = Vector.init Lookup_sorted_minus_1.n ~f:(fun _ -> None)\n ; lookup_table_ids = None\n ; runtime_tables_selector = None\n ; lookup_selector_lookup = None\n ; lookup_selector_xor = None\n ; lookup_selector_range_check = None\n ; lookup_selector_ffmul = None\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\n\n[@@@warning \"-4-27\"]\n\nmodule Yojson_map = Map.Make (struct\n type t =\n [ `Null\n | `Bool of bool\n | `Int of int\n | `Intlit of string\n | `Float of float\n | `String of string\n | `Assoc of (string * t) list\n | `List of t list\n | `Tuple of t list\n | `Variant of string * t option ]\n [@@deriving compare, sexp]\nend)\n\n[@@@warning \"+4+27\"]\n\ntype t = Yojson.Safe.t Yojson_map.t Yojson_map.t ref\n\n(* We use a slightly more verbose format here, so that it's easy to debug.\n There are some overheads to handling this, but the amount of computation we\n save by caching the proofs is orders of magnitude higher, so it's not really\n an issue.\n*)\nlet to_yojson t =\n `List\n (Map.fold ~init:[] !t ~f:(fun ~key ~data xs ->\n let proofs =\n Map.fold ~init:[] data ~f:(fun ~key ~data xs ->\n `Assoc [ (\"public_input\", key); (\"proof\", data) ] :: xs )\n in\n `Assoc [ (\"verification_key\", key); (\"proofs\", `List proofs) ] :: xs )\n )\n\n(* This mirrors the format of [to_yojson], carefully ensuring that we can\n decode what we encode, and reporting an error when the format differs from\n what we expect.\n\n Note that, since this is a cache, it should always be possible to regenerate\n proofs for the cache by starting with the empty cache and calling\n [to_yojson] on the result.\n*)\nlet of_yojson t =\n Result.try_with (fun () ->\n match t with\n | `List xs ->\n let for_vks =\n List.map xs ~f:(function\n | `Assoc [ (\"verification_key\", key); (\"proofs\", `List proofs) ]\n ->\n let proofs =\n List.map proofs ~f:(function\n | `Assoc [ (\"public_input\", key); (\"proof\", data) ] ->\n (key, data)\n | _ ->\n failwith\n \"Expected fields `public_input`, `proof` as a \\\n record in that order; received something \\\n different\" )\n in\n (key, Yojson_map.of_alist_exn proofs)\n | _ ->\n failwith\n \"Expected fields `verification_key`, `proofs` as a record \\\n in that order, where `proofs` is a list; received \\\n something different\" )\n in\n ref (Yojson_map.of_alist_exn for_vks)\n | _ ->\n failwith \"Expected a list, got something different\" )\n |> Result.map_error ~f:Exn.to_string\n\n(* Alias types with a [deriving to_yojson] annotation, so that we don't have to\n spell out the serialization explicitly.\n*)\nmodule Json = struct\n type 'f or_infinity = 'f Kimchi_types.or_infinity =\n | Infinity\n | Finite of ('f * 'f)\n [@@deriving to_yojson]\n\n type 'caml_g poly_comm = 'caml_g Kimchi_types.poly_comm =\n { unshifted : 'caml_g array; shifted : 'caml_g option }\n [@@deriving to_yojson]\n\n type lookup_patterns = Kimchi_types.lookup_patterns =\n { xor : bool; lookup : bool; range_check : bool; foreign_field_mul : bool }\n [@@deriving to_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 to_yojson]\n\n type lookups_used = Kimchi_types.VerifierIndex.Lookup.lookups_used =\n | Single\n | Joint\n [@@deriving to_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 to_yojson]\n\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 to_yojson]\n\n type 'poly_comm lookup = 'poly_comm Kimchi_types.VerifierIndex.Lookup.t =\n { joint_lookup_used : bool\n ; lookup_table : 'poly_comm array\n ; lookup_selectors : 'poly_comm lookup_selectors\n ; table_ids : 'poly_comm option\n ; lookup_info : lookup_info\n ; runtime_tables_selector : 'poly_comm option\n }\n [@@deriving to_yojson]\n\n type 'fr domain = 'fr Kimchi_types.VerifierIndex.domain =\n { log_size_of_group : int; group_gen : 'fr }\n [@@deriving to_yojson]\n\n type 'poly_comm verification_evals =\n 'poly_comm Kimchi_types.VerifierIndex.verification_evals =\n { sigma_comm : 'poly_comm array\n ; coefficients_comm : 'poly_comm array\n ; generic_comm : 'poly_comm\n ; psm_comm : 'poly_comm\n ; complete_add_comm : 'poly_comm\n ; mul_comm : 'poly_comm\n ; emul_comm : 'poly_comm\n ; endomul_scalar_comm : 'poly_comm\n ; xor_comm : 'poly_comm option [@default None]\n ; range_check0_comm : 'poly_comm option [@default None]\n ; range_check1_comm : 'poly_comm option [@default None]\n ; foreign_field_add_comm : 'poly_comm option [@default None]\n ; foreign_field_mul_comm : 'poly_comm option [@default None]\n ; rot_comm : 'poly_comm option [@default None]\n }\n [@@deriving to_yojson]\n\n type ('fr, 'srs, 'poly_comm) verifier_index =\n ('fr, 'srs, 'poly_comm) 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 : 'poly_comm verification_evals\n ; shifts : 'fr array\n ; lookup_index : 'poly_comm lookup option\n ; zk_rows : int [@default 3]\n }\n [@@deriving to_yojson]\n\n let srs_to_yojson _ = `Null\n\n let step_verification_key_to_yojson =\n [%to_yojson:\n ( Backend.Tick.Field.t\n , srs\n , Backend.Tock.Field.t or_infinity poly_comm )\n verifier_index]\n\n let wrap_verification_key_to_yojson =\n [%to_yojson:\n ( Backend.Tock.Field.t\n , srs\n , Backend.Tick.Field.t or_infinity poly_comm )\n verifier_index]\nend\n\nlet empty () = ref Yojson_map.empty\n\nlet get_proof t ~verification_key ~public_input =\n let open Option.Let_syntax in\n let%bind for_vk = Map.find !t verification_key in\n Map.find for_vk public_input\n\nlet get_step_proof t ~keypair ~public_input =\n let open Option.Let_syntax in\n let public_input =\n let len = Kimchi_bindings.FieldVectors.Fp.length public_input in\n Array.init len ~f:(fun i ->\n Kimchi_bindings.FieldVectors.Fp.get public_input i )\n |> [%to_yojson: Backend.Tick.Field.t array]\n in\n let verification_key =\n Backend.Tick.Keypair.vk keypair |> Json.step_verification_key_to_yojson\n in\n let%bind proof_json = get_proof t ~verification_key ~public_input in\n Option.try_with (fun () ->\n Result.ok_or_failwith @@ Backend.Tick.Proof.of_yojson proof_json )\n\nlet get_wrap_proof t ~keypair ~public_input =\n let open Option.Let_syntax in\n let public_input =\n let len = Kimchi_bindings.FieldVectors.Fq.length public_input in\n Array.init len ~f:(fun i ->\n Kimchi_bindings.FieldVectors.Fq.get public_input i )\n |> [%to_yojson: Backend.Tock.Field.t array]\n in\n let verification_key =\n Backend.Tock.Keypair.vk keypair |> Json.wrap_verification_key_to_yojson\n in\n let%bind proof_json = get_proof t ~verification_key ~public_input in\n Option.try_with (fun () ->\n Result.ok_or_failwith @@ Backend.Tock.Proof.of_yojson proof_json )\n\nlet set_proof t ~verification_key ~public_input proof =\n t :=\n Map.update !t verification_key ~f:(function\n | None ->\n Yojson_map.singleton public_input proof\n | Some for_vk ->\n Map.set for_vk ~key:public_input ~data:proof )\n\nlet set_step_proof t ~keypair ~public_input proof =\n let public_input =\n let len = Kimchi_bindings.FieldVectors.Fp.length public_input in\n Array.init len ~f:(fun i ->\n Kimchi_bindings.FieldVectors.Fp.get public_input i )\n |> [%to_yojson: Backend.Tick.Field.t array]\n in\n let verification_key =\n Backend.Tick.Keypair.vk keypair |> Json.step_verification_key_to_yojson\n in\n let proof_json = Backend.Tick.Proof.to_yojson proof in\n set_proof t ~verification_key ~public_input proof_json\n\nlet set_wrap_proof t ~keypair ~public_input proof =\n let public_input =\n let len = Kimchi_bindings.FieldVectors.Fq.length public_input in\n Array.init len ~f:(fun i ->\n Kimchi_bindings.FieldVectors.Fq.get public_input i )\n |> [%to_yojson: Backend.Tock.Field.t array]\n in\n let verification_key =\n Backend.Tock.Keypair.vk keypair |> Json.wrap_verification_key_to_yojson\n in\n let proof_json = Backend.Tock.Proof.to_yojson proof in\n set_proof t ~verification_key ~public_input proof_json\n\nlet is_env_var_set_requesting_error_for_proofs () =\n match Sys.getenv_opt \"ERROR_ON_PROOF\" with\n | Some (\"true\" | \"t\" (* insert whatever value is okay here *)) ->\n true\n | None | Some _ ->\n false\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 type storable =\n (Key.Proving.t, Backend.Tick.Keypair.t) Key_cache.Sync.Disk_storable.t\n\n type vk_storable =\n ( Key.Verification.t\n , Kimchi_bindings.Protocol.VerifierIndex.Fp.t )\n Key_cache.Sync.Disk_storable.t\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 ?(s_p = storable) k_p\n ?(s_v = vk_storable) k_v =\n let open Impls.Step in\n let pk =\n lazy\n (let%map.Promise k_p = Lazy.force k_p in\n match\n Common.time \"step keypair read\" (fun () ->\n Key_cache.Sync.read cache s_p k_p )\n with\n | Ok (pk, dirty) ->\n Common.time \"step keypair create\" (fun () -> (pk, dirty))\n | Error _e ->\n let _, _, _, sys = k_p in\n let r =\n Common.time \"stepkeygen\" (fun () ->\n Keypair.generate ~prev_challenges sys )\n in\n Timer.clock __LOC__ ;\n ignore\n ( Key_cache.Sync.write cache s_p k_p (Keypair.pk r)\n : unit Or_error.t ) ;\n (Keypair.pk r, `Generated_something) )\n in\n let vk =\n lazy\n (let%bind.Promise 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 Promise.return (vk, `Cache_hit)\n | Error _e ->\n let%map.Promise pk, c = Lazy.force pk in\n let vk = Backend.Tick.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 type storable =\n (Key.Proving.t, Backend.Tock.Keypair.t) Key_cache.Sync.Disk_storable.t\n\n type vk_storable =\n (Key.Verification.t, Verification_key.t) Key_cache.Sync.Disk_storable.t\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 vk_storable =\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 Verification_key.Stable.Latest)\n (In_channel.read_all 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, _) 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\n (module Verification_key.Stable.Latest)\n t ) ) )\n header path ) )\n\n let read_or_generate ~prev_challenges cache ?(s_p = storable) k_p\n ?(s_v = vk_storable) k_v =\n let module Vk = Verification_key in\n let open Impls.Wrap in\n let pk =\n lazy\n (let%map.Promise 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 (pk, d)\n | Error _e ->\n let _, _, sys = k in\n let r =\n Common.time \"wrapkeygen\" (fun () ->\n Keypair.generate ~prev_challenges sys )\n in\n ignore\n ( Key_cache.Sync.write cache s_p k (Keypair.pk r)\n : unit Or_error.t ) ;\n (Keypair.pk r, `Generated_something) )\n in\n let vk =\n lazy\n (let%bind.Promise k_v = Lazy.force k_v in\n match Key_cache.Sync.read cache s_v k_v with\n | Ok (vk, d) ->\n Promise.return (vk, d)\n | Error _e ->\n let%map.Promise pk, _dirty = Lazy.force pk in\n let vk = Backend.Tock.Keypair.vk pk 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 to_yojson = Kimchi_pasta_basic.Fp.to_yojson\n\n let of_yojson = Kimchi_pasta_basic.Fp.of_yojson\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 Kimchi_pasta_basic.poseidon_params_fp\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","open Core_kernel\nopen Pickles.Impls.Step.Internal_Basic\n\nmodule State = struct\n include Array\n\n let map2 = map2_exn\n\n let to_array t = t\n\n let of_array t = t\nend\n\nmodule Input = Random_oracle_input\n\nlet params : Field.t Sponge.Params.t = Kimchi_pasta_basic.poseidon_params_fp\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\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\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\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\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:Kimchi_pasta_basic.Fp.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 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\nend\n","[%%import \"/src/config.mlh\"]\n\n(** This file consists of compile-time constants that are not in\n Genesis_constants.\n This file includes all of the constants defined at compile-time for both\n tests and production.\n*)\n\ninclude Node_config_version\ninclude Node_config_unconfigurable_constants\n\n[%%inject \"ledger_depth\", ledger_depth]\n\n[%%inject \"curve_size\", curve_size]\n\n[%%inject \"coinbase\", coinbase]\n\n[%%inject \"k\", k]\n\n[%%inject \"delta\", delta]\n\n[%%inject \"slots_per_epoch\", slots_per_epoch]\n\n[%%inject \"slots_per_sub_window\", slots_per_sub_window]\n\n[%%inject \"sub_windows_per_window\", sub_windows_per_window]\n\n[%%inject \"grace_period_slots\", grace_period_slots]\n\n[%%inject \"scan_state_with_tps_goal\", scan_state_with_tps_goal]\n\n[%%ifndef scan_state_transaction_capacity_log_2]\n\nlet scan_state_transaction_capacity_log_2 : int option = None\n\n[%%else]\n\n[%%inject\n\"scan_state_transaction_capacity_log_2\", scan_state_transaction_capacity_log_2]\n\nlet scan_state_transaction_capacity_log_2 =\n Some scan_state_transaction_capacity_log_2\n\n[%%endif]\n\n[%%inject \"scan_state_work_delay\", scan_state_work_delay]\n\n[%%inject \"proof_level\", proof_level]\n\n[%%inject \"pool_max_size\", pool_max_size]\n\n[%%inject \"account_creation_fee_int\", account_creation_fee_int]\n\n[%%inject \"default_transaction_fee\", default_transaction_fee]\n\n[%%inject \"default_snark_worker_fee\", default_snark_worker_fee]\n\n[%%inject \"minimum_user_command_fee\", minimum_user_command_fee]\n\n[%%inject \"supercharged_coinbase_factor\", supercharged_coinbase_factor]\n\n[%%inject \"plugins\", plugins]\n\n[%%inject \"genesis_state_timestamp\", genesis_state_timestamp]\n\n[%%inject \"block_window_duration\", block_window_duration]\n\n[%%inject \"itn_features\", itn_features]\n\n[%%ifndef compaction_interval]\n\nlet compaction_interval = None\n\n[%%else]\n\n[%%inject \"compaction_interval\", compaction_interval]\n\nlet compaction_interval = Some compaction_interval\n\n[%%endif]\n\n[%%inject \"network\", network]\n\n[%%inject \"vrf_poll_interval\", vrf_poll_interval]\n\n[%%ifndef zkapp_cmd_limit]\n\nlet zkapp_cmd_limit = None\n\n[%%else]\n\n[%%inject \"zkapp_cmd_limit\", zkapp_cmd_limit]\n\nlet zkapp_cmd_limit = Some zkapp_cmd_limit\n\n[%%endif]\n\n[%%ifndef scan_state_tps_goal_x10]\n\nlet scan_state_tps_goal_x10 : int option = None\n\n[%%else]\n\n[%%inject \"scan_state_tps_goal_x10\", scan_state_tps_goal_x10]\n\nlet scan_state_tps_goal_x10 = Some scan_state_tps_goal_x10\n\n[%%endif]\n","open Core_kernel\nopen Snark_params.Tick\n\nlet parity y = Bigint.(test_bit (of_field y) 0)\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 (* 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 *)\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 (* 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 *)\nend\n\ninclude Uncompressed\n","open 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 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 end\nend]\n\n[%%define_locally Stable.Latest.(gen)]\n\nlet create () =\n (* This calls into libsnark which uses /dev/urandom *)\n Inner_curve.Scalar.random ()\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","module 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 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\nend\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 if Random.int 1000 = 0 then (\n print_endline \"SCHNORR BACKTRACE:\" ;\n Printexc.print_backtrace stdout ) ;\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 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\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 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 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 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 end\nend\n\nmodule Legacy = Make (Tick) (Tick.Inner_curve) (Message.Legacy)\nmodule Chunked = Make (Tick) (Tick.Inner_curve) (Message.Chunked)\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","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","open 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\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","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 (** Same as [add_path], but using the hashes provided in the wide merkle path\n instead of recomputing them.\n This is unsafe: the hashes are not checked or recomputed.\n *)\n val add_wide_path_unsafe :\n t\n -> [ `Left of hash * hash | `Right of hash * hash ] list\n -> account_id\n -> account\n -> 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_impl ~replace_self tree0 path0 account =\n (* Takes height, left and right children and builds a pair of sibling nodes\n one level up *)\n let build_tail_f height (prev_l, prev_r) =\n replace_self ~f:(fun mself ->\n let self =\n match mself with\n | Some self ->\n self\n | None ->\n Hash.merge ~height (hash prev_l) (hash prev_r)\n in\n Tree.Node (self, prev_l, prev_r) )\n in\n (* Builds the tail of path, i.e. part of the path that is not present in\n the current ledger and we just add it all the way down to account\n using the path *)\n let build_tail hash_node_to_bottom_path =\n let bottom_el, bottom_to_hash_node_path =\n Mina_stdlib.Nonempty_list.(rev hash_node_to_bottom_path |> uncons)\n in\n (* Left and right branches of a node that is parent of the bottom node *)\n let init = replace_self ~f:(Fn.const (Tree.Account account)) bottom_el in\n List.foldi ~init bottom_to_hash_node_path ~f:build_tail_f\n in\n (* Traverses the tree along path, collecting nodes and untraversed sibling hashes\n Stops when encounters `Hash` or `Account` node.\n\n Returns the last visited node (`Hash` or `Account`), remainder of path and\n collected node/sibling hashes in bottom-to-top order.\n *)\n let rec traverse_through_nodes = function\n | Tree.Account _, _ :: _ ->\n failwith \"path is longer than a tree's branch\"\n | Account _, [] | Tree.Hash _, [] ->\n Tree.Account account\n | Tree.Hash h, fst_el :: rest ->\n let tail_l, tail_r =\n build_tail (Mina_stdlib.Nonempty_list.init fst_el rest)\n in\n Tree.Node (h, tail_l, tail_r)\n | Node (h, l, r), `Left _ :: rest ->\n Tree.Node (h, traverse_through_nodes (l, rest), r)\n | Node (h, l, r), `Right _ :: rest ->\n Tree.Node (h, l, traverse_through_nodes (r, rest))\n | Node _, [] ->\n failwith \"path is shorter than a tree's branch\"\n in\n traverse_through_nodes (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 let replace_self ~f = function\n | `Left h_r ->\n (f None, Tree.Hash h_r)\n | `Right h_l ->\n (Tree.Hash h_l, f None)\n in\n { t with\n tree = add_path_impl ~replace_self t.tree path account\n ; indexes = (account_id, index) :: t.indexes\n }\n\n let add_wide_path_unsafe (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 let replace_self ~f = function\n | `Left (h_l, h_r) ->\n (f (Some h_l), Tree.Hash h_r)\n | `Right (h_l, h_r) ->\n (Tree.Hash h_l, f (Some h_r))\n in\n { t with\n tree = add_path_impl ~replace_self 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}, tree_depth = %d\"\n idx expected_kind kind (depth - i) t depth ()\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 =\n { name : Bounded_types.String.Stable.V1.t; 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 *)\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","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","open Core_kernel\nopen Snark_bits\nopen Snark_params\nopen Tick\nopen Bitstring_lib\nopen Let_syntax\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 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 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 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 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 [%%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 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 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 create_preserve_zero_sign ~magnitude ~sgn = { magnitude; sgn }\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 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 end\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 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]\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 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 end\n end]\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 include Arithmetic_intf with type t := t\n\n include Codable.S with type t := t\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 (* 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 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 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 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 [%%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]\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 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 end\n\n include Make_str (struct\n type t = Unsigned_extended.UInt64.Stable.Latest.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 end\n end]\n\n include (Amount : Basic with type t := t with type var = Amount.var)\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 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 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 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 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","(** This file consists of compile-time constants that are not in Genesis_constants.\n This file includes all of the constants defined at compile-time for both\n tests and production.\n*)\n\ninclude Node_config_version\ninclude Node_config_unconfigurable_constants\n\nlet (ledger_depth : int) = (10 : int)\n\nlet (curve_size : int) = (255 : int)\n\nlet (coinbase : string) = (\"20\" : string)\n\nlet (k : int) = (24 : int)\n\nlet (delta : int) = (0 : int)\n\nlet (slots_per_epoch : int) = (576 : int)\n\nlet (slots_per_sub_window : int) = (2 : int)\n\nlet (sub_windows_per_window : int) = (3 : int)\n\nlet (grace_period_slots : int) = (180 : int)\n\nlet (scan_state_with_tps_goal : bool) = (false : bool)\n\nlet (scan_state_transaction_capacity_log_2 : int) = (3 : int)\n\nlet scan_state_transaction_capacity_log_2 =\n Some scan_state_transaction_capacity_log_2\n\nlet (scan_state_work_delay : int) = (2 : int)\n\nlet (proof_level : string) = (\"check\" : string)\n\nlet (pool_max_size : int) = (3000 : int)\n\nlet (account_creation_fee_int : string) = (\"0.001\" : string)\n\nlet (default_transaction_fee : string) = (\"5\" : string)\n\nlet (default_snark_worker_fee : string) = (\"1\" : string)\n\nlet (minimum_user_command_fee : string) = (\"2\" : string)\n\nlet (supercharged_coinbase_factor : int) = (1 : int)\n\nlet (plugins : bool) = (true : bool)\n\nlet (genesis_state_timestamp : string) = (\"2019-01-30 12:00:00-08:00\" : string)\n\nlet (block_window_duration : int) = (2000 : int)\n\nlet (itn_features : bool) = (true : bool)\n\nlet compaction_interval = None\n\nlet (network : string) = (\"testnet\" : string)\n\nlet (vrf_poll_interval : int) = (0 : int)\n\nlet zkapp_cmd_limit = None\n\nlet scan_state_tps_goal_x10 : int option = None\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","open 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 let balance_change obj' =\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 in\n needs_custom_js\n ~js_type:(js_leaf (Custom \"BalanceChange\"))\n ~name:\"BalanceChange\" balance_change obj\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\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\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 *)\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\nlet zero = dummy\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","open 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 ()\nend\n\nmodule Fork_constants = struct\n type t =\n { state_hash : Pickles.Backend.Tick.Field.Stable.Latest.t\n ; blockchain_length : Mina_numbers.Length.Stable.Latest.t\n ; global_slot_since_genesis :\n Mina_numbers.Global_slot_since_genesis.Stable.Latest.t\n }\n [@@deriving bin_io_unversioned, sexp, equal, compare, yojson]\nend\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 { blockchain_length; state_hash; global_slot_since_genesis } ->\n Some\n { blockchain_length = Unsigned.UInt32.to_int blockchain_length\n ; state_hash = Pickles.Backend.Tick.Field.to_string state_hash\n ; global_slot_since_genesis =\n Unsigned.UInt32.to_int\n (Mina_numbers.Global_slot_since_genesis.to_uint32\n global_slot_since_genesis )\n }\n | None ->\n None )\n }\nend\n\nmodule Helpers = struct\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\n let 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\n let of_time t =\n Time.to_span_since_epoch t |> Time.Span.to_ms |> Int64.of_float\n\n let to_time t =\n t |> Int64.to_float |> Time.Span.of_ms |> Time.of_span_since_epoch\n\n let 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 \\\n UTC-08:00 timezone\"\n\n let 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))\nend\n\ninclude Helpers\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 ; grace_period_slots : '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 ; (\"grace_period_slots\", `Int t.grace_period_slots)\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 ; (\"grace_period_slots\", `Int grace_period_slots)\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 ; grace_period_slots\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 ; grace_period_slots = t.grace_period_slots\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 ; zkapp_cmd_limit_hardcap : int\n ; minimum_user_command_fee : Currency.Fee.Stable.Latest.t\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\nmodule type S = sig\n module Proof_level : sig\n include module type of Proof_level with type t = Proof_level.t\n\n val t : t\n end\n\n module Fork_constants = Fork_constants\n\n module Constraint_constants : sig\n include\n module type of Constraint_constants with type t = Constraint_constants.t\n\n val t : t\n end\n\n val genesis_timestamp_of_string : string -> Time.t\n\n val of_time : Time.t -> int64\n\n val to_time : int64 -> Time.t\n\n val validate_time : string option -> (int64, string) result\n\n val genesis_timestamp_to_string : int64 -> string\n\n module Protocol = Protocol\n\n include module type of T with type t = T.t\n\n val genesis_state_timestamp_string : string\n\n val k : int\n\n val slots_per_epoch : int\n\n val slots_per_sub_window : int\n\n val grace_period_slots : int\n\n val delta : int\n\n val pool_max_size : int\n\n val t : t\nend\n\nmodule Make (Node_config : Node_config_intf.S) : S = struct\n module Proof_level = struct\n include Proof_level\n\n let t = of_string Node_config.proof_level\n end\n\n module Fork_constants = Fork_constants\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 *)\n module Constraint_constants = struct\n include Constraint_constants\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 (** 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 let transaction_capacity_log_2 =\n match\n ( Node_config.scan_state_with_tps_goal\n , Node_config.scan_state_tps_goal_x10 )\n with\n | true, Some tps_goal_x10 ->\n let max_coinbases = 2 in\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 * Node_config.block_window_duration / (1000 * 10)\n in\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 1\n + Core_kernel.Int.ceil_log2\n (max_user_commands_per_block + max_coinbases)\n | _ -> (\n match Node_config.scan_state_transaction_capacity_log_2 with\n | Some a ->\n a\n | None ->\n failwith\n \"scan_state_transaction_capacity_log_2 must be set if \\\n scan_state_with_tps_goal is false\" )\n\n let supercharged_coinbase_factor =\n Node_config.supercharged_coinbase_factor\n\n let pending_coinbase_depth =\n Core_kernel.Int.ceil_log2\n ( (transaction_capacity_log_2 + 1)\n * (Node_config.scan_state_work_delay + 1)\n + 1 )\n\n let t =\n { sub_windows_per_window = Node_config.sub_windows_per_window\n ; ledger_depth = Node_config.ledger_depth\n ; work_delay = Node_config.scan_state_work_delay\n ; block_window_duration_ms = Node_config.block_window_duration\n ; transaction_capacity_log_2\n ; pending_coinbase_depth\n ; coinbase_amount =\n Currency.Amount.of_mina_string_exn Node_config.coinbase\n ; supercharged_coinbase_factor\n ; account_creation_fee =\n Currency.Fee.of_mina_string_exn\n Node_config.account_creation_fee_int\n ; fork = None\n }\n end :\n sig\n val t : t\n end )\n end\n\n include Helpers\n module Protocol = Protocol\n include T\n\n let genesis_state_timestamp_string = Node_config.genesis_state_timestamp\n\n let k = Node_config.k\n\n let slots_per_epoch = Node_config.slots_per_epoch\n\n let slots_per_sub_window = Node_config.slots_per_sub_window\n\n let grace_period_slots = Node_config.grace_period_slots\n\n let delta = Node_config.delta\n\n let pool_max_size = Node_config.pool_max_size\n\n let t : t =\n { protocol =\n { k\n ; slots_per_epoch\n ; slots_per_sub_window\n ; grace_period_slots\n ; delta\n ; genesis_state_timestamp =\n genesis_timestamp_of_string genesis_state_timestamp_string\n |> of_time\n }\n ; txpool_max_size = pool_max_size\n ; num_accounts = None\n ; zkapp_proof_update_cost = Node_config.zkapp_proof_update_cost\n ; zkapp_signed_single_update_cost =\n Node_config.zkapp_signed_single_update_cost\n ; zkapp_signed_pair_update_cost = Node_config.zkapp_signed_pair_update_cost\n ; zkapp_transaction_cost_limit = Node_config.zkapp_transaction_cost_limit\n ; max_event_elements = Node_config.max_event_elements\n ; max_action_elements = Node_config.max_action_elements\n ; zkapp_cmd_limit_hardcap = Node_config.zkapp_cmd_limit_hardcap\n ; minimum_user_command_fee =\n Currency.Fee.of_mina_string_exn Node_config.minimum_user_command_fee\n }\nend\n\nmodule For_unit_tests = Make (Node_config_for_unit_tests)\n\nmodule Compiled : sig\n val genesis_constants : t\n\n val constraint_constants : Constraint_constants.t\n\n val proof_level : Proof_level.t\nend = struct\n include Make (Node_config)\n\n let genesis_constants = t\n\n let constraint_constants = Constraint_constants.t\n\n let proof_level = Proof_level.t\nend\n","open 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 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 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 let now offset = of_time (Time.sub (Time.now ()) (offset ()))\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 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 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","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.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 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 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 [%%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 [%%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 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 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 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\nend\n\ninclude Wire_types.Make (Make_sig) (Make_str)\n","open 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.Latest.t\n , Global_slot_span.Stable.Latest.t\n , Balance.Stable.Latest.t\n , Amount.Stable.Latest.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 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\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","open 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\ntype var = Field.Var.t * Inner_curve.Scalar.var\n\n[%%define_locally\nStable.Latest.\n (of_base58_check_exn, of_base58_check, of_yojson, to_yojson, to_base58_check)]\n","open Core_kernel\n\n(* TODO: temporary hack *)\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\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\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","(* payment_payload.ml *)\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\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\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","open Core_kernel\nopen Mina_base_util\nopen Snark_params.Tick\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 let verification_key_perm_fallback_to_signature_with_older_version = function\n | Impossible | Proof ->\n Signature\n | t ->\n t\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 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 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 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\n let verification_key_perm_fallback_to_signature_with_older_version\n ({ signature_sufficient; _ } as t : t) =\n if_\n Pickles.Impls.Step.Boolean.(not signature_sufficient)\n ~then_:(constant Signature) ~else_:t\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 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, 'txn_version) t =\n ( 'controller\n , 'txn_version )\n 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 * 'txn_version\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 txn_version 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)\n ~set_verification_key:\n (f (fun (c, v) ->\n Random_oracle.Input.Chunked.append (controller c) (txn_version v) )\n )\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 =\n ( Auth_required.Stable.V2.t\n , Mina_numbers.Txn_version.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\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 = auth_required_gen in\n let txn_version =\n Mina_numbers.Txn_version.of_int @@ Protocol_version.(transaction current)\n 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 = (set_verification_key_auth, txn_version)\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\nmodule Checked = struct\n type t =\n ( Auth_required.Checked.t\n , Mina_numbers.Txn_version.Checked.t )\n Poly.Stable.Latest.t\n\n let to_input (x : t) =\n Poly.to_input Auth_required.Checked.to_input\n Mina_numbers.Txn_version.Checked.to_input x\n\n let if_ b ~(then_ : t) ~(else_ : t) : t Snark_params.Tick.Checked.t =\n let open Snark_params.Tick in\n let edit_state =\n Auth_required.Checked.if_ b ~then_:then_.edit_state\n ~else_:else_.edit_state\n in\n let send =\n Auth_required.Checked.if_ b ~then_:then_.send ~else_:else_.send\n in\n let receive =\n Auth_required.Checked.if_ b ~then_:then_.receive ~else_:else_.receive\n in\n let set_delegate =\n Auth_required.Checked.if_ b ~then_:then_.set_delegate\n ~else_:else_.set_delegate\n in\n let set_permissions =\n Auth_required.Checked.if_ b ~then_:then_.set_permissions\n ~else_:else_.set_permissions\n in\n let set_verification_key_auth =\n Auth_required.Checked.if_ b\n ~then_:(fst then_.set_verification_key)\n ~else_:(fst else_.set_verification_key)\n in\n let%map txn_version =\n Mina_numbers.Txn_version.Checked.if_ b\n ~then_:(snd then_.set_verification_key)\n ~else_:(snd else_.set_verification_key)\n in\n let set_zkapp_uri =\n Auth_required.Checked.if_ b ~then_:then_.set_zkapp_uri\n ~else_:else_.set_zkapp_uri\n in\n let edit_action_state =\n Auth_required.Checked.if_ b ~then_:then_.edit_action_state\n ~else_:else_.edit_action_state\n in\n let set_token_symbol =\n Auth_required.Checked.if_ b ~then_:then_.set_token_symbol\n ~else_:else_.set_token_symbol\n in\n let increment_nonce =\n Auth_required.Checked.if_ b ~then_:then_.increment_nonce\n ~else_:else_.increment_nonce\n in\n let set_voting_for =\n Auth_required.Checked.if_ b ~then_:then_.set_voting_for\n ~else_:else_.set_voting_for\n in\n let set_timing =\n Auth_required.Checked.if_ b ~then_:then_.set_timing\n ~else_:else_.set_timing\n in\n let access =\n Auth_required.Checked.if_ b ~then_:then_.access ~else_:else_.access\n in\n { Poly.edit_state\n ; send\n ; receive\n ; set_delegate\n ; set_permissions\n ; set_verification_key = (set_verification_key_auth, txn_version)\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 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\n ~set_verification_key:(fun f ->\n let auth, txn_version = get f t in\n ( Auth_required.Checked.constant auth\n , Mina_numbers.Txn_version.Checked.constant txn_version ) )\n ~set_zkapp_uri:a ~edit_action_state:a ~set_token_symbol:a\n ~increment_nonce:a ~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 ; Typ.tuple2 Auth_required.typ Mina_numbers.Txn_version.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\nlet to_input (x : t) =\n Poly.to_input Auth_required.to_input Mina_numbers.Txn_version.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, Mina_numbers.Txn_version.current)\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, Mina_numbers.Txn_version.current)\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\nmodule As_record = struct\n type t = { auth : Auth_required.t; txn_version : Mina_numbers.Txn_version.t }\n [@@deriving fields, annot]\n\n let deriver obj =\n let open Fields_derivers_zkapps.Derivers in\n let ( !. ) = ( !. ) ~t_fields_annots in\n let transaction_version =\n needs_custom_js ~js_type:uint32 ~name:\"TransactionVersion\" uint32\n in\n Fields.make_creator obj ~auth:!.auth_required\n ~txn_version:!.transaction_version\n |> finish \"VerificationKeyPermission\" ~t_toplevel_annots\nend\n\nlet to_record (auth, txn_version) = { As_record.auth; txn_version }\n\nlet of_record { As_record.auth; txn_version } = (auth, txn_version)\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\n ~set_verification_key:!.(iso_record ~to_record ~of_record As_record.deriver)\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: {\n auth: \"Signature\",\n txnVersion: \"3\"\n },\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\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 = Bounded_types.String.Tagged.Stable.V1.t\n [@@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 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 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 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 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","open 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 *)\nopen Core_kernel\nopen Snark_params.Tick\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 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)\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 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 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 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)\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\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","(* user_command_payload.ml *)\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 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 }\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 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\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","open 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 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 signature Poly.{ signature; _ } = signature\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 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)\n ?(min_fee = Genesis_constants.For_unit_tests.t.minimum_user_command_fee)\n ~fee_range create_body =\n let open Quickcheck.Generator.Let_syntax in\n let min_fee = Fee.to_nanomina_int min_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 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 ?min_fee ~fee_range () =\n gen_inner sign' ~key_gen ?nonce ?min_fee ~fee_range\n @@ fun { 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 ?min_fee ~fee_range =\n with_random_participants ~keys ~gen:(fun ~key_gen ->\n gen ?sign_type ~key_gen ?nonce ?min_amount ~max_amount ?min_fee\n ~fee_range )\n end\n\n module Stake_delegation = struct\n let gen ~key_gen ?nonce ?min_fee ~fee_range () =\n gen_inner For_tests.fake_sign ~key_gen ?nonce ?min_fee ~fee_range\n (fun { 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 ?min_fee ~fee_range =\n with_random_participants ~keys ~gen:(gen ?nonce ?min_fee ~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\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.Legacy.(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 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\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","open Core_kernel\n\nlet field_of_bool = Mina_base_util.field_of_bool\n\nopen Snark_params.Tick\nopen Signature_lib\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 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\nend\n\nmodule Flagged_data = struct\n type ('flag, 'a) t = { flag : 'flag; data : 'a } [@@deriving hlist, fields]\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 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 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 let lazy_option_typ ~default t =\n Typ.transport (typ t)\n ~there:(fun t -> of_option t ~default:(Lazy.force default))\n ~back:to_option\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 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 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 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\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 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\nend\n\nmodule F = Pickles.Backend.Tick.Field\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","open 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 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 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 =\n Hash_prefix_create.salt Inputs.salt_phrase |> Random_oracle.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 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 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 Hash_prefix_create.salt salt_phrase |> Random_oracle.digest\n\n let push_events (acc : Field.t) (events : t) : Field.t =\n push_hash acc (hash events)\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 |]\nend\n\nmodule Zkapp_uri = struct\n [%%versioned_binable\n module Stable = struct\n module V1 = struct\n module T = struct\n type t = Bounded_types.String.Stable.V1.t\n [@@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 (Bounded_types.String.Stable.V1)\n (struct\n type t = Bounded_types.String.Stable.V1.t\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\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.lazy_option_typ\n ~default:(lazy { 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\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%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\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 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\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 = Bounded_types.String.Stable.V1.t\n [@@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 (Bounded_types.String.Stable.V1)\n (struct\n type t = Bounded_types.String.Stable.V1.t\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 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_\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\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 : Public_key.Compressed.Stable.V1.t\n ; token_id : Token_id.Stable.V2.t\n ; token_symbol : Token_symbol.Stable.V1.t\n ; balance : Balance.Stable.V1.t\n ; nonce : Nonce.Stable.V1.t\n ; receipt_chain_hash : Receipt.Chain_hash.Stable.V1.t\n ; delegate : Public_key.Compressed.Stable.V1.t option\n ; voting_for : State_hash.Stable.V1.t\n ; timing : Timing.Stable.V2.t\n ; permissions : Permissions.Stable.V2.t\n ; zkapp : Zkapp_account.Stable.V2.t option\n }\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 { public_key : Public_key.Compressed.Stable.V1.t\n ; token_id : Token_id.Stable.V2.t\n ; token_symbol : Token_symbol.Stable.V1.t\n ; balance : Balance.Stable.V1.t\n ; nonce : Nonce.Stable.V1.t\n ; receipt_chain_hash : Receipt.Chain_hash.Stable.V1.t\n ; delegate : Public_key.Compressed.Stable.V1.t option\n ; voting_for : State_hash.Stable.V1.t\n ; timing : Timing.Stable.V2.t\n ; permissions : Permissions.Stable.V2.t\n ; zkapp : Zkapp_account.Stable.V2.t option\n }\n [@@deriving sexp, equal, hash, compare, yojson, hlist, fields]\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\nStable.Latest.(sexp_of_t, t_of_sexp, equal, to_yojson, of_yojson)]\n\nlet to_poly\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 { Poly.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\nlet of_poly\n { Poly.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 { 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\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 = t [@@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 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\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:to_hlist ~value_of_hlist: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\nlet digest = crypto_hash\n\nlet empty =\n { 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 = lazy (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 { 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 { 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\nlet initial_minimum_balance { timing; _ } =\n match timing with\n | Timing.Untimed ->\n None\n | Timed t ->\n Some t.initial_minimum_balance\n\nlet cliff_time { timing; _ } =\n match timing with Timing.Untimed -> None | Timed t -> Some t.cliff_time\n\nlet cliff_amount { 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\ntype t = Value.Stable.V1.t [@@deriving sexp, compare, equal, hash, yojson]\n\ninclude Comparable.Make (Value.Stable.V1)\n","open Core_kernel\nopen Snark_params.Tick\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 nonce (n : Account.Nonce.t) =\n let nonce : _ Numeric.t = Check { lower = n; upper = n } in\n { accept with nonce }\n\n let is_nonce (t : t) =\n match t.nonce with\n | Ignore ->\n false\n | Check { lower; upper } ->\n (* nonce is exact, all other fields are Ignore *)\n Mina_numbers.Account_nonce.equal lower upper\n && is_accept { t with nonce = Ignore }\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.For_unit_tests.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.t.protocol.slots_per_sub_window\n * Genesis_constants.For_unit_tests.Constraint_constants.t\n .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 lazy_optional_typ ~hash ~non_preimage ~dummy_value =\n Typ.transport\n Typ.(Field.typ * Internal.ref ())\n ~there:(function\n | None -> (Lazy.force non_preimage, dummy_value) | Some s -> (hash s, s)\n )\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","open Core_kernel\nopen Mina_base_util\nopen Snark_params.Tick\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 Events = Zkapp_account.Events\nmodule Actions = Zkapp_account.Actions\nmodule Zkapp_uri = Zkapp_account.Zkapp_uri\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 (Field.t[@version_asserted])\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 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 ( !. ) = ( !. ) ~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 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 module Checked = Structured.Checked\n\n let typ =\n Structured.typ |> Typ.transport ~there:to_structured ~back:of_structured_exn\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 let may_use_token =\n iso_record ~of_record:As_record.to_variant ~to_record:As_record.of_variant\n As_record.deriver\n in\n needs_custom_js\n ~js_type:\n (js_record\n [ (\"parentsOwnToken\", js_layout bool)\n ; (\"inheritFromParent\", js_layout bool)\n ] )\n ~name:\"MayUseToken\" may_use_token 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 : Zkapp_uri.Stable.V1.t 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.lazy_optional_typ ~hash:Zkapp_account.hash_zkapp_uri\n ~non_preimage:(lazy (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 Account_precondition = struct\n [%%versioned\n module Stable = struct\n module V1 = struct\n type t = Zkapp_precondition.Account.Stable.V2.t\n [@@deriving sexp, yojson, hash]\n\n let (_ :\n ( t\n , Mina_wire_types.Mina_base.Account_update.Account_precondition.V1.t\n )\n Type_equal.t ) =\n Type_equal.T\n\n let to_latest = Fn.id\n\n [%%define_locally Zkapp_precondition.Account.(equal, compare)]\n end\n end]\n\n [%%define_locally Stable.Latest.(equal, compare)]\n\n let gen : t Quickcheck.Generator.t =\n (* we used to have 3 constructors, Full, Nonce, and Accept for the type t\n nowadays, the generator creates these 3 different kinds of values, but all mapped to t\n *)\n Quickcheck.Generator.variant3 Zkapp_precondition.Account.gen\n Account.Nonce.gen Unit.quickcheck_generator\n |> Quickcheck.Generator.map ~f:(function\n | `A precondition ->\n precondition\n | `B n ->\n Zkapp_precondition.Account.nonce n\n | `C () ->\n Zkapp_precondition.Account.accept )\n\n module Tag = struct\n type t = Full | Nonce | Accept [@@deriving equal, compare, sexp, yojson]\n end\n\n let deriver obj = 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 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 Zkapp_precondition.Account.typ ()\n\n let nonce ({ nonce; _ } : t) = nonce\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 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 = Zkapp_precondition.Account.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 =\n Pickles.Backend.Tick.Field.Stable.V1.t\n Bounded_types.ArrayN16.Stable.V1.t\n 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 = Zkapp_precondition.Account.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 = Zkapp_precondition.Account.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; preconditions; balance_change; _ } = t in\n let fee =\n Currency.Fee.of_uint64\n (balance_change.magnitude |> Currency.Amount.to_uint64)\n in\n let nonce =\n if Zkapp_precondition.Account.is_nonce preconditions.account then\n match preconditions.account.nonce with\n | Check { lower; upper = _ } ->\n lower\n | Ignore ->\n failwith \"Unexpected Ignore for fee payer precondition nonce\"\n else 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 ?chain (t : t) =\n Random_oracle.Checked.(\n hash ~init:(Hash_prefix.zkapp_body ?chain) (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 ?chain (t : t) =\n Random_oracle.(\n hash ~init:(Hash_prefix.zkapp_body ?chain) (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 ?chain (t : t) = Body.digest ?chain t.body\n\n module Checked = struct\n type t = Body.Checked.t\n\n let digest ?chain (t : t) = Body.Checked.digest ?chain 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 :\n ?chain:Mina_signature_kind.t -> Account_update.Checked.t -> t\n\n val create_body :\n ?chain:Mina_signature_kind.t -> 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 : ?chain:Mina_signature_kind.t -> Account_update.t -> t\n\n val create_body :\n ?chain:Mina_signature_kind.t -> 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_types = struct\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 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 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 end\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 include Make_digest_types.Account_update\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 : ?chain:Mina_signature_kind.t -> Account_update.t -> t =\n Account_update.digest\n\n let create_body :\n ?chain:Mina_signature_kind.t -> Account_update.Body.t -> t =\n Account_update.Body.digest\n end\n\n module Forest = struct\n include Make_digest_types.Forest\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 include Make_digest_types.Tree\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 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 = 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) : (Account_id.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 (Account_update.account_id p, 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 load_vk_from_ledger :\n location_of_account:(Account_id.t -> 'loc option)\n -> get:('loc -> Account.t option)\n -> Zkapp_basic.F.t\n -> Account_id.t\n -> Verification_key_wire.t Or_error.t\n\n val load_vks_from_ledger :\n location_of_account_batch:\n (Account_id.t list -> (Account_id.t * 'loc option) list)\n -> get_batch:('loc list -> ('loc * Account.t option) list)\n -> Account_id.t list\n -> Verification_key_wire.t Account_id.Map.t\n\n val create :\n T.t\n -> failed:bool\n -> find_vk:\n (Zkapp_basic.F.t -> Account_id.t -> Verification_key_wire.t Or_error.t)\n -> t Or_error.t\n\n module type Command_wrapper_intf = sig\n type 'a t\n\n val unwrap : 'a t -> 'a\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val is_failed : 'a t -> bool\n end\n\n module type Create_all_intf = sig\n type cache\n\n module Command_wrapper : Command_wrapper_intf\n\n val create_all :\n T.t Command_wrapper.t list -> cache -> t Command_wrapper.t list Or_error.t\n end\n\n module From_unapplied_sequence :\n Create_all_intf\n with type 'a Command_wrapper.t = 'a\n and type cache =\n Verification_key_wire.t Zkapp_basic.F_map.Map.t Account_id.Map.t\n\n module From_applied_sequence :\n Create_all_intf\n with type 'a Command_wrapper.t = 'a With_status.t\n and type cache = Verification_key_wire.t Account_id.Map.t\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 load_vk_from_ledger ~location_of_account ~get expected_vk_hash account_id\n =\n match\n let open Option.Let_syntax in\n let%bind location = location_of_account account_id in\n let%bind (account : Account.t) = get 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 let load_vks_from_ledger ~location_of_account_batch ~get_batch account_ids =\n let locations =\n location_of_account_batch account_ids |> List.filter_map ~f:snd\n in\n get_batch locations\n |> List.filter_map ~f:(fun ((_, account) : _ * Account.t option) ->\n let open Option.Let_syntax in\n let account = Option.value_exn account in\n let%bind zkapp = account.zkapp in\n let%map verification_key = zkapp.verification_key in\n (Account.identifier account, verification_key) )\n |> Account_id.Map.of_alist_exn\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) ~failed ~find_vk :\n 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 (p.body.authorization_kind, failed) with\n | Proof vk_hash, false -> (\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 type Cache_intf = sig\n type t\n\n val find :\n t\n -> account_id:Account_id.t\n -> vk_hash:Zkapp_basic.F.t\n -> Verification_key_wire.t option\n\n val add : t -> account_id:Account_id.t -> vk:Verification_key_wire.t -> t\n end\n\n module type Command_wrapper_intf = sig\n type 'a t\n\n val unwrap : 'a t -> 'a\n\n val map : 'a t -> f:('a -> 'b) -> 'b t\n\n val is_failed : 'a t -> bool\n end\n\n module type Create_all_intf = sig\n type cache\n\n module Command_wrapper : Command_wrapper_intf\n\n val create_all :\n T.t Command_wrapper.t list -> cache -> t Command_wrapper.t list Or_error.t\n end\n\n module Make_create_all\n (Cache : Cache_intf)\n (Command_wrapper : Command_wrapper_intf) :\n Create_all_intf\n with module Command_wrapper := Command_wrapper\n and type cache = Cache.t = struct\n type cache = Cache.t\n\n let create_all (wrapped_cmds : T.t Command_wrapper.t list)\n (init_cache : Cache.t) : t Command_wrapper.t list Or_error.t =\n Or_error.try_with (fun () ->\n snd (* remove the helper cache we folded with *)\n (List.fold_map wrapped_cmds ~init:init_cache\n ~f:(fun running_cache wrapped_cmd ->\n let cmd = Command_wrapper.unwrap wrapped_cmd in\n let cmd_failed = Command_wrapper.is_failed wrapped_cmd in\n let verified_cmd : t =\n create cmd ~failed:cmd_failed\n ~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 ~account_id ~vk_hash with\n | None ->\n Error\n (Error.of_string\n \"verification key not found in cache\" )\n | Some vk ->\n Ok vk )\n |> Or_error.ok_exn\n in\n let running_cache' =\n (* update the cache if the command is not failed *)\n if not cmd_failed then\n List.fold (extract_vks cmd) ~init:running_cache\n ~f:(fun acc (account_id, vk) ->\n Cache.add acc ~account_id ~vk )\n else running_cache\n in\n ( running_cache'\n , Command_wrapper.map wrapped_cmd ~f:(Fn.const verified_cmd) ) )\n ) )\n end\n\n (* There are 2 situations in which we are converting commands to their verifiable format:\n - we are reasoning about the validity of commands when the sequence is not yet known\n - we are reasoning about the validity of commands when the sequence (and by extension, status) is known\n *)\n\n module From_unapplied_sequence = struct\n module Cache = struct\n type t = Verification_key_wire.t Zkapp_basic.F_map.Map.t Account_id.Map.t\n\n let find (t : t) ~account_id ~vk_hash =\n let%bind.Option vks = Map.find t account_id in\n Map.find vks vk_hash\n\n let add (t : t) ~account_id ~(vk : Verification_key_wire.t) =\n Map.update t account_id ~f:(fun vks_opt ->\n let vks =\n Option.value vks_opt ~default:Zkapp_basic.F_map.Map.empty\n in\n Map.set vks ~key:vk.hash ~data:vk )\n end\n\n module Command_wrapper : Command_wrapper_intf with type 'a t = 'a = struct\n type 'a t = 'a\n\n let unwrap t = t\n\n let map t ~f = f t\n\n let is_failed _ = false\n end\n\n include Make_create_all (Cache) (Command_wrapper)\n end\n\n module From_applied_sequence = struct\n module Cache = struct\n type t = Verification_key_wire.t Account_id.Map.t\n\n let find (t : t) ~account_id ~vk_hash =\n let%bind.Option vk = Map.find t account_id in\n Option.some_if (Zkapp_basic.F.equal vk_hash vk.hash) vk\n\n let add (t : t) ~account_id ~vk = Map.set t ~key:account_id ~data:vk\n end\n\n module Command_wrapper :\n Command_wrapper_intf with type 'a t = 'a With_status.t = struct\n type 'a t = 'a With_status.t\n\n let unwrap = With_status.data\n\n let map { With_status.status; data } ~f =\n { With_status.status; data = f data }\n\n let is_failed { With_status.status; _ } =\n match status with Applied -> false | Failed _ -> true\n end\n\n include Make_create_all (Cache) (Command_wrapper)\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 -> failed:bool\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) ~failed ~find_vk : t Or_error.t =\n Verifiable.create t ~failed ~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 lazy\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 is_incompatible_version t =\n Call_forest.exists t.account_updates ~f:(fun p ->\n match p.body.update.permissions with\n | Keep ->\n false\n | Set { set_verification_key = _auth, txn_version; _ } ->\n not Mina_numbers.Txn_version.(equal_to_current txn_version) )\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) ~failed ~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 ~failed ~find_vk cmd\n |> Or_error.map ~f:(fun cmd -> Zkapp_command cmd)\n\nmodule Make_to_all_verifiable\n (Strategy : Zkapp_command.Verifiable.Create_all_intf) =\nstruct\n let to_all_verifiable (ts : t Strategy.Command_wrapper.t list) ~load_vk_cache\n : Verifiable.t Strategy.Command_wrapper.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 Strategy.Command_wrapper.unwrap cmd with\n | Zkapp_command c ->\n First (i, Strategy.Command_wrapper.map cmd ~f:(Fn.const c))\n | Signed_command c ->\n Second (i, Strategy.Command_wrapper.map cmd ~f:(Fn.const 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 (* TODO: we could optimize this by skipping the fee payer and non-proof authorizations *)\n let accounts_referenced =\n List.fold_left zk_cmds ~init:Account_id.Set.empty ~f:(fun set zk_cmd ->\n Strategy.Command_wrapper.unwrap zk_cmd\n |> Zkapp_command.accounts_referenced |> Account_id.Set.of_list\n |> Set.union set )\n in\n let vk_cache = load_vk_cache accounts_referenced in\n let%map vzk_cmds = Strategy.create_all zk_cmds vk_cache 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, Strategy.Command_wrapper.map cmd ~f:(fun c -> Signed_command c)) )\n @ List.map ivzk_cmds ~f:(fun (i, cmd) ->\n (i, Strategy.Command_wrapper.map cmd ~f:(fun c -> Zkapp_command c)) )\n |> List.sort ~compare:(fun (i, _) (j, _) -> i - j)\n in\n (* Drop the indices *)\n List.unzip ivs |> snd\nend\n\nmodule Unapplied_sequence =\n Make_to_all_verifiable (Zkapp_command.Verifiable.From_unapplied_sequence)\nmodule Applied_sequence =\n Make_to_all_verifiable (Zkapp_command.Verifiable.From_applied_sequence)\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\nlet has_insufficient_fee ~minimum_fee t = Currency.Fee.(fee t < minimum_fee)\n\nlet is_disabled = function\n | Zkapp_command _ ->\n Node_config_unconfigurable_constants.zkapps_disabled\n | _ ->\n false\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 -> (Account_id.t * Verification_key_wire.t) List.t =\n 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 ~failed ~find_vk (t : t) : Valid.t Or_error.t =\n to_verifiable ~failed ~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\nlet is_incompatible_version = function\n | Signed_command _ ->\n false\n | Zkapp_command p ->\n Zkapp_command.is_incompatible_version p\n\nlet has_invalid_call_forest : t -> bool = function\n | Signed_command _ ->\n false\n | Zkapp_command cmd ->\n List.exists cmd.account_updates ~f:(fun call_forest ->\n let root_may_use_token =\n call_forest.elt.account_update.body.may_use_token\n in\n not (Account_update.May_use_token.equal root_may_use_token No) )\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 | Zkapp_invalid_call_forest\n | Transaction_type_disabled\n | Incompatible_version\n [@@deriving compare, to_yojson, sexp]\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)\n | Zkapp_invalid_call_forest ->\n \"Zkapp has an invalid call forest (root account updates may not use \\\n tokens)\"\n | Incompatible_version ->\n \"Set verification-key permission is updated to an incompatible version\"\n | Transaction_type_disabled ->\n \"Transaction type disabled\"\nend\n\nlet check_well_formedness ~(genesis_constants : Genesis_constants.t) t :\n (unit, Well_formedness_error.t list) result =\n let preds =\n let open Well_formedness_error in\n [ ( has_insufficient_fee\n ~minimum_fee:genesis_constants.minimum_user_command_fee\n , Insufficient_fee )\n ; (has_zero_vesting_period, Zero_vesting_period)\n ; (is_incompatible_version, Incompatible_version)\n ; (is_disabled, Transaction_type_disabled)\n ; (has_invalid_call_forest, Zkapp_invalid_call_forest)\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\ntype fee_payer_summary_t = Signature.t * Account.key * int\n[@@deriving yojson, hash]\n\nlet fee_payer_summary : t -> fee_payer_summary_t = function\n | Zkapp_command cmd ->\n let fp = Zkapp_command.fee_payer_account_update cmd in\n let open Account_update in\n let body = Fee_payer.body fp in\n ( Fee_payer.authorization fp\n , Body.Fee_payer.public_key body\n , Body.Fee_payer.nonce body |> Unsigned.UInt32.to_int )\n | Signed_command cmd ->\n Signed_command.\n (signature cmd, fee_payer_pk cmd, nonce cmd |> Unsigned.UInt32.to_int)\n\nlet fee_payer_summary_json =\n Fn.compose fee_payer_summary_t_to_yojson fee_payer_summary\n\nlet fee_payer_summary_string =\n let to_string (signature, pk, nonce) =\n sprintf \"%s (%s %d)\"\n (Signature.to_base58_check signature)\n (Signature_lib.Public_key.Compressed.to_base58_check pk)\n nonce\n in\n Fn.compose to_string fee_payer_summary\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 (* The order of this list will impact the order of new accounts in the\n ledger witness. We use `List.rev` to have the same order as the tx\n application (in `apply_coinbase`) where the \"coinbase fee transfer\"\n receiver is created before the \"coinbase\" receiver.\n *)\n List.map account_ids ~f:(fun acct_id -> (acct_id, access_status))\n |> List.rev\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, to_yojson, compare, equal]\n end\n end]\n\n val of_yojson : Yojson.Safe.t -> (t, string) result\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 = Hash_prefix_create.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 let init (t : t) = t.init\n\n let curr (t : t) = t.curr\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 Hash_prefix_create.salt \"PendingCoinbaseMerkleTree\"\n |> Random_oracle.digest |> of_hash\n\n let of_digest = 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\n let data (t : t) = t.data\n\n let state (t : t) = t.state\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 (* the type below triggers the ppx derivers to insert unused `rec` flags, so we ignore such warnings *)\n [@@@warning \"-39\"]\n\n type t = Hash_builder.t constraint t = Hash_versioned.t\n [@@deriving equal, compare, sexp, yojson, hash]\n\n [@@@warning \"+39\"]\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 hash_at_level =\n let cached = ref [||] in\n fun i ->\n let len = Array.length !cached in\n let len =\n if len = 0 then (\n cached := [| Stack.data_hash Stack.empty |] ;\n 1 )\n else len\n 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.For_unit_tests.Constraint_constants.t\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.For_unit_tests.Constraint_constants.t\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.For_unit_tests.Constraint_constants.t\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.For_unit_tests.Constraint_constants.t\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.For_unit_tests.Constraint_constants.t 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","open 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 = Bounded_types.String.Stable.V1.t\n [@@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 = Bounded_types.String.Stable.V1.t\n [@@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 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 (* TODO: We could just use a prover value. *)\n printf \"WARNING: improperly transporting staged-ledger-hash\\n\" ;\n 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 = Bounded_types.String.Stable.V1.t\n [@@deriving sexp, hash, compare, equal, yojson]\n\n let to_latest = Fn.id\n\n include\n Binable.Of_binable_without_uuid\n (Bounded_types.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","open 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\n and slots_per_sub_window = Int.gen_incl 1 ((k + 9) / 9) in\n let%bind grace_period_slots = Int.gen_incl 0 ((slots_per_epoch / 3) - 1) 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 = T.of_int slots_per_epoch\n ; slots_per_sub_window = T.of_int slots_per_sub_window\n ; grace_period_slots = T.of_int grace_period_slots\n ; genesis_state_timestamp\n }\nend\n\ntype value = Value.t\n\nlet value_of_t\n ({ k\n ; delta\n ; slots_per_epoch\n ; slots_per_sub_window\n ; grace_period_slots\n ; genesis_state_timestamp\n } :\n Genesis_constants.Protocol.t ) : value =\n { k = T.of_int k\n ; delta = T.of_int delta\n ; slots_per_epoch = T.of_int slots_per_epoch\n ; slots_per_sub_window = T.of_int slots_per_sub_window\n ; grace_period_slots = T.of_int grace_period_slots\n ; genesis_state_timestamp = Block_time.of_int64 genesis_state_timestamp\n }\n\nlet t_of_value\n ({ k\n ; delta\n ; slots_per_epoch\n ; slots_per_sub_window\n ; grace_period_slots\n ; genesis_state_timestamp\n } :\n value ) : Genesis_constants.Protocol.t =\n { k = T.to_int k\n ; delta = T.to_int delta\n ; slots_per_epoch = T.to_int slots_per_epoch\n ; slots_per_sub_window = T.to_int slots_per_sub_window\n ; grace_period_slots = T.to_int grace_period_slots\n ; genesis_state_timestamp = Block_time.to_int64 genesis_state_timestamp\n }\n\nlet to_input\n ({ k\n ; delta\n ; slots_per_epoch\n ; slots_per_sub_window\n ; grace_period_slots\n ; genesis_state_timestamp\n } :\n value ) =\n Array.reduce_exn ~f:Random_oracle.Input.Chunked.append\n [| T.to_input k\n ; T.to_input delta\n ; T.to_input slots_per_epoch\n ; T.to_input slots_per_sub_window\n ; T.to_input grace_period_slots\n ; Block_time.to_input genesis_state_timestamp\n |]\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 ; 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\n ({ k\n ; delta\n ; slots_per_epoch\n ; slots_per_sub_window\n ; grace_period_slots\n ; genesis_state_timestamp\n } :\n var ) =\n let k = T.Checked.to_input k\n and delta = T.Checked.to_input delta\n and slots_per_epoch = T.Checked.to_input slots_per_epoch\n and slots_per_sub_window = T.Checked.to_input slots_per_sub_window\n and grace_period_slots = T.Checked.to_input grace_period_slots in\n let genesis_state_timestamp =\n Block_time.Checked.to_input 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 ; grace_period_slots\n ; genesis_state_timestamp\n |]\n\nlet%test_unit \"value = var\" =\n let compiled = Genesis_constants.For_unit_tests.t.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","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\nlet yojson_summary_of_command =\n let is_proof upd =\n match Account_update.authorization upd with Proof _ -> true | _ -> false\n in\n let zkapp_type cmd =\n let updates = Zkapp_command.account_updates_list cmd in\n Printf.sprintf \"zkapp:%d:%d\" (List.length updates)\n (List.count updates ~f:is_proof)\n in\n let mk_record type_ memo signature =\n `List\n [ `String type_\n ; `String (Signature.to_base58_check signature)\n ; `String (Signed_command_memo.to_string_hum memo)\n ]\n in\n function\n | User_command.Zkapp_command cmd ->\n mk_record (zkapp_type cmd) (Zkapp_command.memo cmd)\n ( Zkapp_command.fee_payer_account_update cmd\n |> Account_update.Fee_payer.authorization )\n | Signed_command cmd ->\n mk_record \"payment\" (Signed_command.memo cmd)\n (Signed_command.signature cmd)\n\nlet yojson_summary = function\n | Command cmd ->\n yojson_summary_of_command cmd\n | Fee_transfer _ ->\n `List [ `String \"fee_transfer\" ]\n | Coinbase cb ->\n let amount = Currency.Amount.to_yojson @@ Coinbase.amount cb in\n `List [ `String \"coinbase\"; amount ]\n\nlet yojson_summary_with_status cmd_with_status =\n let status =\n Transaction_status.to_yojson (With_status.status cmd_with_status)\n in\n match yojson_summary (With_status.data cmd_with_status) with\n | `List lst ->\n `List (lst @ [ status ])\n","open Core_kernel\nopen Mina_base\n\nmodule T = struct\n include Blake2.Make ()\nend\n\ninclude T\n\n(* Base58Check functions for original mainnet transaction hashes *)\nmodule V1_base58_check = Codable.Make_base58_check (struct\n (* top tag needed for compatibility *)\n type t = Stable.Latest.With_top_version_tag.t [@@deriving bin_io_unversioned]\n\n let version_byte = Base58_check.Version_bytes.v1_transaction_hash\n\n let description = \"V1 Transaction hash\"\nend)\n\nlet to_base58_check_v1 = V1_base58_check.to_base58_check\n\nlet of_base58_check_v1 = V1_base58_check.of_base58_check\n\nlet of_base58_check_exn_v1 = V1_base58_check.of_base58_check_exn\n\n(* Base58Check functions for current hard fork *)\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 (Lazy.force 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\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 \"decode, recode v1 hashes\" =\n let v1_hashes =\n [ \"CkpZirFuoLVVab6x2ry4j8Ld5gMmQdak7VHW6f5C7VJYE34WAEWqa\"\n ; \"CkpZB4WE3wDRJ4CqCXqS4dqF8hoRQDVK8banePKUgTR6kvhTfyjRp\"\n ; \"CkpYeG32dVJUjs6iq3oroXWitXar1eBtV3GVFyH5agw7HPp9bG4yQ\"\n ]\n in\n let decoded = List.map v1_hashes ~f:of_base58_check_exn_v1 in\n let recoded = List.map decoded ~f:to_base58_check_v1 in\n List.equal String.equal v1_hashes recoded\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 = (Lazy.force 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 (Lazy.force 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 \"5JtWZqwvKEgSMSHbDhYXg6s76GhfBNscQtxLKXnT6YYTsUKQkcpV\"\n in\n run_test ~transaction_id ~expected_hash\n end )\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 :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> t\n -> Currency.Amount.Signed.t Or_error.t =\n fun ~constraint_constants 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 constraint_constants.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 :\n constraint_constants:Genesis_constants.Constraint_constants.t\n -> t\n -> 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\n val new_accounts : t -> Account_id.t list\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 module Stack (Elt : sig\n type t\n end) : sig\n type t = Elt.t list\n\n val if_ : bool -> then_:t -> else_:t -> t\n\n val empty : unit -> t\n\n val is_empty : t -> bool\n\n val pop_exn : t -> Elt.t * t\n\n val pop : t -> (Elt.t * t) option\n\n val push : Elt.t -> onto:t -> t\n end\n\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 : Account.t) ~txn_amount\n ~txn_global_slot =\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.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\n let verification_key_perm_fallback_to_signature_with_older_version =\n Permissions.Auth_required\n .verification_key_perm_fallback_to_signature_with_older_version\n end\n\n module Txn_version = struct\n type t = Mina_numbers.Txn_version.t\n\n let if_ = value_if\n\n let equal_to_current = Mina_numbers.Txn_version.equal_to_current\n\n let older_than_current = Mina_numbers.Txn_version.older_than_current\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 = Bounded_types.String.t\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_auth : t -> Controller.t =\n fun a -> fst a.permissions.set_verification_key\n\n let set_verification_key_txn_version : t -> Txn_version.t =\n fun a -> snd 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 let local_state = ref local_state in\n let check failure b =\n local_state := Inputs.Local_state.add_check !local_state failure b\n in\n Zkapp_precondition.Account.check ~new_account ~check\n account_update.body.preconditions.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 module Stack = Inputs.Stack\n\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, Mina_numbers.Txn_version.current)\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 = Zkapp_precondition.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 (Lazy.force 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 = Zkapp_precondition.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.t) =\n { (Account.to_poly 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 Field = Impl.Field\nmodule Boolean = Impl.Boolean\nmodule Typ = Impl.Typ\nmodule Backend = Pickles.Backend\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 Promise_js_helpers.js_promise )\n Js.prop\n ; featureFlags : bool option Pickles_types.Plonk_types.Features.t 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\nlet map_feature_flags_option\n (feature_flags_ : bool option Pickles_types.Plonk_types.Features.t) =\n Pickles_types.Plonk_types.Features.map feature_flags_ ~f:(function\n | Some true ->\n Pickles_types.Opt.Flag.Yes\n | Some false ->\n Pickles_types.Opt.Flag.No\n | None ->\n Pickles_types.Opt.Flag.Maybe )\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.Promise.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\n (* this is called after `picklesRuleFromFunction()` and finishes the circuit *)\n let finish_circuit prevs self js_result :\n _ Pickles.Inductive_rule.main_return =\n (* convert js rule output to pickles rule output *)\n let public_output = js_result##.publicOutput in\n let previous_proofs_should_verify =\n should_verifys prevs js_result##.shouldVerify\n in\n let previous_public_inputs =\n prev_statements ~public_input_size ~public_output_size ~self prevs\n js_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, prev_values, widths, heights) H4.T(Pickles.Tag).t\n -> ( prev_vars\n , widths )\n H2.T(Pickles.Inductive_rule.Previous_proof_statement).t =\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 ()) ~request:(fun () ->\n 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 prevs\n in\n { previous_proof_statements; public_output; auxiliary_output = () }\n in\n\n let rule ~(self : (Statement.t, Statement.Constant.t, _, _) Pickles.Tag.t)\n : _ Pickles.Inductive_rule.Promise.t =\n let prevs = prevs ~self in\n\n let main ({ public_input } : _ Pickles.Inductive_rule.main_input) =\n (* add dummy constraints *)\n dummy_constraints () ;\n (* circuit from js *)\n rule##.main public_input\n |> Promise_js_helpers.of_js\n |> Promise.map ~f:(finish_circuit prevs self)\n in\n { identifier = Js.to_string rule##.identifier\n ; feature_flags =\n Pickles_types.Plonk_types.Features.map rule##.featureFlags\n ~f:(function\n | Some true ->\n true\n | _ ->\n false )\n ; prevs\n ; main\n }\n in\n Rule rule\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.Promise).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.Promise).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\nmodule Cache = struct\n module Sync : Key_cache.Sync = struct\n open Key_cache\n include T (Or_error)\n\n module Disk_storable = struct\n include Disk_storable (Or_error)\n\n let of_binable = Trivial.Disk_storable.of_binable\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 = _ } key =\n Or_error.find_map_ok spec ~f:(fun s ->\n let res, cache_hit =\n match s with\n | Spec.On_disk { should_write; _ } ->\n let path = to_string key in\n ( read ~path key\n , if should_write then `Locally_generated else `Cache_hit )\n | S3 _ ->\n (Or_error.errorf \"Downloading from S3 is disabled\", `Cache_hit)\n in\n Or_error.map res ~f:(fun res -> (res, cache_hit)) )\n\n let write spec { Disk_storable.to_string; read = _; write } key value =\n let errs =\n List.filter_map spec ~f:(fun s ->\n let res =\n match s with\n | Spec.On_disk { should_write; _ } ->\n if should_write then write key value (to_string key)\n else Or_error.return ()\n | S3 _ ->\n Or_error.return ()\n in\n match res with Error e -> Some e | Ok () -> None )\n in\n match errs with [] -> Ok () | errs -> Error (Error.of_list errs)\n end\n\n let () = Key_cache.set_sync_implementation (module Sync)\n\n open Pickles.Cache\n\n type any_key =\n | Step_pk of Step.Key.Proving.t\n | Step_vk of Step.Key.Verification.t\n | Wrap_pk of Wrap.Key.Proving.t\n | Wrap_vk of Wrap.Key.Verification.t\n\n type any_value =\n | Step_pk of Backend.Tick.Keypair.t\n | Step_vk of Kimchi_bindings.Protocol.VerifierIndex.Fp.t\n | Wrap_pk of Backend.Tock.Keypair.t\n | Wrap_vk of Pickles.Verification_key.t\n\n let step_pk = function Step_pk v -> Ok v | _ -> Or_error.errorf \"step_pk\"\n\n let step_vk = function Step_vk v -> Ok v | _ -> Or_error.errorf \"step_vk\"\n\n let wrap_pk = function Wrap_pk v -> Ok v | _ -> Or_error.errorf \"wrap_pk\"\n\n let wrap_vk = function Wrap_vk v -> Ok v | _ -> Or_error.errorf \"wrap_vk\"\n\n type js_storable =\n { read : any_key -> Js.js_string Js.t -> (any_value, unit) result\n ; write : any_key -> any_value -> Js.js_string Js.t -> (unit, unit) result\n ; can_write : bool\n }\n\n let or_error f = function Ok v -> f v | _ -> Or_error.errorf \"failed\"\n\n let map_error = function Ok v -> Ok v | _ -> Or_error.errorf \"failed\"\n\n let step_storable { read; write; _ } : Step.storable =\n let read key ~path =\n read (Step_pk key) (Js.string path) |> or_error step_pk\n in\n let write key value path =\n write (Step_pk key) (Step_pk value) (Js.string path) |> map_error\n in\n Sync.Disk_storable.simple Step.Key.Proving.to_string read write\n\n let step_vk_storable { read; write; _ } : Step.vk_storable =\n let read key ~path =\n read (Step_vk key) (Js.string path) |> or_error step_vk\n in\n let write key value path =\n write (Step_vk key) (Step_vk value) (Js.string path) |> map_error\n in\n Sync.Disk_storable.simple Step.Key.Verification.to_string read write\n\n let wrap_storable { read; write; _ } : Wrap.storable =\n let read key ~path =\n read (Wrap_pk key) (Js.string path) |> or_error wrap_pk\n in\n let write key value path =\n write (Wrap_pk key) (Wrap_pk value) (Js.string path) |> map_error\n in\n Sync.Disk_storable.simple Wrap.Key.Proving.to_string read write\n\n let wrap_vk_storable { read; write; _ } : Wrap.vk_storable =\n let read key ~path =\n read (Wrap_vk key) (Js.string path) |> or_error wrap_vk\n in\n let write key value path =\n write (Wrap_vk key) (Wrap_vk value) (Js.string path) |> map_error\n in\n Sync.Disk_storable.simple Wrap.Key.Verification.to_string read write\n (* TODO get this code to understand equivalence of versions of Pickles.Verification_key.t *)\n |> Obj.magic\n\n let storables s : Pickles.Storables.t =\n { step_storable = step_storable s\n ; step_vk_storable = step_vk_storable s\n ; wrap_storable = wrap_storable s\n ; wrap_vk_storable = wrap_vk_storable s\n }\n\n let cache_dir { can_write; _ } : Key_cache.Spec.t list =\n let d : Key_cache.Spec.t =\n On_disk { directory = \"\"; should_write = can_write }\n in\n [ d ]\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 pickles_compile (choices : pickles_rule_js array)\n (config :\n < publicInputSize : int Js.prop\n ; publicOutputSize : int Js.prop\n ; storable : Cache.js_storable Js.optdef_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 = config##.publicInputSize in\n let public_output_size = config##.publicOutputSize in\n let override_wrap_domain =\n Js.Optdef.to_option config##.overrideWrapDomain\n |> Option.map ~f:Pickles_base.Proofs_verified.of_int_exn\n in\n let (Choices choices) =\n Choices.of_js ~public_input_size ~public_output_size choices\n in\n\n (* parse caching configuration *)\n let storables =\n Js.Optdef.to_option config##.storable |> Option.map ~f:Cache.storables\n in\n let cache =\n Js.Optdef.to_option config##.storable |> Option.map ~f:Cache.cache_dir\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 ?storables ?cache\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 let get_vk () =\n let vk = Pickles.Side_loaded.Verification_key.of_compiled_promise tag in\n Promise.map vk ~f:(fun vk ->\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 |> 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 val getVerificationKey = get_vk\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 load_srs_fp () = Backend.Tick.Keypair.load_urs ()\n\nlet load_srs_fq () = Backend.Tock.Keypair.load_urs ()\n\nlet dummy_proof (max_proofs_verified : int) (domain_log2 : int) : some_proof =\n match max_proofs_verified with\n | 0 ->\n let n = Pickles_types.Nat.N0.n in\n Proof0 (Pickles.Proof.dummy n n n ~domain_log2)\n | 1 ->\n let n = Pickles_types.Nat.N1.n in\n Proof1 (Pickles.Proof.dummy n n n ~domain_log2)\n | 2 ->\n let n = Pickles_types.Nat.N2.n in\n Proof2 (Pickles.Proof.dummy n n n ~domain_log2)\n | _ ->\n failwith \"invalid\"\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 encode_verification_key (vk : Pickles.Verification_key.t) =\n Pickles.Verification_key.to_yojson vk |> Yojson.Safe.to_string |> Js.string\n\nlet decode_verification_key (bytes : Js.js_string Js.t) =\n let vk_or_error =\n Pickles.Verification_key.of_yojson @@ Yojson.Safe.from_string\n @@ Js.to_string bytes\n in\n let open Ppx_deriving_yojson_runtime.Result in\n match vk_or_error with\n | Ok vk ->\n vk\n | Error err ->\n failwithf \"Could not decode verification key: %s\" err ()\n\nmodule Util = struct\n let to_ml_string s = Js.to_string s\n\n let from_ml_string s = Js.string s\nend\n\nlet side_loaded_create (name : Js.js_string Js.t) (max_proofs_verified : int)\n (public_input_length : int) (public_output_length : int)\n (feature_flags_js : bool option Pickles_types.Plonk_types.Features.t) =\n let name = Js.to_string name in\n let feature_flags = map_feature_flags_option feature_flags_js in\n let typ = statement_typ public_input_length public_output_length in\n match max_proofs_verified with\n | 0 ->\n Obj.magic\n @@ Pickles.Side_loaded.create ~name\n ~max_proofs_verified:(module Pickles_types.Nat.N0)\n ~feature_flags ~typ\n | 1 ->\n Obj.magic\n @@ Pickles.Side_loaded.create ~name\n ~max_proofs_verified:(module Pickles_types.Nat.N1)\n ~feature_flags ~typ\n | 2 ->\n Obj.magic\n @@ Pickles.Side_loaded.create ~name\n ~max_proofs_verified:(module Pickles_types.Nat.N2)\n ~feature_flags ~typ\n | _ ->\n failwith \"side_loaded_create is unhappy; you should pass 0, 1, or 2\"\n\nlet vk_to_circuit vk =\n let vk () =\n match\n Pickles.Side_loaded.Verification_key.of_base64 (Js.to_string (vk ()))\n 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 Impl.exists Pickles.Side_loaded.Verification_key.typ ~compute:(fun () ->\n vk () )\n\nlet vk_digest vk =\n Pickles.Side_loaded.Verification_key.Checked.to_input vk\n |> Random_oracle.Checked.pack_input\n\nlet in_circuit tag checked_vk = Pickles.Side_loaded.in_circuit tag checked_vk\n\nlet in_prover tag (vk : Js.js_string Js.t) =\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.in_prover tag vk\n\nlet pickles =\n object%js\n val compile = pickles_compile\n\n val verify = verify\n\n val loadSrsFp = load_srs_fp\n\n val loadSrsFq = load_srs_fq\n\n val dummyProof = dummy_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\n val encodeVerificationKey = encode_verification_key\n\n val decodeVerificationKey = decode_verification_key\n\n val util =\n object%js\n val toMlString = Util.to_ml_string\n\n val fromMlString = Util.from_ml_string\n end\n\n val sideLoaded =\n object%js\n val create = side_loaded_create\n\n val inCircuit =\n (* We get weak variables here, but they're synthetic. Don't try this\n at home.\n *)\n Obj.magic in_circuit\n\n val inProver =\n (* We get weak variables here, but they're synthetic. Don't try this\n at home.\n *)\n Obj.magic in_prover\n\n val vkToCircuit = vk_to_circuit\n\n val vkDigest = vk_digest\n end\n end\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 lazy\n ( Account_update.Graphql_repr.deriver\n @@ 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 (Lazy.force 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 (Lazy.force 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 lazy\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 (Lazy.force body_deriver)\n |> Account_update.Body.of_graphql_repr\n in\n body_of_json\n\nlet get_network_id_of_js_string (network : Js.js_string Js.t) =\n match Js.to_string network with\n | \"mainnet\" ->\n Mina_signature_kind.Mainnet\n | \"testnet\" ->\n Mina_signature_kind.Testnet\n | other ->\n Mina_signature_kind.(Other_network other)\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 (network_id : Js.js_string Js.t) =\n Signature_lib.Schnorr.Chunked.sign\n ~signature_kind:(get_network_id_of_js_string network_id)\n 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) (network_id : Js.js_string Js.t) =\n p |> account_update_of_json\n |> Account_update.digest ~chain:(get_network_id_of_js_string network_id)\n\n let transaction_commitments (tx_json : Js.js_string Js.t)\n (network_id : Js.js_string Js.t) =\n let chain = get_network_id_of_js_string network_id in\n let tx =\n Zkapp_command.of_json @@ Yojson.Safe.from_string @@ Js.to_string tx_json\n in\n let get_account_updates_hash xs =\n let hash_account_update (p : Account_update.t) =\n Zkapp_command.Digest.Account_update.create ~chain p\n in\n Zkapp_command.Call_forest.accumulate_hashes ~hash_account_update xs\n in\n let commitment =\n let account_updates_hash =\n Zkapp_command.Call_forest.hash\n (get_account_updates_hash tx.account_updates)\n in\n Zkapp_command.Transaction_commitment.create ~account_updates_hash\n in\n let fee_payer = Account_update.of_fee_payer tx.fee_payer in\n let fee_payer_hash =\n Zkapp_command.Digest.Account_update.create ~chain fee_payer\n 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_zkapp_command (command : Js.js_string Js.t) =\n let command : Zkapp_command.t =\n command |> Js.to_string |> Yojson.Safe.from_string\n |> Zkapp_command.of_json\n in\n Mina_transaction.Transaction_hash.(\n command |> hash_zkapp_command |> to_base58_check |> Js.string)\n\n let hash_payment_v1 (command : Js.js_string Js.t) =\n let command : Signed_command.Stable.V1.t =\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.Stable.V1.t =\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 hashZkAppCommand = hash_zkapp_command\n\n val examplePayment = example_payment\n end\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","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Xavier Leroy, projet Gallium, INRIA Paris *)\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\nopen Printf\n\nexternal isatty : out_channel -> bool = \"caml_sys_isatty\"\nexternal terminfo_rows: out_channel -> int = \"caml_terminfo_rows\"\n\ntype status =\n | Uninitialised\n | Bad_term\n | Good_term\n\nlet setup oc =\n let term = try Sys.getenv \"TERM\" with Not_found -> \"\" in\n (* Same heuristics as in Misc.Color.should_enable_color *)\n if term <> \"\" && term <> \"dumb\" && isatty oc\n then Good_term\n else Bad_term\n\nlet num_lines oc =\n let rows = terminfo_rows oc in\n if rows > 0 then rows else 24\n (* 24 is a reasonable default for an ANSI-style terminal *)\n\nlet backup oc n =\n if n >= 1 then fprintf oc \"\\027[%dA%!\" n\n\nlet resume oc n =\n if n >= 1 then fprintf oc \"\\027[%dB%!\" n\n\nlet standout oc b =\n output_string oc (if b then \"\\027[4m\" else \"\\027[0m\"); flush oc\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","(* @configure_input@ *)\n#2 \"stdlib/sys.ml.in\"\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 backend_type =\n | Native\n | Bytecode\n | Other of string\n(* System interface *)\n\nexternal get_config: unit -> string * int * bool = \"caml_sys_get_config\"\nexternal get_executable_name : unit -> string = \"caml_sys_executable_name\"\nexternal argv : string array = \"%sys_argv\"\nexternal big_endian : unit -> bool = \"%big_endian\"\nexternal word_size : unit -> int = \"%word_size\"\nexternal int_size : unit -> int = \"%int_size\"\nexternal max_wosize : unit -> int = \"%max_wosize\"\nexternal unix : unit -> bool = \"%ostype_unix\"\nexternal win32 : unit -> bool = \"%ostype_win32\"\nexternal cygwin : unit -> bool = \"%ostype_cygwin\"\nexternal get_backend_type : unit -> backend_type = \"%backend_type\"\n\nlet executable_name = get_executable_name()\nlet (os_type, _, _) = get_config()\nlet backend_type = get_backend_type ()\nlet big_endian = big_endian ()\nlet word_size = word_size ()\nlet int_size = int_size ()\nlet unix = unix ()\nlet win32 = win32 ()\nlet cygwin = cygwin ()\nlet max_array_length = max_wosize ()\nlet max_floatarray_length = max_array_length / (64 / word_size)\nlet max_string_length = word_size / 8 * max_array_length - 1\nexternal runtime_variant : unit -> string = \"caml_runtime_variant\"\nexternal runtime_parameters : unit -> string = \"caml_runtime_parameters\"\n\nexternal file_exists: string -> bool = \"caml_sys_file_exists\"\nexternal is_directory : string -> bool = \"caml_sys_is_directory\"\nexternal remove: string -> unit = \"caml_sys_remove\"\nexternal rename : string -> string -> unit = \"caml_sys_rename\"\nexternal getenv: string -> string = \"caml_sys_getenv\"\n\nlet getenv_opt s =\n (* TODO: expose a non-raising primitive directly. *)\n try Some (getenv s)\n with Not_found -> None\n\nexternal command: string -> int = \"caml_sys_system_command\"\nexternal time: unit -> (float [@unboxed]) =\n \"caml_sys_time\" \"caml_sys_time_unboxed\" [@@noalloc]\nexternal chdir: string -> unit = \"caml_sys_chdir\"\nexternal mkdir: string -> int -> unit = \"caml_sys_mkdir\"\nexternal rmdir: string -> unit = \"caml_sys_rmdir\"\nexternal getcwd: unit -> string = \"caml_sys_getcwd\"\nexternal readdir : string -> string array = \"caml_sys_read_directory\"\n\nlet interactive = ref false\n\ntype signal_behavior =\n Signal_default\n | Signal_ignore\n | Signal_handle of (int -> unit)\n\nexternal signal : int -> signal_behavior -> signal_behavior\n = \"caml_install_signal_handler\"\n\nlet set_signal sig_num sig_beh = ignore(signal sig_num sig_beh)\n\nlet sigabrt = -1\nlet sigalrm = -2\nlet sigfpe = -3\nlet sighup = -4\nlet sigill = -5\nlet sigint = -6\nlet sigkill = -7\nlet sigpipe = -8\nlet sigquit = -9\nlet sigsegv = -10\nlet sigterm = -11\nlet sigusr1 = -12\nlet sigusr2 = -13\nlet sigchld = -14\nlet sigcont = -15\nlet sigstop = -16\nlet sigtstp = -17\nlet sigttin = -18\nlet sigttou = -19\nlet sigvtalrm = -20\nlet sigprof = -21\nlet sigbus = -22\nlet sigpoll = -23\nlet sigsys = -24\nlet sigtrap = -25\nlet sigurg = -26\nlet sigxcpu = -27\nlet sigxfsz = -28\n\nexception Break\n\nlet catch_break on =\n if on then\n set_signal sigint (Signal_handle(fun _ -> raise Break))\n else\n set_signal sigint Signal_default\n\n\nexternal enable_runtime_warnings: bool -> unit =\n \"caml_ml_enable_runtime_warnings\"\nexternal runtime_warnings_enabled: unit -> bool =\n \"caml_ml_runtime_warnings_enabled\"\n\n(* The version string is found in file ../VERSION *)\n\nlet ocaml_version = \"@VERSION@\"\n\nlet development_version = @OCAML_DEVELOPMENT_VERSION@\n\ntype extra_prefix = Plus | Tilde\n\ntype extra_info = extra_prefix * string\n\ntype ocaml_release_info = {\n major : int;\n minor : int;\n patchlevel : int;\n extra : extra_info option\n}\n\nlet ocaml_release = {\n major = @OCAML_VERSION_MAJOR@;\n minor = @OCAML_VERSION_MINOR@;\n patchlevel = @OCAML_VERSION_PATCHLEVEL@;\n extra = @OCAML_RELEASE_EXTRA@\n}\n\n(* Optimization *)\n\nexternal opaque_identity : 'a -> 'a = \"%opaque\"\n\nmodule Immediate64 = struct\n module type Non_immediate = sig\n type t\n end\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 type 'a repr =\n | Immediate : Immediate.t repr\n | Non_immediate : Non_immediate.t repr\n external magic : _ repr -> t repr = \"%identity\"\n let repr =\n if word_size = 64 then\n magic Immediate\n else\n magic Non_immediate\n end\nend\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(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)\n(* Nicolas Ojeda Bar, LexiFi *)\n(* *)\n(* Copyright 2016 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 repr =\n | Int32 of int32\n | Int64 of int64\n\nmodule type S = sig\n type t\n val zero : t\n val one : t\n val minus_one : t\n val neg : t -> t\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 unsigned_div : t -> t -> t\n val rem : t -> t -> t\n val unsigned_rem : t -> t -> t\n val succ : t -> t\n val pred : t -> t\n val abs : t -> t\n val max_int : t\n val min_int : t\n val logand : t -> t -> t\n val logor : t -> t -> t\n val logxor : t -> t -> t\n val lognot : 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 of_int : int -> t\n val of_int_exn : int -> t\n val to_int : t -> int\n val of_float : float -> t\n val to_float : t -> float\n val of_int32 : int32 -> t\n val to_int32 : t -> int32\n val of_int64 : int64 -> t\n val to_int64 : t -> int64\n val of_string : string -> t\n val to_string : t -> string\n val compare: t -> t -> int\n val unsigned_compare : t -> t -> int\n val equal: t -> t -> bool\n val repr: t -> repr\n val print : Format.formatter -> t -> unit\nend\n\nlet size = Sys.word_size\n(* Later, this will be set by the configure script\n in order to support cross-compilation. *)\n\nmodule Int32 = struct\n include Int32\n let of_int_exn =\n match Sys.word_size with (* size of [int] *)\n | 32 ->\n Int32.of_int\n | 64 ->\n fun n ->\n if n < Int32.(to_int min_int) || n > Int32.(to_int max_int) then\n Misc.fatal_errorf \"Targetint.of_int_exn: 0x%x out of range\" n\n else\n Int32.of_int n\n | _ ->\n assert false\n let of_int32 x = x\n let to_int32 x = x\n let of_int64 = Int64.to_int32\n let to_int64 = Int64.of_int32\n let repr x = Int32 x\n let print ppf t = Format.fprintf ppf \"%ld\" t\nend\n\nmodule Int64 = struct\n include Int64\n let of_int_exn = Int64.of_int\n let of_int64 x = x\n let to_int64 x = x\n let repr x = Int64 x\n let print ppf t = Format.fprintf ppf \"%Ld\" t\nend\n\ninclude (val\n (match size with\n | 32 -> (module Int32)\n | 64 -> (module Int64)\n | _ -> assert false\n ) : S)\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(* Gabriel Radanne, projet Cambium, Inria Paris *)\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[@@@warning \"-16\"]\n\n(* This module implements a modified version of Wagner-Fischer\n See \n for preliminary reading.\n\n The main extensions is that:\n - State is computed based on the optimal patch so far.\n - The lists can be extended at each state computation.\n\n We add the constraint that extensions can only be in one side\n (either the left or right list). This is enforced by the external API.\n\n*)\n\n(** Shared types *)\ntype change_kind =\n | Deletion\n | Insertion\n | Modification\n | Preservation\n\nlet style = function\n | Preservation -> Misc.Color.[ FG Green ]\n | Deletion -> Misc.Color.[ FG Red; Bold]\n | Insertion -> Misc.Color.[ FG Red; Bold]\n | Modification -> Misc.Color.[ FG Magenta; Bold]\n\nlet prefix ppf (pos, p) =\n let sty = style p in\n Format.pp_open_stag ppf (Misc.Color.Style sty);\n Format.fprintf ppf \"%i. \" pos;\n Format.pp_close_stag ppf ()\n\n\nlet (let*) = Option.bind\nlet (let+) x f = Option.map f x\nlet (let*!) x f = Option.iter f x\n\nmodule type Defs = sig\n type left\n type right\n type eq\n type diff\n type state\nend\n\ntype ('left,'right,'eq,'diff) change =\n | Delete of 'left\n | Insert of 'right\n | Keep of 'left * 'right *' eq\n | Change of 'left * 'right * 'diff\n\nlet classify = function\n | Delete _ -> Deletion\n | Insert _ -> Insertion\n | Change _ -> Modification\n | Keep _ -> Preservation\n\nmodule Define(D:Defs) = struct\n open D\n\ntype nonrec change = (left,right,eq,diff) change\n\ntype patch = change list\nmodule type S = sig\n val diff: state -> left array -> right array -> patch\nend\n\n\ntype full_state = {\n line: left array;\n column: right array;\n state: state\n}\n\n(* The matrix supporting our dynamic programming implementation.\n\n Each cell contains:\n - The diff and its weight\n - The state computed so far\n - The lists, potentially extended locally.\n\n The matrix can also be reshaped.\n*)\nmodule Matrix : sig\n\n type shape = { l : int ; c : int }\n\n type t\n\n val make : shape -> t\n val reshape : shape -> t -> t\n\n (** accessor functions *)\n val diff : t -> int -> int -> change option\n val state : t -> int -> int -> full_state option\n val weight : t -> int -> int -> int\n\n val line : t -> int -> int -> left option\n val column : t -> int -> int -> right option\n\n val set :\n t -> int -> int ->\n diff:change option ->\n weight:int ->\n state:full_state ->\n unit\n\n (** the shape when starting filling the matrix *)\n val shape : t -> shape\n\n (** [shape m i j] is the shape as seen from the state at position (i,j)\n after some possible extensions\n *)\n val shape_at : t -> int -> int -> shape option\n\n (** the maximal shape on the whole matrix *)\n val real_shape : t -> shape\n\n (** debugging printer *)\n val[@warning \"-32\"] pp : Format.formatter -> t -> unit\n\nend = struct\n\n type shape = { l : int ; c : int }\n\n type t =\n { states: full_state option array array;\n weight: int array array;\n diff: change option array array;\n columns: int;\n lines: int;\n }\n let opt_get a n =\n if n < Array.length a then Some (Array.unsafe_get a n) else None\n let line m i j = let* st = m.states.(i).(j) in opt_get st.line i\n let column m i j = let* st = m.states.(i).(j) in opt_get st.column j\n let diff m i j = m.diff.(i).(j)\n let weight m i j = m.weight.(i).(j)\n let state m i j = m.states.(i).(j)\n let shape m = { l = m.lines ; c = m.columns }\n\n let set m i j ~diff ~weight ~state =\n m.weight.(i).(j) <- weight;\n m.states.(i).(j) <- Some state;\n m.diff.(i).(j) <- diff;\n ()\n\n let shape_at tbl i j =\n let+ st = tbl.states.(i).(j) in\n let l = Array.length st.line in\n let c = Array.length st.column in\n { l ; c }\n\n let real_shape tbl =\n let lines = ref tbl.lines in\n let columns = ref tbl.columns in\n for i = 0 to tbl.lines do\n for j = 0 to tbl.columns do\n let*! {l; c} = shape_at tbl i j in\n if l > !lines then lines := l;\n if c > !columns then columns := c\n done;\n done;\n { l = !lines ; c = !columns }\n\n let make { l = lines ; c = columns } =\n { states = Array.make_matrix (lines + 1) (columns + 1) None;\n weight = Array.make_matrix (lines + 1) (columns + 1) max_int;\n diff = Array.make_matrix (lines + 1) (columns + 1) None;\n lines;\n columns;\n }\n\n let reshape { l = lines ; c = columns } m =\n let copy default a =\n Array.init (1+lines) (fun i -> Array.init (1+columns) (fun j ->\n if i <= m.lines && j <= m.columns then\n a.(i).(j)\n else default) ) in\n { states = copy None m.states;\n weight = copy max_int m.weight;\n diff = copy None m.diff;\n lines;\n columns\n }\n\n let pp ppf m =\n let { l ; c } = shape m in\n Format.eprintf \"Shape : %i, %i@.\" l c;\n for i = 0 to l do\n for j = 0 to c do\n let d = diff m i j in\n match d with\n | None ->\n Format.fprintf ppf \" \"\n | Some diff ->\n let sdiff = match diff with\n | Insert _ -> \"\\u{2190}\"\n | Delete _ -> \"\\u{2191}\"\n | Keep _ -> \"\\u{2196}\"\n | Change _ -> \"\\u{21F1}\"\n in\n let w = weight m i j in\n Format.fprintf ppf \"%s%i \" sdiff w\n done;\n Format.pp_print_newline ppf ()\n done\n\nend\n\n\n(* Building the patch.\n\n We first select the best final cell. A potential final cell\n is a cell where the local shape (i.e., the size of the strings) correspond\n to its position in the matrix. In other words: it's at the end of both its\n strings. We select the final cell with the smallest weight.\n\n We then build the patch by walking backward from the final cell to the\n origin.\n*)\n\nlet select_final_state m0 =\n let maybe_final i j =\n match Matrix.shape_at m0 i j with\n | Some shape_here -> shape_here.l = i && shape_here.c = j\n | None -> false\n in\n let best_state (i0,j0,weigth0) (i,j) =\n let weight = Matrix.weight m0 i j in\n if weight < weigth0 then (i,j,weight) else (i0,j0,weigth0)\n in\n let res = ref (0,0,max_int) in\n let shape = Matrix.shape m0 in\n for i = 0 to shape.l do\n for j = 0 to shape.c do\n if maybe_final i j then\n res := best_state !res (i,j)\n done\n done;\n let i_final, j_final, _ = !res in\n assert (i_final <> 0 || j_final <> 0);\n (i_final, j_final)\n\nlet construct_patch m0 =\n let rec aux acc (i, j) =\n if i = 0 && j = 0 then\n acc\n else\n match Matrix.diff m0 i j with\n | None -> assert false\n | Some d ->\n let next = match d with\n | Keep _ | Change _ -> (i-1, j-1)\n | Delete _ -> (i-1, j)\n | Insert _ -> (i, j-1)\n in\n aux (d::acc) next\n in\n aux [] (select_final_state m0)\n\n(* Computation of new cells *)\n\nlet select_best_proposition l =\n let compare_proposition curr prop =\n match curr, prop with\n | None, o | o, None -> o\n | Some (curr_m, curr_res), Some (m, res) ->\n Some (if curr_m <= m then curr_m, curr_res else m,res)\n in\n List.fold_left compare_proposition None l\n\n module type Full_core = sig\n type update_result\n type update_state\n val weight: change -> int\n val test: state -> left -> right -> (eq, diff) result\n val update: change -> update_state -> update_result\n end\n\nmodule Generic\n (X: Full_core\n with type update_result := full_state\n and type update_state := full_state) = struct\n open X\n\n (* Boundary cell update *)\n let compute_column0 tbl i =\n let*! st = Matrix.state tbl (i-1) 0 in\n let*! line = Matrix.line tbl (i-1) 0 in\n let diff = Delete line in\n Matrix.set tbl i 0\n ~weight:(weight diff + Matrix.weight tbl (i-1) 0)\n ~state:(update diff st)\n ~diff:(Some diff)\n\n let compute_line0 tbl j =\n let*! st = Matrix.state tbl 0 (j-1) in\n let*! column = Matrix.column tbl 0 (j-1) in\n let diff = Insert column in\n Matrix.set tbl 0 j\n ~weight:(weight diff + Matrix.weight tbl 0 (j-1))\n ~state:(update diff st)\n ~diff:(Some diff)\n\nlet compute_inner_cell tbl i j =\n let compute_proposition i j diff =\n let* diff = diff in\n let+ localstate = Matrix.state tbl i j in\n weight diff + Matrix.weight tbl i j, (diff, localstate)\n in\n let del =\n let diff = let+ x = Matrix.line tbl (i-1) j in Delete x in\n compute_proposition (i-1) j diff\n in\n let insert =\n let diff = let+ x = Matrix.column tbl i (j-1) in Insert x in\n compute_proposition i (j-1) diff\n in\n let diag =\n let diff =\n let* state = Matrix.state tbl (i-1) (j-1) in\n let* line = Matrix.line tbl (i-1) (j-1) in\n let* column = Matrix.column tbl (i-1) (j-1) in\n match test state.state line column with\n | Ok ok -> Some (Keep (line, column, ok))\n | Error err -> Some (Change (line, column, err))\n in\n compute_proposition (i-1) (j-1) diff\n in\n let*! newweight, (diff, localstate) =\n select_best_proposition [diag;del;insert]\n in\n let state = update diff localstate in\n Matrix.set tbl i j ~weight:newweight ~state ~diff:(Some diff)\n\nlet compute_cell m i j =\n match i, j with\n | _ when Matrix.diff m i j <> None -> ()\n | 0,0 -> ()\n | 0,j -> compute_line0 m j\n | i,0 -> compute_column0 m i;\n | _ -> compute_inner_cell m i j\n\n(* Filling the matrix\n\n We fill the whole matrix, as in vanilla Wagner-Fischer.\n At this point, the lists in some states might have been extended.\n If any list have been extended, we need to reshape the matrix\n and repeat the process\n*)\nlet compute_matrix state0 =\n let m0 = Matrix.make { l = 0 ; c = 0 } in\n Matrix.set m0 0 0 ~weight:0 ~state:state0 ~diff:None;\n let rec loop m =\n let shape = Matrix.shape m in\n let new_shape = Matrix.real_shape m in\n if new_shape.l > shape.l || new_shape.c > shape.c then\n let m = Matrix.reshape new_shape m in\n for i = 0 to new_shape.l do\n for j = 0 to new_shape.c do\n compute_cell m i j\n done\n done;\n loop m\n else\n m\n in\n loop m0\n end\n\n\n module type Parameters = Full_core with type update_state := state\n\n module Simple(X:Parameters with type update_result := state) = struct\n module Internal = Generic(struct\n let test = X.test\n let weight = X.weight\n let update d fs = { fs with state = X.update d fs.state }\n end)\n\n let diff state line column =\n let fullstate = { line; column; state } in\n Internal.compute_matrix fullstate\n |> construct_patch\n end\n\n\n let may_append x = function\n | [||] -> x\n | y -> Array.append x y\n\n\n module Left_variadic\n (X:Parameters with type update_result := state * left array) = struct\n open X\n\n module Internal = Generic(struct\n let test = X.test\n let weight = X.weight\n let update d fs =\n let state, a = update d fs.state in\n { fs with state ; line = may_append fs.line a }\n end)\n\n let diff state line column =\n let fullstate = { line; column; state } in\n Internal.compute_matrix fullstate\n |> construct_patch\n end\n\n module Right_variadic\n (X:Parameters with type update_result := state * right array) = struct\n open X\n\n module Internal = Generic(struct\n let test = X.test\n let weight = X.weight\n let update d fs =\n let state, a = update d fs.state in\n { fs with state ; column = may_append fs.column a }\n end)\n\n let diff state line column =\n let fullstate = { line; column; state } in\n Internal.compute_matrix fullstate\n |> construct_patch\n end\n\nend\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","open! Import\n\nlet to_string _ = `Deprecated_use_Exn_to_string_instead\nlet print _ = `Deprecated_use_Exn_to_string_instead\nlet catch _ _ = `Deprecated_use_Exn_handle_uncaught_instead\nlet print_backtrace = Caml.Printexc.print_backtrace\nlet get_backtrace = Caml.Printexc.get_backtrace\nlet record_backtrace = Caml.Printexc.record_backtrace\nlet backtrace_status = Caml.Printexc.backtrace_status\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","let 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(* *)\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","(* 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 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","(*\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 Core_kernel\nopen Core_kernel.Hash.Builtin\n\nmodule N16 = struct\n let max_array_len = 16\nend\n\nmodule N4000 = struct\n let max_array_len = 4000\nend\n\nmodule ArrayN (N : sig\n val max_array_len : int\nend) =\nstruct\n module Stable = struct\n module V1 = struct\n type 'a t = 'a array [@@deriving sexp, yojson, bin_io]\n\n let __versioned__ = ()\n\n let hash_fold_t = hash_fold_array_frozen\n\n [%%define_locally Core_kernel.Array.(compare, equal)]\n\n let to_latest s = s\n\n let bin_shape_t bin_shape_elt =\n Bin_prot.Shape.basetype\n (Bin_prot.Shape.Uuid.of_string \"Bounded_types.Array.t\")\n [ bin_shape_elt ]\n\n let bin_write_t bin_write_el buf ~pos a =\n if Array.length a > N.max_array_len then\n failwithf \"Exceeded array maximum size (max %d < got %d)\"\n N.max_array_len (Array.length a) () ;\n bin_write_array bin_write_el buf ~pos a\n\n let bin_read_t bin_read_el buf ~pos_ref =\n let pos = !pos_ref in\n let len = (Bin_prot.Read.bin_read_nat0 buf ~pos_ref :> int) in\n if len > N.max_array_len then\n Bin_prot.Common.raise_read_error\n Bin_prot.Common.ReadError.Array_too_long !pos_ref\n else (\n pos_ref := pos ;\n bin_read_array bin_read_el buf ~pos_ref )\n end\n end\n\n type 'a t = 'a Stable.V1.t\n\n [%%define_locally\n Stable.V1.\n (compare, equal, hash_fold_t, sexp_of_t, t_of_sexp, to_yojson, of_yojson)]\nend\n\nmodule String = struct\n let max_string_len = 100_000_000\n\n module Stable = struct\n module V1 = struct\n type t = string [@@deriving sexp, yojson, bin_io]\n\n let __versioned__ = ()\n\n let to_latest s = s\n\n [%%define_locally Core_kernel.String.(compare, equal)]\n\n let hash = hash_string\n\n let hash_fold_t = hash_fold_string\n\n let bin_shape_t =\n Bin_prot.Shape.basetype\n (Bin_prot.Shape.Uuid.of_string \"Bounded_types.String.t\")\n []\n\n let bin_write_t buf ~pos s =\n if String.length s > max_string_len then\n failwith \"Exceeded string maximum size\" ;\n bin_write_string buf ~pos s\n\n let bin_read_t buf ~pos_ref =\n let pos = !pos_ref in\n let len = (Bin_prot.Read.bin_read_nat0 buf ~pos_ref :> int) in\n if len > max_string_len then\n Bin_prot.Common.raise_read_error\n Bin_prot.Common.ReadError.Array_too_long !pos_ref\n else (\n pos_ref := pos ;\n bin_read_string buf ~pos_ref )\n end\n end\n\n type t = Stable.V1.t\n\n [%%define_locally\n Stable.V1.\n ( compare\n , equal\n , hash\n , hash_fold_t\n , sexp_of_t\n , t_of_sexp\n , to_yojson\n , of_yojson )]\n\n module Tagged = struct\n module Stable = struct\n module V1 = struct\n include Stable.V1\n\n (* because this is replacing a primitive,\n there is no actual version tag handling\n needed (and in fact, that will make a\n test in transaction fail *)\n module With_all_version_tags = Stable.V1\n end\n end\n\n include Stable.V1\n end\n\n module Of_stringable (M : Stringable.S) =\n Bin_prot.Utils.Make_binable_without_uuid (struct\n module Binable = Stable.V1\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 = try M.of_string s with x -> raise (Of_binable (s, x))\n end)\nend\n\nmodule Wrapped_error = struct\n module Stable = struct\n module V1 = struct\n type t = Core_kernel.Error.Stable.V2.t [@@deriving sexp]\n\n let __versioned__ = ()\n\n let to_latest = Core_kernel.Fn.id\n\n include String.Of_stringable (struct\n type nonrec t = t\n\n let to_string (s : t) =\n Core_kernel.Error.sexp_of_t s |> Core_kernel.Sexp.to_string_mach\n\n let of_string s =\n Core_kernel.Error.t_of_sexp (Core_kernel.Sexp.of_string s)\n end)\n end\n end\n\n type t = Stable.V1.t\nend\n\nmodule ArrayN16 = ArrayN (N16)\nmodule ArrayN4000 = ArrayN (N4000)\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","{\ntype result =\n| Neg of string\n| Pos of string\n}\n\nlet hex_digit = ['0' - '9' 'A' - 'F' 'a' - 'f']\nlet body = (hex_digit (hex_digit | '_')*) as body\nlet body_with_suffix = '0' ['X' 'x'] body\nlet pos = body_with_suffix\nlet neg = '-' body_with_suffix\n\nrule parse_hex = parse\n| neg { Neg body }\n| pos { Pos body }\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","(**************************************************************************)\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\nlet shell = \"/bin/sh\"\n\ntype error =\n E2BIG\n | EACCES\n | EAGAIN\n | EBADF\n | EBUSY\n | ECHILD\n | EDEADLK\n | EDOM\n | EEXIST\n | EFAULT\n | EFBIG\n | EINTR\n | EINVAL\n | EIO\n | EISDIR\n | EMFILE\n | EMLINK\n | ENAMETOOLONG\n | ENFILE\n | ENODEV\n | ENOENT\n | ENOEXEC\n | ENOLCK\n | ENOMEM\n | ENOSPC\n | ENOSYS\n | ENOTDIR\n | ENOTEMPTY\n | ENOTTY\n | ENXIO\n | EPERM\n | EPIPE\n | ERANGE\n | EROFS\n | ESPIPE\n | ESRCH\n | EXDEV\n | EWOULDBLOCK\n | EINPROGRESS\n | EALREADY\n | ENOTSOCK\n | EDESTADDRREQ\n | EMSGSIZE\n | EPROTOTYPE\n | ENOPROTOOPT\n | EPROTONOSUPPORT\n | ESOCKTNOSUPPORT\n | EOPNOTSUPP\n | EPFNOSUPPORT\n | EAFNOSUPPORT\n | EADDRINUSE\n | EADDRNOTAVAIL\n | ENETDOWN\n | ENETUNREACH\n | ENETRESET\n | ECONNABORTED\n | ECONNRESET\n | ENOBUFS\n | EISCONN\n | ENOTCONN\n | ESHUTDOWN\n | ETOOMANYREFS\n | ETIMEDOUT\n | ECONNREFUSED\n | EHOSTDOWN\n | EHOSTUNREACH\n | ELOOP\n | EOVERFLOW\n | EUNKNOWNERR of int\n\nexception Unix_error of error * string * string\n\nlet _ = Callback.register_exception \"Unix.Unix_error\"\n (Unix_error(E2BIG, \"\", \"\"))\n\nexternal error_message : error -> string = \"unix_error_message\"\n\nlet () =\n Printexc.register_printer\n (function\n | Unix_error (e, s, s') ->\n let msg = match e with\n | E2BIG -> \"E2BIG\"\n | EACCES -> \"EACCES\"\n | EAGAIN -> \"EAGAIN\"\n | EBADF -> \"EBADF\"\n | EBUSY -> \"EBUSY\"\n | ECHILD -> \"ECHILD\"\n | EDEADLK -> \"EDEADLK\"\n | EDOM -> \"EDOM\"\n | EEXIST -> \"EEXIST\"\n | EFAULT -> \"EFAULT\"\n | EFBIG -> \"EFBIG\"\n | EINTR -> \"EINTR\"\n | EINVAL -> \"EINVAL\"\n | EIO -> \"EIO\"\n | EISDIR -> \"EISDIR\"\n | EMFILE -> \"EMFILE\"\n | EMLINK -> \"EMLINK\"\n | ENAMETOOLONG -> \"ENAMETOOLONG\"\n | ENFILE -> \"ENFILE\"\n | ENODEV -> \"ENODEV\"\n | ENOENT -> \"ENOENT\"\n | ENOEXEC -> \"ENOEXEC\"\n | ENOLCK -> \"ENOLCK\"\n | ENOMEM -> \"ENOMEM\"\n | ENOSPC -> \"ENOSPC\"\n | ENOSYS -> \"ENOSYS\"\n | ENOTDIR -> \"ENOTDIR\"\n | ENOTEMPTY -> \"ENOTEMPTY\"\n | ENOTTY -> \"ENOTTY\"\n | ENXIO -> \"ENXIO\"\n | EPERM -> \"EPERM\"\n | EPIPE -> \"EPIPE\"\n | ERANGE -> \"ERANGE\"\n | EROFS -> \"EROFS\"\n | ESPIPE -> \"ESPIPE\"\n | ESRCH -> \"ESRCH\"\n | EXDEV -> \"EXDEV\"\n | EWOULDBLOCK -> \"EWOULDBLOCK\"\n | EINPROGRESS -> \"EINPROGRESS\"\n | EALREADY -> \"EALREADY\"\n | ENOTSOCK -> \"ENOTSOCK\"\n | EDESTADDRREQ -> \"EDESTADDRREQ\"\n | EMSGSIZE -> \"EMSGSIZE\"\n | EPROTOTYPE -> \"EPROTOTYPE\"\n | ENOPROTOOPT -> \"ENOPROTOOPT\"\n | EPROTONOSUPPORT -> \"EPROTONOSUPPORT\"\n | ESOCKTNOSUPPORT -> \"ESOCKTNOSUPPORT\"\n | EOPNOTSUPP -> \"EOPNOTSUPP\"\n | EPFNOSUPPORT -> \"EPFNOSUPPORT\"\n | EAFNOSUPPORT -> \"EAFNOSUPPORT\"\n | EADDRINUSE -> \"EADDRINUSE\"\n | EADDRNOTAVAIL -> \"EADDRNOTAVAIL\"\n | ENETDOWN -> \"ENETDOWN\"\n | ENETUNREACH -> \"ENETUNREACH\"\n | ENETRESET -> \"ENETRESET\"\n | ECONNABORTED -> \"ECONNABORTED\"\n | ECONNRESET -> \"ECONNRESET\"\n | ENOBUFS -> \"ENOBUFS\"\n | EISCONN -> \"EISCONN\"\n | ENOTCONN -> \"ENOTCONN\"\n | ESHUTDOWN -> \"ESHUTDOWN\"\n | ETOOMANYREFS -> \"ETOOMANYREFS\"\n | ETIMEDOUT -> \"ETIMEDOUT\"\n | ECONNREFUSED -> \"ECONNREFUSED\"\n | EHOSTDOWN -> \"EHOSTDOWN\"\n | EHOSTUNREACH -> \"EHOSTUNREACH\"\n | ELOOP -> \"ELOOP\"\n | EOVERFLOW -> \"EOVERFLOW\"\n | EUNKNOWNERR x -> Printf.sprintf \"EUNKNOWNERR %d\" x in\n Some (Printf.sprintf \"Unix.Unix_error(Unix.%s, %S, %S)\" msg s s')\n | _ -> None)\n\nlet handle_unix_error f arg =\n try\n f arg\n with Unix_error(err, fun_name, arg) ->\n prerr_string Sys.argv.(0);\n prerr_string \": \\\"\";\n prerr_string fun_name;\n prerr_string \"\\\" failed\";\n if String.length arg > 0 then begin\n prerr_string \" on \\\"\";\n prerr_string arg;\n prerr_string \"\\\"\"\n end;\n prerr_string \": \";\n prerr_endline (error_message err);\n exit 2\n\nexternal environment : unit -> string array = \"unix_environment\"\nexternal unsafe_environment : unit -> string array = \"unix_environment_unsafe\"\nexternal getenv: string -> string = \"caml_sys_getenv\"\nexternal unsafe_getenv: string -> string = \"caml_sys_unsafe_getenv\"\nexternal putenv: string -> string -> unit = \"unix_putenv\"\n\ntype process_status =\n WEXITED of int\n | WSIGNALED of int\n | WSTOPPED of int\n\ntype wait_flag =\n WNOHANG\n | WUNTRACED\n\nexternal execv : string -> string array -> 'a = \"unix_execv\"\nexternal execve : string -> string array -> string array -> 'a = \"unix_execve\"\nexternal execvp : string -> string array -> 'a = \"unix_execvp\"\nexternal execvpe : string -> string array -> string array -> 'a = \"unix_execvpe\"\n\nexternal fork : unit -> int = \"unix_fork\"\nexternal wait : unit -> int * process_status = \"unix_wait\"\nexternal waitpid : wait_flag list -> int -> int * process_status\n = \"unix_waitpid\"\nexternal _exit : int -> 'a = \"unix_exit\"\nexternal getpid : unit -> int = \"unix_getpid\"\nexternal getppid : unit -> int = \"unix_getppid\"\nexternal nice : int -> int = \"unix_nice\"\n\ntype file_descr = int\n\nlet stdin = 0\nlet stdout = 1\nlet stderr = 2\n\ntype open_flag =\n O_RDONLY\n | O_WRONLY\n | O_RDWR\n | O_NONBLOCK\n | O_APPEND\n | O_CREAT\n | O_TRUNC\n | O_EXCL\n | O_NOCTTY\n | O_DSYNC\n | O_SYNC\n | O_RSYNC\n | O_SHARE_DELETE\n | O_CLOEXEC\n | O_KEEPEXEC\n\ntype file_perm = int\n\n\nexternal openfile : string -> open_flag list -> file_perm -> file_descr\n = \"unix_open\"\nexternal close : file_descr -> unit = \"unix_close\"\nexternal fsync : file_descr -> unit = \"unix_fsync\"\nexternal unsafe_read : file_descr -> bytes -> int -> int -> int\n = \"unix_read\"\nexternal unsafe_write : file_descr -> bytes -> int -> int -> int = \"unix_write\"\nexternal unsafe_single_write : file_descr -> bytes -> int -> int -> int\n = \"unix_single_write\"\n\nlet read fd buf ofs len =\n if ofs < 0 || len < 0 || ofs > Bytes.length buf - len\n then invalid_arg \"Unix.read\"\n else unsafe_read fd buf ofs len\nlet write fd buf ofs len =\n if ofs < 0 || len < 0 || ofs > Bytes.length buf - len\n then invalid_arg \"Unix.write\"\n else unsafe_write fd buf ofs len\n(* write misbehaves because it attempts to write all data by making repeated\n calls to the Unix write function (see comment in write.c and unix.mli).\n single_write fixes this by never calling write twice. *)\nlet single_write fd buf ofs len =\n if ofs < 0 || len < 0 || ofs > Bytes.length buf - len\n then invalid_arg \"Unix.single_write\"\n else unsafe_single_write fd buf ofs len\n\nlet write_substring fd buf ofs len =\n write fd (Bytes.unsafe_of_string buf) ofs len\n\nlet single_write_substring fd buf ofs len =\n single_write fd (Bytes.unsafe_of_string buf) ofs len\n\nexternal in_channel_of_descr : file_descr -> in_channel\n = \"unix_inchannel_of_filedescr\"\nexternal out_channel_of_descr : file_descr -> out_channel\n = \"unix_outchannel_of_filedescr\"\nexternal descr_of_in_channel : in_channel -> file_descr\n = \"caml_channel_descriptor\"\nexternal descr_of_out_channel : out_channel -> file_descr\n = \"caml_channel_descriptor\"\n\ntype seek_command =\n SEEK_SET\n | SEEK_CUR\n | SEEK_END\n\nexternal lseek : file_descr -> int -> seek_command -> int = \"unix_lseek\"\nexternal truncate : string -> int -> unit = \"unix_truncate\"\nexternal ftruncate : file_descr -> int -> unit = \"unix_ftruncate\"\n\ntype file_kind =\n S_REG\n | S_DIR\n | S_CHR\n | S_BLK\n | S_LNK\n | S_FIFO\n | S_SOCK\n\ntype stats =\n { st_dev : int;\n st_ino : int;\n st_kind : file_kind;\n st_perm : file_perm;\n st_nlink : int;\n st_uid : int;\n st_gid : int;\n st_rdev : int;\n st_size : int;\n st_atime : float;\n st_mtime : float;\n st_ctime : float }\n\nexternal stat : string -> stats = \"unix_stat\"\nexternal lstat : string -> stats = \"unix_lstat\"\nexternal fstat : file_descr -> stats = \"unix_fstat\"\nexternal isatty : file_descr -> bool = \"unix_isatty\"\nexternal unlink : string -> unit = \"unix_unlink\"\nexternal rename : string -> string -> unit = \"unix_rename\"\nexternal link : ?follow:bool -> string -> string -> unit = \"unix_link\"\nexternal realpath : string -> string = \"unix_realpath\"\n\nmodule LargeFile =\n struct\n external lseek : file_descr -> int64 -> seek_command -> int64\n = \"unix_lseek_64\"\n external truncate : string -> int64 -> unit = \"unix_truncate_64\"\n external ftruncate : file_descr -> int64 -> unit = \"unix_ftruncate_64\"\n type stats =\n { st_dev : int;\n st_ino : int;\n st_kind : file_kind;\n st_perm : file_perm;\n st_nlink : int;\n st_uid : int;\n st_gid : int;\n st_rdev : int;\n st_size : int64;\n st_atime : float;\n st_mtime : float;\n st_ctime : float;\n }\n external stat : string -> stats = \"unix_stat_64\"\n external lstat : string -> stats = \"unix_lstat_64\"\n external fstat : file_descr -> stats = \"unix_fstat_64\"\n end\n\nexternal map_internal:\n file_descr -> ('a, 'b) Stdlib.Bigarray.kind\n -> 'c Stdlib.Bigarray.layout\n -> bool -> int array -> int64\n -> ('a, 'b, 'c) Stdlib.Bigarray.Genarray.t\n = \"caml_unix_map_file_bytecode\" \"caml_unix_map_file\"\n\nlet map_file fd ?(pos=0L) kind layout shared dims =\n map_internal fd kind layout shared dims pos\n\ntype access_permission =\n R_OK\n | W_OK\n | X_OK\n | F_OK\n\nexternal chmod : string -> file_perm -> unit = \"unix_chmod\"\nexternal fchmod : file_descr -> file_perm -> unit = \"unix_fchmod\"\nexternal chown : string -> int -> int -> unit = \"unix_chown\"\nexternal fchown : file_descr -> int -> int -> unit = \"unix_fchown\"\nexternal umask : int -> int = \"unix_umask\"\nexternal access : string -> access_permission list -> unit = \"unix_access\"\n\nexternal dup : ?cloexec: bool -> file_descr -> file_descr = \"unix_dup\"\nexternal dup2 :\n ?cloexec: bool -> file_descr -> file_descr -> unit = \"unix_dup2\"\nexternal set_nonblock : file_descr -> unit = \"unix_set_nonblock\"\nexternal clear_nonblock : file_descr -> unit = \"unix_clear_nonblock\"\nexternal set_close_on_exec : file_descr -> unit = \"unix_set_close_on_exec\"\nexternal clear_close_on_exec : file_descr -> unit = \"unix_clear_close_on_exec\"\n\nexternal mkdir : string -> file_perm -> unit = \"unix_mkdir\"\nexternal rmdir : string -> unit = \"unix_rmdir\"\nexternal chdir : string -> unit = \"unix_chdir\"\nexternal getcwd : unit -> string = \"unix_getcwd\"\nexternal chroot : string -> unit = \"unix_chroot\"\n\ntype dir_handle\n\nexternal opendir : string -> dir_handle = \"unix_opendir\"\nexternal readdir : dir_handle -> string = \"unix_readdir\"\nexternal rewinddir : dir_handle -> unit = \"unix_rewinddir\"\nexternal closedir : dir_handle -> unit = \"unix_closedir\"\n\nexternal pipe :\n ?cloexec: bool -> unit -> file_descr * file_descr = \"unix_pipe\"\nexternal symlink : ?to_dir:bool -> string -> string -> unit = \"unix_symlink\"\nexternal has_symlink : unit -> bool = \"unix_has_symlink\"\nexternal readlink : string -> string = \"unix_readlink\"\nexternal mkfifo : string -> file_perm -> unit = \"unix_mkfifo\"\nexternal select :\n file_descr list -> file_descr list -> file_descr list -> float ->\n file_descr list * file_descr list * file_descr list = \"unix_select\"\n\ntype lock_command =\n F_ULOCK\n | F_LOCK\n | F_TLOCK\n | F_TEST\n | F_RLOCK\n | F_TRLOCK\n\nexternal lockf : file_descr -> lock_command -> int -> unit = \"unix_lockf\"\nexternal kill : int -> int -> unit = \"unix_kill\"\ntype sigprocmask_command = SIG_SETMASK | SIG_BLOCK | SIG_UNBLOCK\nexternal sigprocmask: sigprocmask_command -> int list -> int list\n = \"unix_sigprocmask\"\nexternal sigpending: unit -> int list = \"unix_sigpending\"\nexternal sigsuspend: int list -> unit = \"unix_sigsuspend\"\n\nlet pause() =\n let sigs = sigprocmask SIG_BLOCK [] in sigsuspend sigs\n\ntype process_times =\n { tms_utime : float;\n tms_stime : float;\n tms_cutime : float;\n tms_cstime : float }\n\ntype tm =\n { tm_sec : int;\n tm_min : int;\n tm_hour : int;\n tm_mday : int;\n tm_mon : int;\n tm_year : int;\n tm_wday : int;\n tm_yday : int;\n tm_isdst : bool }\n\nexternal time : unit -> (float [@unboxed]) =\n \"unix_time\" \"unix_time_unboxed\" [@@noalloc]\nexternal gettimeofday : unit -> (float [@unboxed]) =\n \"unix_gettimeofday\" \"unix_gettimeofday_unboxed\" [@@noalloc]\nexternal gmtime : float -> tm = \"unix_gmtime\"\nexternal localtime : float -> tm = \"unix_localtime\"\nexternal mktime : tm -> float * tm = \"unix_mktime\"\nexternal alarm : int -> int = \"unix_alarm\"\nexternal sleepf : float -> unit = \"unix_sleep\"\nlet sleep duration = sleepf (float duration)\nexternal times : unit -> process_times = \"unix_times\"\nexternal utimes : string -> float -> float -> unit = \"unix_utimes\"\n\ntype interval_timer =\n ITIMER_REAL\n | ITIMER_VIRTUAL\n | ITIMER_PROF\n\ntype interval_timer_status =\n { it_interval: float; (* Period *)\n it_value: float } (* Current value of the timer *)\n\nexternal getitimer: interval_timer -> interval_timer_status = \"unix_getitimer\"\nexternal setitimer:\n interval_timer -> interval_timer_status -> interval_timer_status\n = \"unix_setitimer\"\n\nexternal getuid : unit -> int = \"unix_getuid\"\nexternal geteuid : unit -> int = \"unix_geteuid\"\nexternal setuid : int -> unit = \"unix_setuid\"\nexternal getgid : unit -> int = \"unix_getgid\"\nexternal getegid : unit -> int = \"unix_getegid\"\nexternal setgid : int -> unit = \"unix_setgid\"\nexternal getgroups : unit -> int array = \"unix_getgroups\"\nexternal setgroups : int array -> unit = \"unix_setgroups\"\nexternal initgroups : string -> int -> unit = \"unix_initgroups\"\n\ntype passwd_entry =\n { pw_name : string;\n pw_passwd : string;\n pw_uid : int;\n pw_gid : int;\n pw_gecos : string;\n pw_dir : string;\n pw_shell : string }\n\ntype group_entry =\n { gr_name : string;\n gr_passwd : string;\n gr_gid : int;\n gr_mem : string array }\n\n\nexternal getlogin : unit -> string = \"unix_getlogin\"\nexternal getpwnam : string -> passwd_entry = \"unix_getpwnam\"\nexternal getgrnam : string -> group_entry = \"unix_getgrnam\"\nexternal getpwuid : int -> passwd_entry = \"unix_getpwuid\"\nexternal getgrgid : int -> group_entry = \"unix_getgrgid\"\n\ntype inet_addr = string\n\nlet is_inet6_addr s = String.length s = 16\n\nexternal inet_addr_of_string : string -> inet_addr\n = \"unix_inet_addr_of_string\"\nexternal string_of_inet_addr : inet_addr -> string\n = \"unix_string_of_inet_addr\"\n\nlet inet_addr_any = inet_addr_of_string \"0.0.0.0\"\nlet inet_addr_loopback = inet_addr_of_string \"127.0.0.1\"\nlet inet6_addr_any =\n try inet_addr_of_string \"::\" with Failure _ -> inet_addr_any\nlet inet6_addr_loopback =\n try inet_addr_of_string \"::1\" with Failure _ -> inet_addr_loopback\n\ntype socket_domain =\n PF_UNIX\n | PF_INET\n | PF_INET6\n\ntype socket_type =\n SOCK_STREAM\n | SOCK_DGRAM\n | SOCK_RAW\n | SOCK_SEQPACKET\n\ntype sockaddr =\n ADDR_UNIX of string\n | ADDR_INET of inet_addr * int\n\nlet domain_of_sockaddr = function\n ADDR_UNIX _ -> PF_UNIX\n | ADDR_INET(a, _) -> if is_inet6_addr a then PF_INET6 else PF_INET\n\ntype shutdown_command =\n SHUTDOWN_RECEIVE\n | SHUTDOWN_SEND\n | SHUTDOWN_ALL\n\ntype msg_flag =\n MSG_OOB\n | MSG_DONTROUTE\n | MSG_PEEK\n\nexternal socket :\n ?cloexec: bool -> socket_domain -> socket_type -> int -> file_descr\n = \"unix_socket\"\nexternal socketpair :\n ?cloexec: bool -> socket_domain -> socket_type -> int ->\n file_descr * file_descr\n = \"unix_socketpair\"\nexternal accept :\n ?cloexec: bool -> file_descr -> file_descr * sockaddr = \"unix_accept\"\nexternal bind : file_descr -> sockaddr -> unit = \"unix_bind\"\nexternal connect : file_descr -> sockaddr -> unit = \"unix_connect\"\nexternal listen : file_descr -> int -> unit = \"unix_listen\"\nexternal shutdown : file_descr -> shutdown_command -> unit = \"unix_shutdown\"\nexternal getsockname : file_descr -> sockaddr = \"unix_getsockname\"\nexternal getpeername : file_descr -> sockaddr = \"unix_getpeername\"\n\nexternal unsafe_recv :\n file_descr -> bytes -> int -> int -> msg_flag list -> int\n = \"unix_recv\"\nexternal unsafe_recvfrom :\n file_descr -> bytes -> int -> int -> msg_flag list -> int * sockaddr\n = \"unix_recvfrom\"\nexternal unsafe_send :\n file_descr -> bytes -> int -> int -> msg_flag list -> int\n = \"unix_send\"\nexternal unsafe_sendto :\n file_descr -> bytes -> int -> int -> msg_flag list -> sockaddr -> int\n = \"unix_sendto\" \"unix_sendto_native\"\n\nlet recv fd buf ofs len flags =\n if ofs < 0 || len < 0 || ofs > Bytes.length buf - len\n then invalid_arg \"Unix.recv\"\n else unsafe_recv fd buf ofs len flags\nlet recvfrom fd buf ofs len flags =\n if ofs < 0 || len < 0 || ofs > Bytes.length buf - len\n then invalid_arg \"Unix.recvfrom\"\n else unsafe_recvfrom fd buf ofs len flags\nlet send fd buf ofs len flags =\n if ofs < 0 || len < 0 || ofs > Bytes.length buf - len\n then invalid_arg \"Unix.send\"\n else unsafe_send fd buf ofs len flags\nlet sendto fd buf ofs len flags addr =\n if ofs < 0 || len < 0 || ofs > Bytes.length buf - len\n then invalid_arg \"Unix.sendto\"\n else unsafe_sendto fd buf ofs len flags addr\n\nlet send_substring fd buf ofs len flags =\n send fd (Bytes.unsafe_of_string buf) ofs len flags\n\nlet sendto_substring fd buf ofs len flags addr =\n sendto fd (Bytes.unsafe_of_string buf) ofs len flags addr\n\ntype socket_bool_option =\n SO_DEBUG\n | SO_BROADCAST\n | SO_REUSEADDR\n | SO_KEEPALIVE\n | SO_DONTROUTE\n | SO_OOBINLINE\n | SO_ACCEPTCONN\n | TCP_NODELAY\n | IPV6_ONLY\n | SO_REUSEPORT\n\ntype socket_int_option =\n SO_SNDBUF\n | SO_RCVBUF\n | SO_ERROR\n | SO_TYPE\n | SO_RCVLOWAT\n | SO_SNDLOWAT\n\ntype socket_optint_option = SO_LINGER\n\ntype socket_float_option =\n SO_RCVTIMEO\n | SO_SNDTIMEO\n\ntype socket_error_option = SO_ERROR\n\nmodule SO: sig\n type ('opt, 'v) t\n val bool: (socket_bool_option, bool) t\n val int: (socket_int_option, int) t\n val optint: (socket_optint_option, int option) t\n val float: (socket_float_option, float) t\n val error: (socket_error_option, error option) t\n val get: ('opt, 'v) t -> file_descr -> 'opt -> 'v\n val set: ('opt, 'v) t -> file_descr -> 'opt -> 'v -> unit\nend = struct\n type ('opt, 'v) t = int\n let bool = 0\n let int = 1\n let optint = 2\n let float = 3\n let error = 4\n external get: ('opt, 'v) t -> file_descr -> 'opt -> 'v\n = \"unix_getsockopt\"\n external set: ('opt, 'v) t -> file_descr -> 'opt -> 'v -> unit\n = \"unix_setsockopt\"\nend\n\nlet getsockopt fd opt = SO.get SO.bool fd opt\nlet setsockopt fd opt v = SO.set SO.bool fd opt v\n\nlet getsockopt_int fd opt = SO.get SO.int fd opt\nlet setsockopt_int fd opt v = SO.set SO.int fd opt v\n\nlet getsockopt_optint fd opt = SO.get SO.optint fd opt\nlet setsockopt_optint fd opt v = SO.set SO.optint fd opt v\n\nlet getsockopt_float fd opt = SO.get SO.float fd opt\nlet setsockopt_float fd opt v = SO.set SO.float fd opt v\n\nlet getsockopt_error fd = SO.get SO.error fd SO_ERROR\n\ntype host_entry =\n { h_name : string;\n h_aliases : string array;\n h_addrtype : socket_domain;\n h_addr_list : inet_addr array }\n\ntype protocol_entry =\n { p_name : string;\n p_aliases : string array;\n p_proto : int }\n\ntype service_entry =\n { s_name : string;\n s_aliases : string array;\n s_port : int;\n s_proto : string }\n\nexternal gethostname : unit -> string = \"unix_gethostname\"\nexternal gethostbyname : string -> host_entry = \"unix_gethostbyname\"\nexternal gethostbyaddr : inet_addr -> host_entry = \"unix_gethostbyaddr\"\nexternal getprotobyname : string -> protocol_entry\n = \"unix_getprotobyname\"\nexternal getprotobynumber : int -> protocol_entry\n = \"unix_getprotobynumber\"\nexternal getservbyname : string -> string -> service_entry\n = \"unix_getservbyname\"\nexternal getservbyport : int -> string -> service_entry\n = \"unix_getservbyport\"\n\ntype addr_info =\n { ai_family : socket_domain;\n ai_socktype : socket_type;\n ai_protocol : int;\n ai_addr : sockaddr;\n ai_canonname : string }\n\ntype getaddrinfo_option =\n AI_FAMILY of socket_domain\n | AI_SOCKTYPE of socket_type\n | AI_PROTOCOL of int\n | AI_NUMERICHOST\n | AI_CANONNAME\n | AI_PASSIVE\n\nexternal getaddrinfo_system\n : string -> string -> getaddrinfo_option list -> addr_info list\n = \"unix_getaddrinfo\"\n\nlet getaddrinfo_emulation node service opts =\n (* Parse options *)\n let opt_socktype = ref None\n and opt_protocol = ref 0\n and opt_passive = ref false in\n List.iter\n (function AI_SOCKTYPE s -> opt_socktype := Some s\n | AI_PROTOCOL p -> opt_protocol := p\n | AI_PASSIVE -> opt_passive := true\n | _ -> ())\n opts;\n (* Determine socket types and port numbers *)\n let get_port ty kind =\n if service = \"\" then [ty, 0] else\n try\n [ty, int_of_string service]\n with Failure _ ->\n try\n [ty, (getservbyname service kind).s_port]\n with Not_found -> []\n in\n let ports =\n match !opt_socktype with\n | None ->\n get_port SOCK_STREAM \"tcp\" @ get_port SOCK_DGRAM \"udp\"\n | Some SOCK_STREAM ->\n get_port SOCK_STREAM \"tcp\"\n | Some SOCK_DGRAM ->\n get_port SOCK_DGRAM \"udp\"\n | Some ty ->\n if service = \"\" then [ty, 0] else [] in\n (* Determine IP addresses *)\n let addresses =\n if node = \"\" then\n if List.mem AI_PASSIVE opts\n then [inet_addr_any, \"0.0.0.0\"]\n else [inet_addr_loopback, \"127.0.0.1\"]\n else\n try\n [inet_addr_of_string node, node]\n with Failure _ ->\n try\n let he = gethostbyname node in\n List.map\n (fun a -> (a, he.h_name))\n (Array.to_list he.h_addr_list)\n with Not_found ->\n [] in\n (* Cross-product of addresses and ports *)\n List.flatten\n (List.map\n (fun (ty, port) ->\n List.map\n (fun (addr, name) ->\n { ai_family = PF_INET;\n ai_socktype = ty;\n ai_protocol = !opt_protocol;\n ai_addr = ADDR_INET(addr, port);\n ai_canonname = name })\n addresses)\n ports)\n\nlet getaddrinfo node service opts =\n try\n List.rev(getaddrinfo_system node service opts)\n with Invalid_argument _ ->\n getaddrinfo_emulation node service opts\n\ntype name_info =\n { ni_hostname : string;\n ni_service : string }\n\ntype getnameinfo_option =\n NI_NOFQDN\n | NI_NUMERICHOST\n | NI_NAMEREQD\n | NI_NUMERICSERV\n | NI_DGRAM\n\nexternal getnameinfo_system\n : sockaddr -> getnameinfo_option list -> name_info\n = \"unix_getnameinfo\"\n\nlet getnameinfo_emulation addr opts =\n match addr with\n | ADDR_UNIX f ->\n { ni_hostname = \"\"; ni_service = f } (* why not? *)\n | ADDR_INET(a, p) ->\n let hostname =\n try\n if List.mem NI_NUMERICHOST opts then raise Not_found;\n (gethostbyaddr a).h_name\n with Not_found ->\n if List.mem NI_NAMEREQD opts then raise Not_found;\n string_of_inet_addr a in\n let service =\n try\n if List.mem NI_NUMERICSERV opts then raise Not_found;\n let kind = if List.mem NI_DGRAM opts then \"udp\" else \"tcp\" in\n (getservbyport p kind).s_name\n with Not_found ->\n Int.to_string p in\n { ni_hostname = hostname; ni_service = service }\n\nlet getnameinfo addr opts =\n try\n getnameinfo_system addr opts\n with Invalid_argument _ ->\n getnameinfo_emulation addr opts\n\ntype terminal_io = {\n mutable c_ignbrk: bool;\n mutable c_brkint: bool;\n mutable c_ignpar: bool;\n mutable c_parmrk: bool;\n mutable c_inpck: bool;\n mutable c_istrip: bool;\n mutable c_inlcr: bool;\n mutable c_igncr: bool;\n mutable c_icrnl: bool;\n mutable c_ixon: bool;\n mutable c_ixoff: bool;\n mutable c_opost: bool;\n mutable c_obaud: int;\n mutable c_ibaud: int;\n mutable c_csize: int;\n mutable c_cstopb: int;\n mutable c_cread: bool;\n mutable c_parenb: bool;\n mutable c_parodd: bool;\n mutable c_hupcl: bool;\n mutable c_clocal: bool;\n mutable c_isig: bool;\n mutable c_icanon: bool;\n mutable c_noflsh: bool;\n mutable c_echo: bool;\n mutable c_echoe: bool;\n mutable c_echok: bool;\n mutable c_echonl: bool;\n mutable c_vintr: char;\n mutable c_vquit: char;\n mutable c_verase: char;\n mutable c_vkill: char;\n mutable c_veof: char;\n mutable c_veol: char;\n mutable c_vmin: int;\n mutable c_vtime: int;\n mutable c_vstart: char;\n mutable c_vstop: char\n }\n\nexternal tcgetattr: file_descr -> terminal_io = \"unix_tcgetattr\"\n\ntype setattr_when = TCSANOW | TCSADRAIN | TCSAFLUSH\n\nexternal tcsetattr: file_descr -> setattr_when -> terminal_io -> unit\n = \"unix_tcsetattr\"\nexternal tcsendbreak: file_descr -> int -> unit = \"unix_tcsendbreak\"\nexternal tcdrain: file_descr -> unit = \"unix_tcdrain\"\n\ntype flush_queue = TCIFLUSH | TCOFLUSH | TCIOFLUSH\n\nexternal tcflush: file_descr -> flush_queue -> unit = \"unix_tcflush\"\n\ntype flow_action = TCOOFF | TCOON | TCIOFF | TCION\n\nexternal tcflow: file_descr -> flow_action -> unit = \"unix_tcflow\"\n\nexternal setsid : unit -> int = \"unix_setsid\"\n\n(* High-level process management (system, popen) *)\n\nlet rec waitpid_non_intr pid =\n try waitpid [] pid\n with Unix_error (EINTR, _, _) -> waitpid_non_intr pid\n\nexternal spawn : string -> string array -> string array option ->\n bool -> int array -> int\n = \"unix_spawn\"\n\nlet system cmd =\n let pid = spawn shell [| shell; \"-c\"; cmd |] None false [| 0; 1; 2 |] in\n snd(waitpid_non_intr pid)\n\nlet create_process_gen cmd args optenv\n new_stdin new_stdout new_stderr =\n let toclose = ref [] in\n let close_after () =\n List.iter\n (fun fd -> try close fd with Unix_error(_,_,_) -> ())\n !toclose in\n (* Duplicate [fd] if needed to make sure it isn't one of the\n standard descriptors (stdin, stdout, stderr).\n The temporary file descriptors created here will be closed\n after the spawn, both in the parent (call to [close_after] below)\n and in the child (they are close-on-exec). *)\n let rec file_descr_not_standard fd =\n if fd >= 3 then fd else begin\n let fd' = dup ~cloexec:true fd in\n toclose := fd' :: !toclose;\n file_descr_not_standard fd'\n end in\n (* As an optimization, if a standard descriptor is not redirected,\n i.e. \"redirected to itself\", don't duplicate it: the [unix_spawn]\n C stub will perform no redirection either. *)\n let redirections = [|\n (if new_stdin = 0 then 0 else file_descr_not_standard new_stdin);\n (if new_stdout = 1 then 1 else file_descr_not_standard new_stdout);\n (if new_stderr = 2 then 2 else file_descr_not_standard new_stderr)\n |] in\n Fun.protect ~finally:close_after\n (fun () -> spawn cmd args optenv true (* usepath *) redirections)\n\nlet create_process cmd args new_stdin new_stdout new_stderr =\n create_process_gen cmd args None new_stdin new_stdout new_stderr\n\nlet create_process_env cmd args env new_stdin new_stdout new_stderr =\n create_process_gen cmd args (Some env) new_stdin new_stdout new_stderr\n\ntype popen_process =\n Process of in_channel * out_channel\n | Process_in of in_channel\n | Process_out of out_channel\n | Process_full of in_channel * out_channel * in_channel\n\nlet popen_processes = (Hashtbl.create 7 : (popen_process, int) Hashtbl.t)\n\nlet open_proc prog args envopt proc input output error =\n let pid =\n create_process_gen prog args envopt input output error in\n Hashtbl.add popen_processes proc pid\n\nlet open_process_args_in prog args =\n let (in_read, in_write) = pipe ~cloexec:true () in\n let inchan = in_channel_of_descr in_read in\n begin\n try\n open_proc prog args None (Process_in inchan) stdin in_write stderr\n with e ->\n close_in inchan;\n close in_write;\n raise e\n end;\n close in_write;\n inchan\n\nlet open_process_args_out prog args =\n let (out_read, out_write) = pipe ~cloexec:true () in\n let outchan = out_channel_of_descr out_write in\n begin\n try\n open_proc prog args None (Process_out outchan) out_read stdout stderr\n with e ->\n close_out outchan;\n close out_read;\n raise e\n end;\n close out_read;\n outchan\n\nlet open_process_args prog args =\n let (in_read, in_write) = pipe ~cloexec:true () in\n let (out_read, out_write) =\n try pipe ~cloexec:true ()\n with e -> close in_read; close in_write; raise e in\n let inchan = in_channel_of_descr in_read in\n let outchan = out_channel_of_descr out_write in\n begin\n try\n open_proc prog args None\n (Process(inchan, outchan)) out_read in_write stderr\n with e ->\n close out_read; close out_write;\n close in_read; close in_write;\n raise e\n end;\n close out_read;\n close in_write;\n (inchan, outchan)\n\nlet open_process_args_full prog args env =\n let (in_read, in_write) = pipe ~cloexec:true () in\n let (out_read, out_write) =\n try pipe ~cloexec:true ()\n with e -> close in_read; close in_write; raise e in\n let (err_read, err_write) =\n try pipe ~cloexec:true ()\n with e -> close in_read; close in_write;\n close out_read; close out_write; raise e in\n let inchan = in_channel_of_descr in_read in\n let outchan = out_channel_of_descr out_write in\n let errchan = in_channel_of_descr err_read in\n begin\n try\n open_proc prog args (Some env) (Process_full(inchan, outchan, errchan))\n out_read in_write err_write\n with e ->\n close out_read; close out_write;\n close in_read; close in_write;\n close err_read; close err_write;\n raise e\n end;\n close out_read;\n close in_write;\n close err_write;\n (inchan, outchan, errchan)\n\nlet open_process_shell fn cmd =\n fn shell [|shell; \"-c\"; cmd|]\nlet open_process_in cmd =\n open_process_shell open_process_args_in cmd\nlet open_process_out cmd =\n open_process_shell open_process_args_out cmd\nlet open_process cmd =\n open_process_shell open_process_args cmd\nlet open_process_full cmd =\n open_process_shell open_process_args_full cmd\n\nlet find_proc_id fun_name proc =\n try\n Hashtbl.find popen_processes proc\n with Not_found ->\n raise(Unix_error(EBADF, fun_name, \"\"))\n\nlet remove_proc_id proc =\n Hashtbl.remove popen_processes proc\n\nlet process_in_pid inchan =\n find_proc_id \"process_in_pid\" (Process_in inchan)\nlet process_out_pid outchan =\n find_proc_id \"process_out_pid\" (Process_out outchan)\nlet process_pid (inchan, outchan) =\n find_proc_id \"process_pid\" (Process(inchan, outchan))\nlet process_full_pid (inchan, outchan, errchan) =\n find_proc_id \"process_full_pid\"\n (Process_full(inchan, outchan, errchan))\n\nlet close_process_in inchan =\n let proc = Process_in inchan in\n let pid = find_proc_id \"close_process_in\" proc in\n remove_proc_id proc;\n close_in inchan;\n snd(waitpid_non_intr pid)\n\nlet close_process_out outchan =\n let proc = Process_out outchan in\n let pid = find_proc_id \"close_process_out\" proc in\n remove_proc_id proc;\n (* The application may have closed [outchan] already to signal\n end-of-input to the process. *)\n begin try close_out outchan with Sys_error _ -> () end;\n snd(waitpid_non_intr pid)\n\nlet close_process (inchan, outchan) =\n let proc = Process(inchan, outchan) in\n let pid = find_proc_id \"close_process\" proc in\n remove_proc_id proc;\n close_in inchan;\n begin try close_out outchan with Sys_error _ -> () end;\n snd(waitpid_non_intr pid)\n\nlet close_process_full (inchan, outchan, errchan) =\n let proc = Process_full(inchan, outchan, errchan) in\n let pid = find_proc_id \"close_process_full\" proc in\n remove_proc_id proc;\n close_in inchan;\n begin try close_out outchan with Sys_error _ -> () end;\n close_in errchan;\n snd(waitpid_non_intr pid)\n\n(* High-level network functions *)\n\nlet open_connection sockaddr =\n let sock =\n socket ~cloexec:true (domain_of_sockaddr sockaddr) SOCK_STREAM 0 in\n try\n connect sock sockaddr;\n (in_channel_of_descr sock, out_channel_of_descr sock)\n with exn ->\n close sock; raise exn\n\nlet shutdown_connection inchan =\n shutdown (descr_of_in_channel inchan) SHUTDOWN_SEND\n\nlet rec accept_non_intr s =\n try accept ~cloexec:true s\n with Unix_error (EINTR, _, _) -> accept_non_intr s\n\nlet establish_server server_fun sockaddr =\n let sock =\n socket ~cloexec:true (domain_of_sockaddr sockaddr) SOCK_STREAM 0 in\n setsockopt sock SO_REUSEADDR true;\n bind sock sockaddr;\n listen sock 5;\n while true do\n let (s, _caller) = accept_non_intr sock in\n (* The \"double fork\" trick, the process which calls server_fun will not\n leave a zombie process *)\n match fork() with\n 0 -> if fork() <> 0 then _exit 0;\n (* The child exits, the grandchild works *)\n close sock;\n let inchan = in_channel_of_descr s in\n let outchan = out_channel_of_descr s in\n server_fun inchan outchan;\n (* Do not close inchan nor outchan, as the server_fun could\n have done it already, and we are about to exit anyway\n (PR#3794) *)\n exit 0\n | id -> close s; ignore(waitpid_non_intr id) (* Reclaim the child *)\n done\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, 'n) t = ('a, 'n) Mina_wire_types.Pickles_types.Vector.t =\n | [] : ('a, z) t\n | ( :: ) : '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","let forbidden = \"Raised at \" | \"Called from \" | \"Raised by primitive operation \"\n\nrule check = parse\n | forbidden { true }\n | \"\" { not_at_bos lexbuf }\n\nand not_at_bos = parse\n | [^'a'-'z' 'A'-'Z' '0'-'9' '_'] forbidden { true }\n | _ { not_at_bos lexbuf }\n | eof { false }\n\n{\n let contains_backtraces s = check (Lexing.from_string s)\n}\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! 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 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\n\n val verification_key_perm_fallback_to_signature_with_older_version : t -> t\nend\n\nmodule type Txn_version_intf = sig\n include Iffable\n\n val equal_to_current : t -> bool\n\n val older_than_current : 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 type txn_version\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_auth : t -> controller\n\n val set_verification_key_txn_version : t -> txn_version\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 Txn_version : Txn_version_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 Permissions.txn_version := Txn_version.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 older_than_current_version =\n Txn_version.older_than_current\n (Account.Permissions.set_verification_key_txn_version a)\n in\n let original_auth = Account.Permissions.set_verification_key_auth a in\n let auth =\n Controller.if_ older_than_current_version\n ~then_:\n (Controller\n .verification_key_perm_fallback_to_signature_with_older_version\n original_auth )\n ~else_:original_auth\n in\n let has_permission =\n Controller.check ~proof_verifies ~signature_verifies auth\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","(* 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#ifdef INT\n | `Int i -> write_int ob i\n#endif\n#ifdef INTLIT\n | `Intlit s -> Bi_outbuf.add_string ob s\n#endif\n#ifdef FLOAT\n | `Float f -> write_float ob f\n#endif\n#ifdef FLOATLIT\n | `Floatlit s -> Bi_outbuf.add_string ob s\n#endif\n#ifdef STRING\n | `String s -> write_string ob s\n#endif\n#ifdef STRINGLIT\n | `Stringlit s -> Bi_outbuf.add_string ob s\n#endif\n | `Assoc l -> write_assoc ob l\n | `List l -> write_list ob l\n#ifdef TUPLE\n | `Tuple l -> write_tuple ob l\n#endif\n#ifdef VARIANT\n | `Variant (s, o) -> write_variant ob s o\n#endif\n\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#ifdef TUPLE\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#endif\n\n#ifdef VARIANT\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#endif\n\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#ifdef INT\n | `Int i -> write_int ob i\n#endif\n#ifdef INTLIT\n | `Intlit s -> Bi_outbuf.add_string ob s\n#endif\n#ifdef FLOAT\n | `Float f -> write_std_float ob f\n#endif\n#ifdef FLOATLIT\n | `Floatlit s -> Bi_outbuf.add_string ob s\n#endif\n#ifdef STRING\n | `String s -> write_string ob s\n#endif\n#ifdef STRINGLIT\n | `Stringlit s -> Bi_outbuf.add_string ob s\n#endif\n | `Assoc l -> write_std_assoc ob l\n | `List l -> write_std_list ob l\n#ifdef TUPLE\n | `Tuple l -> write_std_tuple ob l\n#endif\n#ifdef VARIANT\n | `Variant (s, o) -> write_std_variant ob s o\n#endif\n\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#ifdef VARIANT\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#endif\n\n\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#ifdef TUPLE\n | `Tuple l ->\n `Tuple (List.rev (List.rev_map sort l))\n#endif\n#ifdef VARIANT\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#endif\n | x -> x\n","let 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 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 #ifdef INT\n try `Int (extract_positive_int lexbuf)\n with Int_overflow ->\n #endif\n #ifdef INTLIT\n `Intlit (lexeme lexbuf)\n #else\n lexer_error \"Int overflow\" v lexbuf\n #endif\n\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 #ifdef INT\n try `Int (extract_negative_int lexbuf)\n with Int_overflow ->\n #endif\n #ifdef INTLIT\n `Intlit (lexeme lexbuf)\n #else\n lexer_error \"Int overflow\" v lexbuf\n #endif\n\n\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\nlet space = [' ' '\\t' '\\r']+\n\nlet digit = ['0'-'9']\nlet nonzero = ['1'-'9']\nlet digits = digit+\nlet frac = '.' digits\nlet e = ['e' 'E']['+' '-']?\nlet exp = e digits\n\nlet positive_int = (digit | nonzero digits)\nlet float = '-'? positive_int (frac | exp | frac exp)\nlet number = '-'? positive_int (frac | exp | frac exp)?\n\nlet hex = [ '0'-'9' 'a'-'f' 'A'-'F' ]\n\nlet ident = ['a'-'z' 'A'-'Z' '_']['a'-'z' 'A'-'Z' '_' '0'-'9']*\n\nlet optjunk4 = (eof | _ (eof | _ (eof | _ (eof | _))))\nlet optjunk8 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk4)))))\nlet optjunk12 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk8)))))\nlet optjunk16 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk12)))))\nlet optjunk20 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk16)))))\nlet optjunk24 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk20)))))\nlet optjunk28 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk24)))))\nlet optjunk32 = (eof | _ (eof | _ (eof | _ (eof | _ (eof | optjunk28)))))\nlet junk = optjunk32\n\nrule read_json v = parse\n | \"true\" { `Bool true }\n | \"false\" { `Bool false }\n | \"null\" { `Null }\n | \"NaN\" {\n #ifdef FLOAT\n `Float nan\n #elif defined FLOATLIT\n `Floatlit \"NaN\"\n #endif\n }\n | \"Infinity\" {\n #ifdef FLOAT\n `Float infinity\n #elif defined FLOATLIT\n `Floatlit \"Infinity\"\n #endif\n }\n | \"-Infinity\" {\n #ifdef FLOAT\n `Float neg_infinity\n #elif defined FLOATLIT\n `Floatlit \"-Infinity\"\n #endif\n }\n | '\"' {\n #ifdef STRING\n Bi_outbuf.clear v.buf;\n `String (finish_string v lexbuf)\n #elif defined STRINGLIT\n `Stringlit (finish_stringlit v lexbuf)\n #endif\n }\n | positive_int { make_positive_int v lexbuf }\n | '-' positive_int { make_negative_int v lexbuf }\n | float {\n #ifdef FLOAT\n `Float (float_of_string (lexeme lexbuf))\n #elif defined FLOATLIT\n `Floatlit (lexeme lexbuf)\n #endif\n }\n\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 | '[' { 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 | '(' {\n #ifdef TUPLE\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | '<' {\n #ifdef VARIANT\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | \"//\"[^'\\n']* { read_json v lexbuf }\n | \"/*\" { finish_comment v lexbuf; read_json v lexbuf }\n | \"\\n\" { newline v lexbuf; read_json v lexbuf }\n | space { read_json v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n | _ { long_error \"Invalid token\" v lexbuf }\n\n\nand finish_string v = parse\n '\"' { Bi_outbuf.contents v.buf }\n | '\\\\' { finish_escaped_char v lexbuf;\n finish_string v lexbuf }\n | [^ '\"' '\\\\']+ { add_lexeme v.buf lexbuf;\n finish_string v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand map_string v f = parse\n '\"' { let b = v.buf in\n f (Bytes.to_string b.Bi_outbuf.o_s) 0 b.Bi_outbuf.o_len }\n | '\\\\' { finish_escaped_char v lexbuf;\n map_string v f lexbuf }\n | [^ '\"' '\\\\']+ { add_lexeme v.buf lexbuf;\n map_string v f lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_escaped_char v = parse\n '\"'\n | '\\\\'\n | '/' as c { Bi_outbuf.add_char v.buf c }\n | 'b' { Bi_outbuf.add_char v.buf '\\b' }\n | 'f' { Bi_outbuf.add_char v.buf '\\012' }\n | 'n' { Bi_outbuf.add_char v.buf '\\n' }\n | 'r' { Bi_outbuf.add_char v.buf '\\r' }\n | 't' { Bi_outbuf.add_char v.buf '\\t' }\n | 'u' (hex as a) (hex as b) (hex as c) (hex as d)\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 | _ { long_error \"Invalid escape sequence\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_surrogate_pair v x = parse\n | \"\\\\u\" (hex as a) (hex as b) (hex as c) (hex as d)\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 | _ { long_error \"Missing escape sequence representing low surrogate \\\n for code point beyond U+FFFF\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_stringlit v = parse\n ( '\\\\' (['\"' '\\\\' '/' 'b' 'f' 'n' 'r' 't'] | 'u' hex hex hex hex)\n | [^'\"' '\\\\'] )* '\"'\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 | _ { long_error \"Invalid string literal\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_variant v = parse\n ':' { let x = read_json v lexbuf in\n read_space v lexbuf;\n read_gt v lexbuf;\n Some x }\n | '>' { None }\n | _ { long_error \"Expected ':' or '>' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_lt v = parse\n '<' { () }\n | _ { long_error \"Expected '<' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_gt v = parse\n '>' { () }\n | _ { long_error \"Expected '>' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_comma v = parse\n ',' { () }\n | _ { long_error \"Expected ',' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand start_any_variant v = parse\n '<' { `Edgy_bracket }\n | '\"' { Bi_outbuf.clear v.buf;\n `Double_quote }\n | '[' { `Square_bracket }\n | _ { long_error \"Expected '<', '\\\"' or '[' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_comment v = parse\n | \"*/\" { () }\n | eof { long_error \"Unterminated comment\" v lexbuf }\n | '\\n' { newline v lexbuf; finish_comment v lexbuf }\n | _ { finish_comment v lexbuf }\n\n\n\n\n(* Readers expecting a particular JSON construct *)\n\nand read_eof = parse\n eof { true }\n | \"\" { false }\n\nand read_space v = parse\n | \"//\"[^'\\n']* ('\\n'|eof) { newline v lexbuf; read_space v lexbuf }\n | \"/*\" { finish_comment v lexbuf; read_space v lexbuf }\n | '\\n' { newline v lexbuf; read_space v lexbuf }\n | [' ' '\\t' '\\r']+ { read_space v lexbuf }\n | \"\" { () }\n\nand read_null v = parse\n \"null\" { () }\n | _ { long_error \"Expected 'null' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_null_if_possible v = parse\n \"null\" { true }\n | \"\" { false }\n\nand read_bool v = parse\n \"true\" { true }\n | \"false\" { false }\n\n (* tolerate booleans passed as strings without \\u obfuscation *)\n | \"\\\"true\\\"\" { true }\n | \"\\\"false\\\"\" { false }\n\n | _ { long_error \"Expected 'true' or 'false' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_int v = parse\n positive_int { try extract_positive_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf }\n | '-' positive_int { try extract_negative_int lexbuf\n with Int_overflow ->\n lexer_error \"Int overflow\" v lexbuf }\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 | _ { long_error \"Expected integer but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_int32 v = parse\n '-'? positive_int { try Int32.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf }\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 | _ { long_error \"Expected int32 but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_int64 v = parse\n '-'? positive_int { try Int64.of_string (Lexing.lexeme lexbuf)\n with _ ->\n lexer_error \"Int32 overflow\" v lexbuf }\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 | _ { long_error \"Expected int64 but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_number v = parse\n | \"NaN\" { nan }\n | \"Infinity\" { infinity }\n | \"-Infinity\" { neg_infinity }\n | number { float_of_string (lexeme lexbuf) }\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 | _ { long_error \"Expected number but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_string v = parse\n '\"' { Bi_outbuf.clear v.buf;\n finish_string v lexbuf }\n | _ { long_error \"Expected '\\\"' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_ident v = parse\n '\"' { Bi_outbuf.clear v.buf;\n finish_string v lexbuf }\n | ident as s\n { s }\n | _ { long_error \"Expected string or identifier but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand map_ident v f = parse\n '\"' { Bi_outbuf.clear v.buf;\n map_string v f lexbuf }\n | ident\n { map_lexeme f lexbuf }\n | _ { long_error \"Expected string or identifier but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_sequence read_cell init_acc v = parse\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 | _ { long_error \"Expected '[' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_list_rev read_cell v = parse\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 | _ { long_error \"Expected '[' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_array_end = parse\n ']' { raise End_of_array }\n | \"\" { () }\n\nand read_array_sep v = parse\n ',' { () }\n | ']' { raise End_of_array }\n | _ { long_error \"Expected ',' or ']' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\n\nand read_tuple read_cell init_acc v = parse\n '(' {\n #ifdef TUPLE\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n | _ { long_error \"Expected ')' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_tuple_end = parse\n ')' { raise End_of_tuple }\n | \"\" { () }\n\nand read_tuple_end2 v std = parse\n ')' { if std then\n long_error \"Expected ')' or '' but found\" v lexbuf\n else\n raise End_of_tuple }\n | ']' { if std then\n raise End_of_tuple\n else\n long_error \"Expected ']' or '' but found\" v lexbuf }\n | \"\" { () }\n\nand read_tuple_sep v = parse\n ',' { () }\n | ')' { raise End_of_tuple }\n | _ { long_error \"Expected ',' or ')' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_tuple_sep2 v std = parse\n ',' { () }\n | ')' { if std then\n long_error \"Expected ',' or ']' but found\" v lexbuf\n else\n raise End_of_tuple }\n | ']' { if std then\n raise End_of_tuple\n else\n long_error \"Expected ',' or ')' but found\" v lexbuf }\n | _ { long_error \"Expected ',' or ')' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\n(* Read a JSON object, reading the keys using a custom parser *)\nand read_abstract_fields read_key read_field init_acc v = parse\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 | _ { long_error \"Expected '{' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_lcurl v = parse\n '{' { () }\n | _ { long_error \"Expected '{' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_object_end = parse\n '}' { raise End_of_object }\n | \"\" { () }\n\nand read_object_sep v = parse\n ',' { () }\n | '}' { raise End_of_object }\n | _ { long_error \"Expected ',' or '}' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_colon v = parse\n ':' { () }\n | _ { long_error \"Expected ':' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand start_any_tuple v = parse\n '(' { false }\n | '[' { true }\n | _ { long_error \"Expected '(' or '[' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_lpar v = parse\n '(' { () }\n | _ { long_error \"Expected '(' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_rpar v = parse\n ')' { () }\n | _ { long_error \"Expected ')' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_lbr v = parse\n '[' { () }\n | _ { long_error \"Expected '[' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand read_rbr v = parse\n ']' { () }\n | _ { long_error \"Expected ']' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\n(*** And now pretty much the same thing repeated,\n only for the purpose of skipping ignored field values ***)\n\nand skip_json v = parse\n | \"true\" { () }\n | \"false\" { () }\n | \"null\" { () }\n | \"NaN\" { () }\n | \"Infinity\" { () }\n | \"-Infinity\" { () }\n | '\"' { finish_skip_stringlit v lexbuf }\n | '-'? positive_int { () }\n | float { () }\n\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 | '[' { 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 | '(' {\n #ifdef TUPLE\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | '<' {\n #ifdef VARIANT\n read_space v lexbuf;\n skip_ident v lexbuf;\n read_space v lexbuf;\n finish_skip_variant v lexbuf\n #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | \"//\"[^'\\n']* { skip_json v lexbuf }\n | \"/*\" { finish_comment v lexbuf; skip_json v lexbuf }\n | \"\\n\" { newline v lexbuf; skip_json v lexbuf }\n | space { skip_json v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n | _ { long_error \"Invalid token\" v lexbuf }\n\n\nand finish_skip_stringlit v = parse\n ( '\\\\' (['\"' '\\\\' '/' 'b' 'f' 'n' 'r' 't'] | 'u' hex hex hex hex)\n | [^'\"' '\\\\'] )* '\"'\n { () }\n | _ { long_error \"Invalid string literal\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_skip_variant v = parse\n ':' { skip_json v lexbuf;\n read_space v lexbuf;\n read_gt v lexbuf }\n | '>' { () }\n | _ { long_error \"Expected ':' or '>' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand skip_ident v = parse\n '\"' { finish_skip_stringlit v lexbuf }\n | ident { () }\n | _ { long_error \"Expected string or identifier but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\n(*** And now pretty much the same thing repeated,\n only for the purpose of buffering deferred field values ***)\n\nand buffer_json v = parse\n | \"true\"\n | \"false\"\n | \"null\"\n | \"NaN\"\n | \"Infinity\"\n | \"-Infinity\"\n | '-'? positive_int\n | float { add_lexeme v.buf lexbuf }\n\n | '\"' { finish_buffer_stringlit v lexbuf }\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 | '[' { 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 | '(' {\n #ifdef TUPLE\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | '<' {\n #ifdef VARIANT\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 #else\n long_error \"Invalid token\" v lexbuf\n #endif\n }\n\n | \"//\"[^'\\n']* { add_lexeme v.buf lexbuf; buffer_json v lexbuf }\n | \"/*\" { Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_json v lexbuf }\n | \"\\n\" { Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_json v lexbuf }\n | space { add_lexeme v.buf lexbuf; buffer_json v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n | _ { long_error \"Invalid token\" v lexbuf }\n\n\nand finish_buffer_stringlit v = parse\n ( '\\\\' (['\"' '\\\\' '/' 'b' 'f' 'n' 'r' 't'] | 'u' hex hex hex hex)\n | [^'\"' '\\\\'] )* '\"'\n { Bi_outbuf.add_char v.buf '\"';\n add_lexeme v.buf lexbuf\n }\n | _ { long_error \"Invalid string literal\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_buffer_variant v = parse\n ':' { Bi_outbuf.add_char v.buf ':';\n buffer_json v lexbuf;\n buffer_space v lexbuf;\n buffer_gt v lexbuf }\n | '>' { Bi_outbuf.add_char v.buf '>' }\n | _ { long_error \"Expected ':' or '>' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_ident v = parse\n '\"' { finish_buffer_stringlit v lexbuf }\n | ident { add_lexeme v.buf lexbuf }\n | _ { long_error \"Expected string or identifier but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_space v = parse\n | \"//\"[^'\\n']* ('\\n'|eof) {\n add_lexeme v.buf lexbuf;\n newline v lexbuf;\n buffer_space v lexbuf }\n | \"/*\" {\n Bi_outbuf.add_string v.buf \"/*\";\n finish_buffer_comment v lexbuf;\n buffer_space v lexbuf }\n | '\\n' {\n Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n buffer_space v lexbuf }\n | [' ' '\\t' '\\r']+ {\n add_lexeme v.buf lexbuf;\n buffer_space v lexbuf }\n | \"\" { () }\n\nand buffer_object_end v = parse\n '}' {\n Bi_outbuf.add_char v.buf '}';\n raise End_of_object }\n | \"\" { () }\n\nand buffer_object_sep v = parse\n ',' { Bi_outbuf.add_char v.buf ',' }\n | '}' { Bi_outbuf.add_char v.buf '}'; raise End_of_object }\n | _ { long_error \"Expected ',' or '}' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_array_end v = parse\n ']' { Bi_outbuf.add_char v.buf ']'; raise End_of_array }\n | \"\" { () }\n\nand buffer_array_sep v = parse\n ',' { Bi_outbuf.add_char v.buf ',' }\n | ']' { Bi_outbuf.add_char v.buf ']'; raise End_of_array }\n | _ { long_error \"Expected ',' or ']' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_tuple_end v = parse\n ')' {\n Bi_outbuf.add_char v.buf ')';\n raise End_of_tuple }\n | \"\" { () }\n\nand buffer_tuple_sep v = parse\n ',' { Bi_outbuf.add_char v.buf ',' }\n | ')' { Bi_outbuf.add_char v.buf ')'; raise End_of_tuple }\n | _ { long_error \"Expected ',' or ')' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_colon v = parse\n ':' { Bi_outbuf.add_char v.buf ':' }\n | _ { long_error \"Expected ':' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand buffer_gt v = parse\n '>' { Bi_outbuf.add_char v.buf '>' }\n | _ { long_error \"Expected '>' but found\" v lexbuf }\n | eof { custom_error \"Unexpected end of input\" v lexbuf }\n\nand finish_buffer_comment v = parse\n | \"*/\" { Bi_outbuf.add_string v.buf \"*/\" }\n | eof { long_error \"Unterminated comment\" v lexbuf }\n | '\\n' { Bi_outbuf.add_char v.buf '\\n';\n newline v lexbuf;\n finish_buffer_comment v lexbuf }\n | _ { add_lexeme v.buf lexbuf; finish_buffer_comment v lexbuf }\n\nand junk = parse\n junk { Lexing.lexeme lexbuf }\n\n{\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","let 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","exception 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","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","(* 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","(* 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 print_rust : t -> unit = \"caml_pasta_fp_print_rust\"\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 print_rust : t -> unit = \"caml_pasta_fq_print_rust\"\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","(* 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.lookup_table array\n -> Pasta_bindings.Fp.t Kimchi_types.runtime_table_cfg array\n -> int\n -> SRS.Fp.t\n -> t\n = \"caml_pasta_fp_plonk_index_create_bytecode\" \"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.lookup_table array\n -> Pasta_bindings.Fq.t Kimchi_types.runtime_table_cfg array\n -> int\n -> SRS.Fq.t\n -> t\n = \"caml_pasta_fq_plonk_index_create_bytecode\" \"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_no_public\"\n\n external create_with_public_evals :\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.proof_with_public\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_no_public\"\n\n external create_with_public_evals :\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.proof_with_public\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 Kimchi_types.runtime_table 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.proof_with_public = \"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 Kimchi_types.runtime_table 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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public\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.proof_with_public = \"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.proof_with_public\n -> ( Pasta_bindings.Fq.t Kimchi_types.or_infinity\n , Pasta_bindings.Fp.t )\n Kimchi_types.proof_with_public\n = \"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 Kimchi_types.runtime_table 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.proof_with_public = \"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.proof_with_public\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.proof_with_public\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.proof_with_public = \"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.proof_with_public\n -> ( Pasta_bindings.Fp.t Kimchi_types.or_infinity\n , Pasta_bindings.Fq.t )\n Kimchi_types.proof_with_public\n = \"caml_pasta_fq_plonk_proof_deep_copy\"\n end\n end\nend\n","open 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","include 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","let 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","module 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 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 : 'bool Pickles_types.Plonk_types.Features.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 type 'a columns_vec = ('a, Pickles_types.Nat.fifteen) Pickles_types.Vector.t\n\n type 'a quotient_polynomial_vec =\n ('a, Pickles_types.Nat.seven) Pickles_types.Vector.t\n\n type 'a permuts_minus_1_vec =\n ('a, Pickles_types.Nat.six) Pickles_types.Vector.t\n\n module Commitments = struct\n module V1 = struct\n type t =\n { w_comm : (Pasta_bindings.Fp.t * Pasta_bindings.Fp.t) columns_vec\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\n }\n end\n end\n\n module Evaluations = struct\n module V1 = struct\n type t =\n { w : (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t) columns_vec\n ; coefficients :\n (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t) columns_vec\n ; z : Pasta_bindings.Fq.t * Pasta_bindings.Fq.t\n ; s : (Pasta_bindings.Fq.t * Pasta_bindings.Fq.t) permuts_minus_1_vec\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.V1.t\n }\n end\n end\n\n module Proof = struct\n type challenge_constant =\n Pickles_types.Nat.two Pickles_limb_vector.Constant.t\n\n type tock_affine = Pasta_bindings.Fp.t * Pasta_bindings.Fp.t\n\n type 'a step_bp_vec = ('a, Pickles_types.Nat.sixteen) Pickles_types.Vector.t\n\n module Base = struct\n module Wrap = struct\n module V2 = struct\n type digest_constant =\n Pickles_types.Nat.four Pickles_limb_vector.Constant.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\n Pickles_types.Shifted_value.Type1.V1.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.V1.t\n (* A job half-done may be worse than not done at all.\n TODO: Migrate Plonk_types here, and actually include the\n *wire* type, not this in-memory version.\n *)\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.two, Pickles_types.Nat.two) 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 = struct\n type n = Pickles_types.Nat.two\n end\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.two, Pickles_types.Nat.two) t\n end\n end\n end\n\n module Side_loaded : sig\n module Verification_key : sig\n module Max_width : sig\n type n = Pickles_types.Nat.two\n end\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","open Utils\n\nmodule Types = struct\n module type S = sig\n module Digest : V1S0\n\n include V2S0\n end\nend\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\nmodule M = struct\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\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 Txn_version = 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","module 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","open Utils\n\nmodule Types = struct\n module type S = V2S0\nend\n\nmodule type Concrete = sig\n module V2 : sig\n type t = { transaction : int; network : int; patch : int }\n end\nend\n\nmodule M = struct\n module V2 = struct\n type t = { transaction : int; network : int; patch : int }\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! 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","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Gabriel Scherer, projet Parsifal, INRIA Saclay *)\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\ntype path = string\ntype path_prefix = string\ntype error_message = string\n\nlet errorf fmt = Printf.kprintf (fun err -> Error err) fmt\n\nlet encode_prefix str =\n let buf = Buffer.create (String.length str) in\n let push_char = function\n | '%' -> Buffer.add_string buf \"%#\"\n | '=' -> Buffer.add_string buf \"%+\"\n | ':' -> Buffer.add_string buf \"%.\"\n | c -> Buffer.add_char buf c\n in\n String.iter push_char str;\n Buffer.contents buf\n\nlet decode_prefix str =\n let buf = Buffer.create (String.length str) in\n let rec loop i =\n if i >= String.length str\n then Ok (Buffer.contents buf)\n else match str.[i] with\n | ('=' | ':') as c ->\n errorf \"invalid character '%c' in key or value\" c\n | '%' ->\n let push c = Buffer.add_char buf c; loop (i + 2) in\n if i + 1 = String.length str then\n errorf \"invalid encoded string %S (trailing '%%')\" str\n else begin match str.[i + 1] with\n | '#' -> push '%'\n | '+' -> push '='\n | '.' -> push ':'\n | c -> errorf \"invalid %%-escaped character '%c'\" c\n end\n | c ->\n Buffer.add_char buf c;\n loop (i + 1)\n in loop 0\n\ntype pair = { target: path_prefix; source : path_prefix }\n\nlet encode_pair { target; source } =\n String.concat \"=\" [encode_prefix target; encode_prefix source]\n\nlet decode_pair str =\n match String.index str '=' with\n | exception Not_found ->\n errorf \"invalid key/value pair %S, no '=' separator\" str\n | equal_pos ->\n let encoded_target = String.sub str 0 equal_pos in\n let encoded_source =\n String.sub str (equal_pos + 1) (String.length str - equal_pos - 1) in\n match decode_prefix encoded_target, decode_prefix encoded_source with\n | Ok target, Ok source -> Ok { target; source }\n | ((Error _ as err), _) | (_, (Error _ as err)) -> err\n\ntype map = pair option list\n\nlet encode_map map =\n let encode_elem = function\n | None -> \"\"\n | Some pair -> encode_pair pair\n in\n List.map encode_elem map\n |> String.concat \":\"\n\nlet decode_map str =\n let exception Shortcut of error_message in\n let decode_or_empty = function\n | \"\" -> None\n | pair ->\n begin match decode_pair pair with\n | Ok str -> Some str\n | Error err -> raise (Shortcut err)\n end\n in\n let pairs = String.split_on_char ':' str in\n match List.map decode_or_empty pairs with\n | exception (Shortcut err) -> Error err\n | map -> Ok map\n\nlet rewrite_opt prefix_map path =\n let is_prefix = function\n | None -> false\n | Some { target = _; source } ->\n String.length source <= String.length path\n && String.equal source (String.sub path 0 (String.length source))\n in\n match\n List.find is_prefix\n (* read key/value pairs from right to left, as the spec demands *)\n (List.rev prefix_map)\n with\n | exception Not_found -> None\n | None -> None\n | Some { source; target } ->\n Some (target ^ (String.sub path (String.length source)\n (String.length path - String.length source)))\n\nlet rewrite prefix_map path =\n match rewrite_opt prefix_map path with\n | None -> path\n | Some path -> path\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Chambart, OCamlPro *)\n(* Mark Shinwell and Leo White, Jane Street Europe *)\n(* *)\n(* Copyright 2013--2016 OCamlPro SAS *)\n(* Copyright 2014--2016 Jane Street Group LLC *)\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 Thing = sig\n type t\n\n include Hashtbl.HashedType with type t := t\n include Map.OrderedType with type t := t\n\n val output : out_channel -> t -> unit\n val print : Format.formatter -> t -> unit\nend\n\nmodule type Set = sig\n module T : Set.OrderedType\n include Set.S\n with type elt = T.t\n and type t = Set.Make (T).t\n\n val output : out_channel -> t -> unit\n val print : Format.formatter -> t -> unit\n val to_string : t -> string\n val of_list : elt list -> t\n val map : (elt -> elt) -> t -> t\nend\n\nmodule type Map = sig\n module T : Map.OrderedType\n include Map.S\n with type key = T.t\n and type 'a t = 'a Map.Make (T).t\n\n val of_list : (key * 'a) list -> 'a t\n\n val disjoint_union :\n ?eq:('a -> 'a -> bool) -> ?print:(Format.formatter -> 'a -> unit) -> 'a t ->\n 'a t -> 'a t\n\n val union_right : 'a t -> 'a t -> 'a t\n\n val union_left : 'a t -> 'a t -> 'a t\n\n val union_merge : ('a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t\n val rename : key t -> key -> key\n val map_keys : (key -> key) -> 'a t -> 'a t\n val keys : 'a t -> Set.Make(T).t\n val data : 'a t -> 'a list\n val of_set : (key -> 'a) -> Set.Make(T).t -> 'a t\n val transpose_keys_and_data : key t -> key t\n val transpose_keys_and_data_set : key t -> Set.Make(T).t t\n val print :\n (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a t -> unit\nend\n\nmodule type Tbl = sig\n module T : sig\n type t\n include Map.OrderedType with type t := t\n include Hashtbl.HashedType with type t := t\n end\n include Hashtbl.S\n with type key = T.t\n and type 'a t = 'a Hashtbl.Make (T).t\n\n val to_list : 'a t -> (T.t * 'a) list\n val of_list : (T.t * 'a) list -> 'a t\n\n val to_map : 'a t -> 'a Map.Make(T).t\n val of_map : 'a Map.Make(T).t -> 'a t\n val memoize : 'a t -> (key -> 'a) -> key -> 'a\n val map : 'a t -> ('a -> 'b) -> 'b t\nend\n\nmodule Pair (A : Thing) (B : Thing) : Thing with type t = A.t * B.t = struct\n type t = A.t * B.t\n\n let compare (a1, b1) (a2, b2) =\n let c = A.compare a1 a2 in\n if c <> 0 then c\n else B.compare b1 b2\n\n let output oc (a, b) = Printf.fprintf oc \" (%a, %a)\" A.output a B.output b\n let hash (a, b) = Hashtbl.hash (A.hash a, B.hash b)\n let equal (a1, b1) (a2, b2) = A.equal a1 a2 && B.equal b1 b2\n let print ppf (a, b) = Format.fprintf ppf \" (%a, @ %a)\" A.print a B.print b\nend\n\nmodule Make_map (T : Thing) = struct\n include Map.Make (T)\n\n let of_list l =\n List.fold_left (fun map (id, v) -> add id v map) empty l\n\n let disjoint_union ?eq ?print m1 m2 =\n union (fun id v1 v2 ->\n let ok = match eq with\n | None -> false\n | Some eq -> eq v1 v2\n in\n if not ok then\n let err =\n match print with\n | None ->\n Format.asprintf \"Map.disjoint_union %a\" T.print id\n | Some print ->\n Format.asprintf \"Map.disjoint_union %a => %a <> %a\"\n T.print id print v1 print v2\n in\n Misc.fatal_error err\n else Some v1)\n m1 m2\n\n let union_right m1 m2 =\n merge (fun _id x y -> match x, y with\n | None, None -> None\n | None, Some v\n | Some v, None\n | Some _, Some v -> Some v)\n m1 m2\n\n let union_left m1 m2 = union_right m2 m1\n\n let union_merge f m1 m2 =\n let aux _ m1 m2 =\n match m1, m2 with\n | None, m | m, None -> m\n | Some m1, Some m2 -> Some (f m1 m2)\n in\n merge aux m1 m2\n\n let rename m v =\n try find v m\n with Not_found -> v\n\n let map_keys f m =\n of_list (List.map (fun (k, v) -> f k, v) (bindings m))\n\n let print f ppf s =\n let elts ppf s = iter (fun id v ->\n Format.fprintf ppf \"@ (@[%a@ %a@])\" T.print id f v) s in\n Format.fprintf ppf \"@[<1>{@[%a@ @]}@]\" elts s\n\n module T_set = Set.Make (T)\n\n let keys map = fold (fun k _ set -> T_set.add k set) map T_set.empty\n\n let data t = List.map snd (bindings t)\n\n let of_set f set = T_set.fold (fun e map -> add e (f e) map) set empty\n\n let transpose_keys_and_data map = fold (fun k v m -> add v k m) map empty\n let transpose_keys_and_data_set map =\n fold (fun k v m ->\n let set =\n match find v m with\n | exception Not_found ->\n T_set.singleton k\n | set ->\n T_set.add k set\n in\n add v set m)\n map empty\nend\n\nmodule Make_set (T : Thing) = struct\n include Set.Make (T)\n\n let output oc s =\n Printf.fprintf oc \" ( \";\n iter (fun v -> Printf.fprintf oc \"%a \" T.output v) s;\n Printf.fprintf oc \")\"\n\n let print ppf s =\n let elts ppf s = iter (fun e -> Format.fprintf ppf \"@ %a\" T.print e) s in\n Format.fprintf ppf \"@[<1>{@[%a@ @]}@]\" elts s\n\n let to_string s = Format.asprintf \"%a\" print s\n\n let of_list l = match l with\n | [] -> empty\n | [t] -> singleton t\n | t :: q -> List.fold_left (fun acc e -> add e acc) (singleton t) q\n\n let map f s = of_list (List.map f (elements s))\nend\n\nmodule Make_tbl (T : Thing) = struct\n include Hashtbl.Make (T)\n\n module T_map = Make_map (T)\n\n let to_list t =\n fold (fun key datum elts -> (key, datum)::elts) t []\n\n let of_list elts =\n let t = create 42 in\n List.iter (fun (key, datum) -> add t key datum) elts;\n t\n\n let to_map v = fold T_map.add v T_map.empty\n\n let of_map m =\n let t = create (T_map.cardinal m) in\n T_map.iter (fun k v -> add t k v) m;\n t\n\n let memoize t f = fun key ->\n try find t key with\n | Not_found ->\n let r = f key in\n add t key r;\n r\n\n let map t f =\n of_map (T_map.map f (to_map t))\nend\n\nmodule type S = sig\n type t\n\n module T : Thing with type t = t\n include Thing with type t := T.t\n\n module Set : Set with module T := T\n module Map : Map with module T := T\n module Tbl : Tbl with module T := T\nend\n\nmodule Make (T : Thing) = struct\n module T = T\n include T\n\n module Set = Make_set (T)\n module Map = Make_map (T)\n module Tbl = Make_tbl (T)\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Chambart, OCamlPro *)\n(* Mark Shinwell and Leo White, Jane Street Europe *)\n(* *)\n(* Copyright 2013--2016 OCamlPro SAS *)\n(* Copyright 2014--2016 Jane Street Group LLC *)\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 Int_base = Identifiable.Make (struct\n type t = int\n\n let compare x y = x - y\n let output oc x = Printf.fprintf oc \"%i\" x\n let hash i = i\n let equal (i : int) j = i = j\n let print = Format.pp_print_int\nend)\n\nmodule Int = struct\n type t = int\n\n include Int_base\n\n let rec zero_to_n n =\n if n < 0 then Set.empty else Set.add n (zero_to_n (n-1))\n\n let to_string n = Int.to_string n\nend\n\nmodule Int8 = struct\n type t = int\n\n let zero = 0\n let one = 1\n\n let of_int_exn i =\n if i < -(1 lsl 7) || i > ((1 lsl 7) - 1) then\n Misc.fatal_errorf \"Int8.of_int_exn: %d is out of range\" i\n else\n i\n\n let to_int i = i\nend\n\nmodule Int16 = struct\n type t = int\n\n let of_int_exn i =\n if i < -(1 lsl 15) || i > ((1 lsl 15) - 1) then\n Misc.fatal_errorf \"Int16.of_int_exn: %d is out of range\" i\n else\n i\n\n let lower_int64 = Int64.neg (Int64.shift_left Int64.one 15)\n let upper_int64 = Int64.sub (Int64.shift_left Int64.one 15) Int64.one\n\n let of_int64_exn i =\n if Int64.compare i lower_int64 < 0\n || Int64.compare i upper_int64 > 0\n then\n Misc.fatal_errorf \"Int16.of_int64_exn: %Ld is out of range\" i\n else\n Int64.to_int i\n\n let to_int t = t\nend\n\nmodule Float = struct\n type t = float\n\n include Identifiable.Make (struct\n type t = float\n\n let compare x y = Stdlib.compare x y\n let output oc x = Printf.fprintf oc \"%f\" x\n let hash f = Hashtbl.hash f\n let equal (i : float) j = i = j\n let print = Format.pp_print_float\n end)\nend\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Pierre Chambart, OCamlPro *)\n(* Mark Shinwell and Leo White, Jane Street Europe *)\n(* *)\n(* Copyright 2015--2016 OCamlPro SAS *)\n(* Copyright 2015--2016 Jane Street Group LLC *)\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 fatal err =\n prerr_endline err;\n exit 2\n\nmodule Make (S : sig\n module Key : sig\n type t\n val of_string : string -> t\n module Map : Map.S with type key = t\n end\n\n module Value : sig\n type t\n val of_string : string -> t\n end\nend) = struct\n type parsed = {\n base_default : S.Value.t;\n base_override : S.Value.t S.Key.Map.t;\n user_default : S.Value.t option;\n user_override : S.Value.t S.Key.Map.t;\n }\n\n let default v =\n { base_default = v;\n base_override = S.Key.Map.empty;\n user_default = None;\n user_override = S.Key.Map.empty; }\n\n let set_base_default value t =\n { t with base_default = value }\n\n let add_base_override key value t =\n { t with base_override = S.Key.Map.add key value t.base_override }\n\n let reset_base_overrides t =\n { t with base_override = S.Key.Map.empty }\n\n let set_user_default value t =\n { t with user_default = Some value }\n\n let add_user_override key value t =\n { t with user_override = S.Key.Map.add key value t.user_override }\n\n exception Parse_failure of exn\n\n let parse_exn str ~update =\n (* Is the removal of empty chunks really relevant here? *)\n (* (It has been added to mimic the old Misc.String.split.) *)\n let values = String.split_on_char ',' str |> List.filter ((<>) \"\") in\n let parsed =\n List.fold_left (fun acc value ->\n match String.index value '=' with\n | exception Not_found ->\n begin match S.Value.of_string value with\n | value -> set_user_default value acc\n | exception exn -> raise (Parse_failure exn)\n end\n | equals ->\n let key_value_pair = value in\n let length = String.length key_value_pair in\n assert (equals >= 0 && equals < length);\n if equals = 0 then begin\n raise (Parse_failure (\n Failure \"Missing key in argument specification\"))\n end;\n let key =\n let key = String.sub key_value_pair 0 equals in\n try S.Key.of_string key\n with exn -> raise (Parse_failure exn)\n in\n let value =\n let value =\n String.sub key_value_pair (equals + 1) (length - equals - 1)\n in\n try S.Value.of_string value\n with exn -> raise (Parse_failure exn)\n in\n add_user_override key value acc)\n !update\n values\n in\n update := parsed\n\n let parse str help_text update =\n match parse_exn str ~update with\n | () -> ()\n | exception (Parse_failure exn) ->\n fatal (Printf.sprintf \"%s: %s\" (Printexc.to_string exn) help_text)\n\n type parse_result =\n | Ok\n | Parse_failed of exn\n\n let parse_no_error str update =\n match parse_exn str ~update with\n | () -> Ok\n | exception (Parse_failure exn) -> Parse_failed exn\n\n let get ~key parsed =\n match S.Key.Map.find key parsed.user_override with\n | value -> value\n | exception Not_found ->\n match parsed.user_default with\n | Some value -> value\n | None ->\n match S.Key.Map.find key parsed.base_override with\n | value -> value\n | exception Not_found -> parsed.base_default\n\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(* Command-line parameters *)\n\nmodule Int_arg_helper = Arg_helper.Make (struct\n module Key = struct\n include Numbers.Int\n let of_string = int_of_string\n end\n\n module Value = struct\n include Numbers.Int\n let of_string = int_of_string\n end\nend)\nmodule Float_arg_helper = Arg_helper.Make (struct\n module Key = struct\n include Numbers.Int\n let of_string = int_of_string\n end\n\n module Value = struct\n include Numbers.Float\n let of_string = float_of_string\n end\nend)\n\nlet objfiles = ref ([] : string list) (* .cmo and .cma files *)\nand ccobjs = ref ([] : string list) (* .o, .a, .so and -cclib -lxxx *)\nand dllibs = ref ([] : string list) (* .so and -dllib -lxxx *)\n\nlet compile_only = ref false (* -c *)\nand output_name = ref (None : string option) (* -o *)\nand include_dirs = ref ([] : string list)(* -I *)\nand no_std_include = ref false (* -nostdlib *)\nand print_types = ref false (* -i *)\nand make_archive = ref false (* -a *)\nand debug = ref false (* -g *)\nand debug_full = ref false (* For full DWARF support *)\nand unsafe = ref false (* -unsafe *)\nand use_linscan = ref false (* -linscan *)\nand link_everything = ref false (* -linkall *)\nand custom_runtime = ref false (* -custom *)\nand no_check_prims = ref false (* -no-check-prims *)\nand bytecode_compatible_32 = ref false (* -compat-32 *)\nand output_c_object = ref false (* -output-obj *)\nand output_complete_object = ref false (* -output-complete-obj *)\nand output_complete_executable = ref false (* -output-complete-exe *)\nand all_ccopts = ref ([] : string list) (* -ccopt *)\nand classic = ref false (* -nolabels *)\nand nopervasives = ref false (* -nopervasives *)\nand match_context_rows = ref 32 (* -match-context-rows *)\nand preprocessor = ref(None : string option) (* -pp *)\nand all_ppx = ref ([] : string list) (* -ppx *)\nlet absname = ref false (* -absname *)\nlet annotations = ref false (* -annot *)\nlet binary_annotations = ref false (* -bin-annot *)\nand use_threads = ref false (* -thread *)\nand noassert = ref false (* -noassert *)\nand verbose = ref false (* -verbose *)\nand noversion = ref false (* -no-version *)\nand noprompt = ref false (* -noprompt *)\nand nopromptcont = ref false (* -nopromptcont *)\nand init_file = ref (None : string option) (* -init *)\nand noinit = ref false (* -noinit *)\nand open_modules = ref [] (* -open *)\nand use_prims = ref \"\" (* -use-prims ... *)\nand use_runtime = ref \"\" (* -use-runtime ... *)\nand plugin = ref false (* -plugin ... *)\nand principal = ref false (* -principal *)\nand real_paths = ref true (* -short-paths *)\nand recursive_types = ref false (* -rectypes *)\nand strict_sequence = ref false (* -strict-sequence *)\nand strict_formats = ref false (* -strict-formats *)\nand applicative_functors = ref true (* -no-app-funct *)\nand make_runtime = ref false (* -make-runtime *)\nand c_compiler = ref (None: string option) (* -cc *)\nand no_auto_link = ref false (* -noautolink *)\nand dllpaths = ref ([] : string list) (* -dllpath *)\nand make_package = ref false (* -pack *)\nand for_package = ref (None: string option) (* -for-pack *)\nand error_size = ref 500 (* -error-size *)\nand float_const_prop = ref true (* -no-float-const-prop *)\nand transparent_modules = ref false (* -trans-mod *)\nlet unique_ids = ref true (* -d(no-)unique-ds *)\nlet locations = ref true (* -d(no-)locations *)\nlet dump_source = ref false (* -dsource *)\nlet dump_parsetree = ref false (* -dparsetree *)\nand dump_typedtree = ref false (* -dtypedtree *)\nand dump_shape = ref false (* -dshape *)\nand dump_rawlambda = ref false (* -drawlambda *)\nand dump_lambda = ref false (* -dlambda *)\nand dump_rawclambda = ref false (* -drawclambda *)\nand dump_clambda = ref false (* -dclambda *)\nand dump_rawflambda = ref false (* -drawflambda *)\nand dump_flambda = ref false (* -dflambda *)\nand dump_flambda_let = ref (None : int option) (* -dflambda-let=... *)\nand dump_flambda_verbose = ref false (* -dflambda-verbose *)\nand dump_instr = ref false (* -dinstr *)\nand keep_camlprimc_file = ref false (* -dcamlprimc *)\n\nlet keep_asm_file = ref false (* -S *)\nlet optimize_for_speed = ref true (* -compact *)\nand opaque = ref false (* -opaque *)\n\nand dump_cmm = ref false (* -dcmm *)\nlet dump_selection = ref false (* -dsel *)\nlet dump_cse = ref false (* -dcse *)\nlet dump_live = ref false (* -dlive *)\nlet dump_spill = ref false (* -dspill *)\nlet dump_split = ref false (* -dsplit *)\nlet dump_interf = ref false (* -dinterf *)\nlet dump_prefer = ref false (* -dprefer *)\nlet dump_regalloc = ref false (* -dalloc *)\nlet dump_reload = ref false (* -dreload *)\nlet dump_scheduling = ref false (* -dscheduling *)\nlet dump_linear = ref false (* -dlinear *)\nlet dump_interval = ref false (* -dinterval *)\nlet keep_startup_file = ref false (* -dstartup *)\nlet dump_combine = ref false (* -dcombine *)\nlet profile_columns : Profile.column list ref = ref [] (* -dprofile/-dtimings *)\n\nlet native_code = ref false (* set to true under ocamlopt *)\n\nlet force_tmc = ref false (* -force-tmc *)\nlet force_slash = ref false (* for ocamldep *)\nlet clambda_checks = ref false (* -clambda-checks *)\nlet cmm_invariants =\n ref Config.with_cmm_invariants (* -dcmm-invariants *)\n\nlet flambda_invariant_checks =\n ref Config.with_flambda_invariants (* -flambda-(no-)invariants *)\n\nlet dont_write_files = ref false (* set to true under ocamldoc *)\n\nlet insn_sched_default = true\nlet insn_sched = ref insn_sched_default (* -[no-]insn-sched *)\n\nlet std_include_flag prefix =\n if !no_std_include then \"\"\n else (prefix ^ (Filename.quote Config.standard_library))\n;;\n\nlet std_include_dir () =\n if !no_std_include then [] else [Config.standard_library]\n;;\n\nlet shared = ref false (* -shared *)\nlet dlcode = ref true (* not -nodynlink *)\n\nlet pic_code = ref (match Config.architecture with (* -fPIC *)\n | \"amd64\" -> true\n | _ -> false)\n\nlet runtime_variant = ref \"\";; (* -runtime-variant *)\nlet with_runtime = ref true;; (* -with-runtime *)\n\nlet keep_docs = ref false (* -keep-docs *)\nlet keep_locs = ref true (* -keep-locs *)\nlet unsafe_string =\n if Config.safe_string then ref false\n else ref (not Config.default_safe_string)\n (* -safe-string / -unsafe-string *)\n\nlet classic_inlining = ref false (* -Oclassic *)\nlet inlining_report = ref false (* -inlining-report *)\n\nlet afl_instrument = ref Config.afl_instrument (* -afl-instrument *)\nlet afl_inst_ratio = ref 100 (* -afl-inst-ratio *)\n\nlet function_sections = ref false (* -function-sections *)\n\nlet simplify_rounds = ref None (* -rounds *)\nlet default_simplify_rounds = ref 1 (* -rounds *)\nlet rounds () =\n match !simplify_rounds with\n | None -> !default_simplify_rounds\n | Some r -> r\n\nlet default_inline_threshold = if Config.flambda then 10. else 10. /. 8.\nlet inline_toplevel_multiplier = 16\nlet default_inline_toplevel_threshold =\n int_of_float ((float inline_toplevel_multiplier) *. default_inline_threshold)\nlet default_inline_call_cost = 5\nlet default_inline_alloc_cost = 7\nlet default_inline_prim_cost = 3\nlet default_inline_branch_cost = 5\nlet default_inline_indirect_cost = 4\nlet default_inline_branch_factor = 0.1\nlet default_inline_lifting_benefit = 1300\nlet default_inline_max_unroll = 0\nlet default_inline_max_depth = 1\n\nlet inline_threshold = ref (Float_arg_helper.default default_inline_threshold)\nlet inline_toplevel_threshold =\n ref (Int_arg_helper.default default_inline_toplevel_threshold)\nlet inline_call_cost = ref (Int_arg_helper.default default_inline_call_cost)\nlet inline_alloc_cost = ref (Int_arg_helper.default default_inline_alloc_cost)\nlet inline_prim_cost = ref (Int_arg_helper.default default_inline_prim_cost)\nlet inline_branch_cost =\n ref (Int_arg_helper.default default_inline_branch_cost)\nlet inline_indirect_cost =\n ref (Int_arg_helper.default default_inline_indirect_cost)\nlet inline_branch_factor =\n ref (Float_arg_helper.default default_inline_branch_factor)\nlet inline_lifting_benefit =\n ref (Int_arg_helper.default default_inline_lifting_benefit)\nlet inline_max_unroll =\n ref (Int_arg_helper.default default_inline_max_unroll)\nlet inline_max_depth =\n ref (Int_arg_helper.default default_inline_max_depth)\n\n\nlet unbox_specialised_args = ref true (* -no-unbox-specialised-args *)\nlet unbox_free_vars_of_closures = ref true\nlet unbox_closures = ref false (* -unbox-closures *)\nlet default_unbox_closures_factor = 10\nlet unbox_closures_factor =\n ref default_unbox_closures_factor (* -unbox-closures-factor *)\nlet remove_unused_arguments = ref false (* -remove-unused-arguments *)\n\ntype inlining_arguments = {\n inline_call_cost : int option;\n inline_alloc_cost : int option;\n inline_prim_cost : int option;\n inline_branch_cost : int option;\n inline_indirect_cost : int option;\n inline_lifting_benefit : int option;\n inline_branch_factor : float option;\n inline_max_depth : int option;\n inline_max_unroll : int option;\n inline_threshold : float option;\n inline_toplevel_threshold : int option;\n}\n\nlet set_int_arg round (arg:Int_arg_helper.parsed ref) default value =\n let value : int =\n match value with\n | None -> default\n | Some value -> value\n in\n match round with\n | None ->\n arg := Int_arg_helper.set_base_default value\n (Int_arg_helper.reset_base_overrides !arg)\n | Some round ->\n arg := Int_arg_helper.add_base_override round value !arg\n\nlet set_float_arg round (arg:Float_arg_helper.parsed ref) default value =\n let value =\n match value with\n | None -> default\n | Some value -> value\n in\n match round with\n | None ->\n arg := Float_arg_helper.set_base_default value\n (Float_arg_helper.reset_base_overrides !arg)\n | Some round ->\n arg := Float_arg_helper.add_base_override round value !arg\n\nlet use_inlining_arguments_set ?round (arg:inlining_arguments) =\n let set_int = set_int_arg round in\n let set_float = set_float_arg round in\n set_int inline_call_cost default_inline_call_cost arg.inline_call_cost;\n set_int inline_alloc_cost default_inline_alloc_cost arg.inline_alloc_cost;\n set_int inline_prim_cost default_inline_prim_cost arg.inline_prim_cost;\n set_int inline_branch_cost\n default_inline_branch_cost arg.inline_branch_cost;\n set_int inline_indirect_cost\n default_inline_indirect_cost arg.inline_indirect_cost;\n set_int inline_lifting_benefit\n default_inline_lifting_benefit arg.inline_lifting_benefit;\n set_float inline_branch_factor\n default_inline_branch_factor arg.inline_branch_factor;\n set_int inline_max_depth\n default_inline_max_depth arg.inline_max_depth;\n set_int inline_max_unroll\n default_inline_max_unroll arg.inline_max_unroll;\n set_float inline_threshold\n default_inline_threshold arg.inline_threshold;\n set_int inline_toplevel_threshold\n default_inline_toplevel_threshold arg.inline_toplevel_threshold\n\n(* o1 is the default *)\nlet o1_arguments = {\n inline_call_cost = None;\n inline_alloc_cost = None;\n inline_prim_cost = None;\n inline_branch_cost = None;\n inline_indirect_cost = None;\n inline_lifting_benefit = None;\n inline_branch_factor = None;\n inline_max_depth = None;\n inline_max_unroll = None;\n inline_threshold = None;\n inline_toplevel_threshold = None;\n}\n\nlet classic_arguments = {\n inline_call_cost = None;\n inline_alloc_cost = None;\n inline_prim_cost = None;\n inline_branch_cost = None;\n inline_indirect_cost = None;\n inline_lifting_benefit = None;\n inline_branch_factor = None;\n inline_max_depth = None;\n inline_max_unroll = None;\n (* [inline_threshold] matches the current compiler's default.\n Note that this particular fraction can be expressed exactly in\n floating point. *)\n inline_threshold = Some (10. /. 8.);\n (* [inline_toplevel_threshold] is not used in classic mode. *)\n inline_toplevel_threshold = Some 1;\n}\n\nlet o2_arguments = {\n inline_call_cost = Some (2 * default_inline_call_cost);\n inline_alloc_cost = Some (2 * default_inline_alloc_cost);\n inline_prim_cost = Some (2 * default_inline_prim_cost);\n inline_branch_cost = Some (2 * default_inline_branch_cost);\n inline_indirect_cost = Some (2 * default_inline_indirect_cost);\n inline_lifting_benefit = None;\n inline_branch_factor = None;\n inline_max_depth = Some 2;\n inline_max_unroll = None;\n inline_threshold = Some 25.;\n inline_toplevel_threshold = Some (25 * inline_toplevel_multiplier);\n}\n\nlet o3_arguments = {\n inline_call_cost = Some (3 * default_inline_call_cost);\n inline_alloc_cost = Some (3 * default_inline_alloc_cost);\n inline_prim_cost = Some (3 * default_inline_prim_cost);\n inline_branch_cost = Some (3 * default_inline_branch_cost);\n inline_indirect_cost = Some (3 * default_inline_indirect_cost);\n inline_lifting_benefit = None;\n inline_branch_factor = Some 0.;\n inline_max_depth = Some 3;\n inline_max_unroll = Some 1;\n inline_threshold = Some 50.;\n inline_toplevel_threshold = Some (50 * inline_toplevel_multiplier);\n}\n\nlet all_passes = ref []\nlet dumped_passes_list = ref []\nlet dumped_pass s =\n assert(List.mem s !all_passes);\n List.mem s !dumped_passes_list\n\nlet set_dumped_pass s enabled =\n if (List.mem s !all_passes) then begin\n let passes_without_s = List.filter ((<>) s) !dumped_passes_list in\n let dumped_passes =\n if enabled then\n s :: passes_without_s\n else\n passes_without_s\n in\n dumped_passes_list := dumped_passes\n end\n\nlet dump_into_file = ref false (* -dump-into-file *)\nlet dump_dir: string option ref = ref None (* -dump-dir *)\n\ntype 'a env_reader = {\n parse : string -> 'a option;\n print : 'a -> string;\n usage : string;\n env_var : string;\n}\n\nlet color = ref None (* -color *)\n\nlet color_reader = {\n parse = (function\n | \"auto\" -> Some Misc.Color.Auto\n | \"always\" -> Some Misc.Color.Always\n | \"never\" -> Some Misc.Color.Never\n | _ -> None);\n print = (function\n | Misc.Color.Auto -> \"auto\"\n | Misc.Color.Always -> \"always\"\n | Misc.Color.Never -> \"never\");\n usage = \"expected \\\"auto\\\", \\\"always\\\" or \\\"never\\\"\";\n env_var = \"OCAML_COLOR\";\n}\n\nlet error_style = ref None (* -error-style *)\n\nlet error_style_reader = {\n parse = (function\n | \"contextual\" -> Some Misc.Error_style.Contextual\n | \"short\" -> Some Misc.Error_style.Short\n | _ -> None);\n print = (function\n | Misc.Error_style.Contextual -> \"contextual\"\n | Misc.Error_style.Short -> \"short\");\n usage = \"expected \\\"contextual\\\" or \\\"short\\\"\";\n env_var = \"OCAML_ERROR_STYLE\";\n}\n\nlet unboxed_types = ref false\n\n(* This is used by the -save-ir-after option. *)\nmodule Compiler_ir = struct\n type t = Linear\n\n let all = [\n Linear;\n ]\n\n let extension t =\n let ext =\n match t with\n | Linear -> \"linear\"\n in\n \".cmir-\" ^ ext\n\n (** [extract_extension_with_pass filename] returns the IR whose extension\n is a prefix of the extension of [filename], and the suffix,\n which can be used to distinguish different passes on the same IR.\n For example, [extract_extension_with_pass \"foo.cmir-linear123\"]\n returns [Some (Linear, \"123\")]. *)\n let extract_extension_with_pass filename =\n let ext = Filename.extension filename in\n let ext_len = String.length ext in\n if ext_len <= 0 then None\n else begin\n let is_prefix ir =\n let s = extension ir in\n let s_len = String.length s in\n s_len <= ext_len && s = String.sub ext 0 s_len\n in\n let drop_prefix ir =\n let s = extension ir in\n let s_len = String.length s in\n String.sub ext s_len (ext_len - s_len)\n in\n let ir = List.find_opt is_prefix all in\n match ir with\n | None -> None\n | Some ir -> Some (ir, drop_prefix ir)\n end\nend\n\n(* This is used by the -stop-after option. *)\nmodule Compiler_pass = struct\n (* If you add a new pass, the following must be updated:\n - the variable `passes` below\n - the manpages in man/ocaml{c,opt}.m\n - the manual manual/src/cmds/unified-options.etex\n *)\n type t = Parsing | Typing | Scheduling | Emit\n\n let to_string = function\n | Parsing -> \"parsing\"\n | Typing -> \"typing\"\n | Scheduling -> \"scheduling\"\n | Emit -> \"emit\"\n\n let of_string = function\n | \"parsing\" -> Some Parsing\n | \"typing\" -> Some Typing\n | \"scheduling\" -> Some Scheduling\n | \"emit\" -> Some Emit\n | _ -> None\n\n let rank = function\n | Parsing -> 0\n | Typing -> 1\n | Scheduling -> 50\n | Emit -> 60\n\n let passes = [\n Parsing;\n Typing;\n Scheduling;\n Emit;\n ]\n let is_compilation_pass _ = true\n let is_native_only = function\n | Scheduling -> true\n | Emit -> true\n | _ -> false\n\n let enabled is_native t = not (is_native_only t) || is_native\n let can_save_ir_after = function\n | Scheduling -> true\n | _ -> false\n\n let available_pass_names ~filter ~native =\n passes\n |> List.filter (enabled native)\n |> List.filter filter\n |> List.map to_string\n\n let compare a b =\n compare (rank a) (rank b)\n\n let to_output_filename t ~prefix =\n match t with\n | Scheduling -> prefix ^ Compiler_ir.(extension Linear)\n | _ -> Misc.fatal_error \"Not supported\"\n\n let of_input_filename name =\n match Compiler_ir.extract_extension_with_pass name with\n | Some (Linear, _) -> Some Emit\n | None -> None\nend\n\nlet stop_after = ref None (* -stop-after *)\n\nlet should_stop_after pass =\n if Compiler_pass.(rank Typing <= rank pass) && !print_types then true\n else\n match !stop_after with\n | None -> false\n | Some stop -> Compiler_pass.rank stop <= Compiler_pass.rank pass\n\nlet save_ir_after = ref []\n\nlet should_save_ir_after pass =\n List.mem pass !save_ir_after\n\nlet set_save_ir_after pass enabled =\n let other_passes = List.filter ((<>) pass) !save_ir_after in\n let new_passes =\n if enabled then\n pass :: other_passes\n else\n other_passes\n in\n save_ir_after := new_passes\n\nmodule String = Misc.Stdlib.String\n\nlet arg_spec = ref []\nlet arg_names = ref String.Map.empty\n\nlet reset_arguments () =\n arg_spec := [];\n arg_names := String.Map.empty\n\nlet add_arguments loc args =\n List.iter (function (arg_name, _, _) as arg ->\n try\n let loc2 = String.Map.find arg_name !arg_names in\n Printf.eprintf\n \"Warning: compiler argument %s is already defined:\\n\" arg_name;\n Printf.eprintf \" First definition: %s\\n\" loc2;\n Printf.eprintf \" New definition: %s\\n\" loc;\n with Not_found ->\n arg_spec := !arg_spec @ [ arg ];\n arg_names := String.Map.add arg_name loc !arg_names\n ) args\n\nlet create_usage_msg program =\n Printf.sprintf \"Usage: %s \\n\\\n Try '%s --help' for more information.\" program program\n\n\nlet print_arguments program =\n Arg.usage !arg_spec (create_usage_msg program)\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Florian Angeletti, projet Cambium, Inria Paris *)\n(* *)\n(* Copyright 2021 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\nmodule Context = struct\n type pos =\n | Module of Ident.t\n | Modtype of Ident.t\n | Arg of Types.functor_parameter\n | Body of Types.functor_parameter\n\n let path_of_context = function\n Module id :: rem ->\n let rec subm path = function\n | [] -> path\n | Module id :: rem -> subm (Path.Pdot (path, Ident.name id)) rem\n | _ -> assert false\n in subm (Path.Pident id) rem\n | _ -> assert false\n\n\n let rec context ppf = function\n Module id :: rem ->\n Format.fprintf ppf \"@[<2>module %a%a@]\" Printtyp.ident id args rem\n | Modtype id :: rem ->\n Format.fprintf ppf \"@[<2>module type %a =@ %a@]\"\n Printtyp.ident id context_mty rem\n | Body x :: rem ->\n Format.fprintf ppf \"functor (%s) ->@ %a\" (argname x) context_mty rem\n | Arg x :: rem ->\n Format.fprintf ppf \"functor (%s : %a) -> ...\"\n (argname x) context_mty rem\n | [] ->\n Format.fprintf ppf \"\"\n and context_mty ppf = function\n (Module _ | Modtype _) :: _ as rem ->\n Format.fprintf ppf \"@[<2>sig@ %a@;<1 -2>end@]\" context rem\n | cxt -> context ppf cxt\n and args ppf = function\n Body x :: rem ->\n Format.fprintf ppf \"(%s)%a\" (argname x) args rem\n | Arg x :: rem ->\n Format.fprintf ppf \"(%s :@ %a) : ...\" (argname x) context_mty rem\n | cxt ->\n Format.fprintf ppf \" :@ %a\" context_mty cxt\n and argname = function\n | Types.Unit -> \"\"\n | Types.Named (None, _) -> \"_\"\n | Types.Named (Some id, _) -> Ident.name id\n\n let alt_pp ppf cxt =\n if cxt = [] then () else\n if List.for_all (function Module _ -> true | _ -> false) cxt then\n Format.fprintf ppf \"in module %a,\" Printtyp.path (path_of_context cxt)\n else\n Format.fprintf ppf \"@[at position@ %a,@]\" context cxt\n\n let pp ppf cxt =\n if cxt = [] then () else\n if List.for_all (function Module _ -> true | _ -> false) cxt then\n Format.fprintf ppf \"In module %a:@ \" Printtyp.path (path_of_context cxt)\n else\n Format.fprintf ppf \"@[At position@ %a@]@ \" context cxt\nend\n\nmodule Illegal_permutation = struct\n (** Extraction of information in case of illegal permutation\n in a module type *)\n\n (** When examining coercions, we only have runtime component indices,\n we use thus a limited version of {!pos}. *)\n type coerce_pos =\n | Item of int\n | InArg\n | InBody\n\n let either f x g y = match f x with\n | None -> g y\n | Some _ as v -> v\n\n (** We extract a lone transposition from a full tree of permutations. *)\n let rec transposition_under path (coerc:Typedtree.module_coercion) =\n match coerc with\n | Tcoerce_structure(c,_) ->\n either\n (not_fixpoint path 0) c\n (first_non_id path 0) c\n | Tcoerce_functor(arg,res) ->\n either\n (transposition_under (InArg::path)) arg\n (transposition_under (InBody::path)) res\n | Tcoerce_none -> None\n | Tcoerce_alias _ | Tcoerce_primitive _ ->\n (* these coercions are not inversible, and raise an error earlier when\n checking for module type equivalence *)\n assert false\n (* we search the first point which is not invariant at the current level *)\n and not_fixpoint path pos = function\n | [] -> None\n | (n, _) :: q ->\n if n = pos then\n not_fixpoint path (pos+1) q\n else\n Some(List.rev path, pos, n)\n (* we search the first item with a non-identity inner coercion *)\n and first_non_id path pos = function\n | [] -> None\n | (_, Typedtree.Tcoerce_none) :: q -> first_non_id path (pos + 1) q\n | (_,c) :: q ->\n either\n (transposition_under (Item pos :: path)) c\n (first_non_id path (pos + 1)) q\n\n let transposition c =\n match transposition_under [] c with\n | None -> raise Not_found\n | Some x -> x\n\n let rec runtime_item k = function\n | [] -> raise Not_found\n | item :: q ->\n if not(Includemod.is_runtime_component item) then\n runtime_item k q\n else if k = 0 then\n item\n else\n runtime_item (k-1) q\n\n (* Find module type at position [path] and convert the [coerce_pos] path to\n a [pos] path *)\n let rec find env ctx path (mt:Types.module_type) = match mt, path with\n | (Mty_ident p | Mty_alias p), _ ->\n begin match (Env.find_modtype p env).mtd_type with\n | None -> raise Not_found\n | Some mt -> find env ctx path mt\n end\n | Mty_signature s , [] -> List.rev ctx, s\n | Mty_signature s, Item k :: q ->\n begin match runtime_item k s with\n | Sig_module (id, _, md,_,_) ->\n find env (Context.Module id :: ctx) q md.md_type\n | _ -> raise Not_found\n end\n | Mty_functor(Named (_,mt) as arg,_), InArg :: q ->\n find env (Context.Arg arg :: ctx) q mt\n | Mty_functor(arg, mt), InBody :: q ->\n find env (Context.Body arg :: ctx) q mt\n | _ -> raise Not_found\n\n let find env path mt = find env [] path mt\n let item mt k = Includemod.item_ident_name (runtime_item k mt)\n\n let pp_item ppf (id,_,kind) =\n Format.fprintf ppf \"%s %S\"\n (Includemod.kind_of_field_desc kind)\n (Ident.name id)\n\n let pp ctx_printer env ppf (mty,c) =\n try\n let p, k, l = transposition c in\n let ctx, mt = find env p mty in\n Format.fprintf ppf\n \"@[Illegal permutation of runtime components in a module type.@ \\\n @[For example,@ %a@]@ @[the %a@ and the %a are not in the same order@ \\\n in the expected and actual module types.@]@]\"\n ctx_printer ctx pp_item (item mt k) pp_item (item mt l)\n with Not_found -> (* this should not happen *)\n Format.fprintf ppf\n \"Illegal permutation of runtime components in a module type.\"\n\nend\n\n\n\nmodule Err = Includemod.Error\n\nlet buffer = ref Bytes.empty\nlet is_big obj =\n let size = !Clflags.error_size in\n size > 0 &&\n begin\n if Bytes.length !buffer < size then buffer := Bytes.create size;\n try ignore (Marshal.to_buffer !buffer 0 size obj []); false\n with _ -> true\n end\n\nlet show_loc msg ppf loc =\n let pos = loc.Location.loc_start in\n if List.mem pos.Lexing.pos_fname [\"\"; \"_none_\"; \"//toplevel//\"] then ()\n else Format.fprintf ppf \"@\\n@[<2>%a:@ %s@]\" Location.print_loc loc msg\n\nlet show_locs ppf (loc1, loc2) =\n show_loc \"Expected declaration\" ppf loc2;\n show_loc \"Actual declaration\" ppf loc1\n\n\nlet dmodtype mty =\n let tmty = Printtyp.tree_of_modtype mty in\n Format.dprintf \"%a\" !Oprint.out_module_type tmty\n\nlet space ppf () = Format.fprintf ppf \"@ \"\n\n(**\n In order to display a list of functor arguments in a compact format,\n we introduce a notion of shorthand for functor arguments.\n The aim is to first present the lists of actual and expected types with\n shorthands:\n\n (X: $S1) (Y: $S2) (Z: An_existing_module_type) ...\n does not match\n (X: $T1) (Y: A_real_path) (Z: $T3) ...\n\n and delay the full display of the module types corresponding to $S1, $S2,\n $T1, and $T3 to the suberror message.\n\n*)\nmodule With_shorthand = struct\n\n (** A item with a potential shorthand name *)\n type 'a named = {\n item: 'a;\n name : string;\n }\n\n type 'a t =\n | Original of 'a (** The shorthand has been discarded *)\n | Synthetic of 'a named\n (** The shorthand is potentially useful *)\n\n type functor_param =\n | Unit\n | Named of (Ident.t option * Types.module_type t)\n\n (** Shorthand generation *)\n type kind =\n | Got\n | Expected\n | Unneeded\n\n type variant =\n | App\n | Inclusion\n\n let elide_if_app ctx s = match ctx with\n | App -> Unneeded\n | Inclusion -> s\n\n let make side pos =\n match side with\n | Got -> Format.sprintf \"$S%d\" pos\n | Expected -> Format.sprintf \"$T%d\" pos\n | Unneeded -> \"...\"\n\n (** Add shorthands to a patch *)\n open Diffing\n let patch ctx p =\n let add_shorthand side pos mty =\n {name = (make side pos); item = mty }\n in\n let aux i d =\n let pos = i + 1 in\n let d = match d with\n | Insert mty ->\n Insert (add_shorthand Expected pos mty)\n | Delete mty ->\n Delete (add_shorthand (elide_if_app ctx Got) pos mty)\n | Change (g, e, p) ->\n Change\n (add_shorthand Got pos g,\n add_shorthand Expected pos e, p)\n | Keep (g, e, p) ->\n Keep (add_shorthand Got pos g,\n add_shorthand (elide_if_app ctx Expected) pos e, p)\n in\n pos, d\n in\n List.mapi aux p\n\n (** Shorthand computation from named item *)\n let modtype (r : _ named) = match r.item with\n | Types.Mty_ident _\n | Types.Mty_alias _\n | Types.Mty_signature []\n -> Original r.item\n | Types.Mty_signature _ | Types.Mty_functor _\n -> Synthetic r\n\n let functor_param (ua : _ named) = match ua.item with\n | Types.Unit -> Unit\n | Types.Named (from, mty) ->\n Named (from, modtype { ua with item = mty })\n\n (** Printing of arguments with shorthands *)\n let pp ppx = function\n | Original x -> ppx x\n | Synthetic s -> Format.dprintf \"%s\" s.name\n\n let pp_orig ppx = function\n | Original x | Synthetic { item=x; _ } -> ppx x\n\n let definition x = match functor_param x with\n | Unit -> Format.dprintf \"()\"\n | Named(_,short_mty) ->\n match short_mty with\n | Original mty -> dmodtype mty\n | Synthetic {name; item = mty} ->\n Format.dprintf\n \"%s@ =@ %t\" name (dmodtype mty)\n\n let param x = match functor_param x with\n | Unit -> Format.dprintf \"()\"\n | Named (_, short_mty) ->\n pp dmodtype short_mty\n\n let qualified_param x = match functor_param x with\n | Unit -> Format.dprintf \"()\"\n | Named (None, Original (Mty_signature []) ) ->\n Format.dprintf \"(sig end)\"\n | Named (None, short_mty) ->\n pp dmodtype short_mty\n | Named (Some p, short_mty) ->\n Format.dprintf \"(%s : %t)\"\n (Ident.name p) (pp dmodtype short_mty)\n\n let definition_of_argument ua =\n let arg, mty = ua.item in\n match (arg: Err.functor_arg_descr) with\n | Unit -> Format.dprintf \"()\"\n | Named p ->\n let mty = modtype { ua with item = mty } in\n Format.dprintf\n \"%a@ :@ %t\"\n Printtyp.path p\n (pp_orig dmodtype mty)\n | Anonymous ->\n let short_mty = modtype { ua with item = mty } in\n begin match short_mty with\n | Original mty -> dmodtype mty\n | Synthetic {name; item=mty} ->\n Format.dprintf \"%s@ :@ %t\" name (dmodtype mty)\n end\n\n let arg ua =\n let arg, mty = ua.item in\n match (arg: Err.functor_arg_descr) with\n | Unit -> Format.dprintf \"()\"\n | Named p -> fun ppf -> Printtyp.path ppf p\n | Anonymous ->\n let short_mty = modtype { ua with item=mty } in\n pp dmodtype short_mty\n\nend\n\n\nmodule Functor_suberror = struct\n open Err\n\n let param_id x = match x.With_shorthand.item with\n | Types.Named (Some _ as x,_) -> x\n | Types.(Unit | Named(None,_)) -> None\n\n (** Print the list of params with style *)\n let pretty_params sep proj printer patch =\n let elt (x,param) =\n let sty = Diffing.(style @@ classify x) in\n Format.dprintf \"%a%t%a\"\n Format.pp_open_stag (Misc.Color.Style sty)\n (printer param)\n Format.pp_close_stag ()\n in\n let params = List.filter_map proj @@ List.map snd patch in\n Printtyp.functor_parameters ~sep elt params\n\n let expected d =\n let extract: _ Diffing.change -> _ = function\n | Insert mty\n | Keep(_,mty,_)\n | Change (_,mty,_) as x ->\n Some (param_id mty,(x, mty))\n | Delete _ -> None\n in\n pretty_params space extract With_shorthand.qualified_param d\n\n let drop_inserted_suffix patch =\n let rec drop = function\n | Diffing.Insert _ :: q -> drop q\n | rest -> List.rev rest in\n drop (List.rev patch)\n\n let prepare_patch ~drop ~ctx patch =\n let drop_suffix x = if drop then drop_inserted_suffix x else x in\n patch |> drop_suffix |> With_shorthand.patch ctx\n\n\n module Inclusion = struct\n\n let got d =\n let extract: _ Diffing.change -> _ = function\n | Delete mty\n | Keep (mty,_,_)\n | Change (mty,_,_) as x ->\n Some (param_id mty,(x,mty))\n | Insert _ -> None\n in\n pretty_params space extract With_shorthand.qualified_param d\n\n let insert mty =\n Format.dprintf\n \"An argument appears to be missing with module type@;<1 2>@[%t@]\"\n (With_shorthand.definition mty)\n\n let delete mty =\n Format.dprintf\n \"An extra argument is provided of module type@;<1 2>@[%t@]\"\n (With_shorthand.definition mty)\n\n let ok x y =\n Format.dprintf\n \"Module types %t and %t match\"\n (With_shorthand.param x)\n (With_shorthand.param y)\n\n let diff g e more =\n let g = With_shorthand.definition g in\n let e = With_shorthand.definition e in\n Format.dprintf\n \"Module types do not match:@ @[%t@]@;<1 -2>does not include@ \\\n @[%t@]%t\"\n g e (more ())\n\n let incompatible = function\n | Types.Unit ->\n Format.dprintf\n \"The functor was expected to be applicative at this position\"\n | Types.Named _ ->\n Format.dprintf\n \"The functor was expected to be generative at this position\"\n\n let patch env got expected =\n Includemod.Functor_inclusion_diff.diff env got expected\n |> prepare_patch ~drop:false ~ctx:Inclusion\n\n end\n\n module App = struct\n\n let patch env ~f ~args =\n Includemod.Functor_app_diff.diff env ~f ~args\n |> prepare_patch ~drop:true ~ctx:App\n\n let got d =\n let extract: _ Diffing.change -> _ = function\n | Delete mty\n | Keep (mty,_,_)\n | Change (mty,_,_) as x ->\n Some (None,(x,mty))\n | Insert _ -> None\n in\n pretty_params space extract With_shorthand.arg d\n\n let delete mty =\n Format.dprintf\n \"The following extra argument is provided@;<1 2>@[%t@]\"\n (With_shorthand.definition_of_argument mty)\n\n let insert = Inclusion.insert\n\n let ok x y =\n let pp_orig_name = match With_shorthand.functor_param y with\n | With_shorthand.Named (_, Original mty) ->\n Format.dprintf \" %t\" (dmodtype mty)\n | _ -> ignore\n in\n Format.dprintf\n \"Module %t matches the expected module type%t\"\n (With_shorthand.arg x)\n pp_orig_name\n\n let diff g e more =\n let g = With_shorthand.definition_of_argument g in\n let e = With_shorthand.definition e in\n Format.dprintf\n \"Modules do not match:@ @[%t@]@;<1 -2>\\\n is not included in@ @[%t@]%t\"\n g e (more ())\n\n (** Specialized to avoid introducing shorthand names\n for single change difference\n *)\n let single_diff g e more =\n let _arg, mty = g.With_shorthand.item in\n let e = match e.With_shorthand.item with\n | Types.Unit -> Format.dprintf \"()\"\n | Types.Named(_, mty) -> dmodtype mty\n in\n Format.dprintf\n \"Modules do not match:@ @[%t@]@;<1 -2>\\\n is not included in@ @[%t@]%t\"\n (dmodtype mty) e (more ())\n\n\n let incompatible = function\n | Unit ->\n Format.dprintf\n \"The functor was expected to be applicative at this position\"\n | Named _ | Anonymous ->\n Format.dprintf\n \"The functor was expected to be generative at this position\"\n\n end\n\n let subcase sub ~expansion_token env (pos, diff) =\n Location.msg \"%a%a%a%a@[%t@]%a\"\n Format.pp_print_tab ()\n Format.pp_open_tbox ()\n Diffing.prefix (pos, Diffing.classify diff)\n Format.pp_set_tab ()\n (Printtyp.wrap_printing_env env ~error:true\n (fun () -> sub ~expansion_token env diff)\n )\n Format.pp_close_tbox ()\n\n let onlycase sub ~expansion_token env (_, diff) =\n Location.msg \"%a@[%t@]\"\n Format.pp_print_tab ()\n (Printtyp.wrap_printing_env env ~error:true\n (fun () -> sub ~expansion_token env diff)\n )\n\n let params sub ~expansion_token env l =\n let rec aux subcases = function\n | [] -> subcases\n | (_, Diffing.Keep _) as a :: q ->\n aux (subcase sub ~expansion_token env a :: subcases) q\n | a :: q ->\n List.fold_left (fun acc x ->\n (subcase sub ~expansion_token:false env x) :: acc\n )\n (subcase sub ~expansion_token env a :: subcases)\n q\n in\n match l with\n | [a] -> [onlycase sub ~expansion_token env a]\n | l -> aux [] l\nend\n\n\n(** Construct a linear presentation of the error tree *)\n\nopen Err\n\n(* Context helper functions *)\nlet with_context ?loc ctx printer diff =\n Location.msg ?loc \"%a%a\" Context.pp (List.rev ctx)\n printer diff\n\nlet dwith_context ?loc ctx printer =\n Location.msg ?loc \"%a%t\" Context.pp (List.rev ctx) printer\n\nlet dwith_context_and_elision ?loc ctx printer diff =\n if is_big (diff.got,diff.expected) then\n Location.msg ?loc \"...\"\n else\n dwith_context ?loc ctx (printer diff)\n\n(* Merge sub msgs into one printer *)\nlet coalesce msgs =\n match List.rev msgs with\n | [] -> ignore\n | before ->\n let ctx ppf =\n Format.pp_print_list ~pp_sep:space\n (fun ppf x -> x.Location.txt ppf)\n ppf before in\n ctx\n\nlet subcase_list l ppf = match l with\n | [] -> ()\n | _ :: _ ->\n Format.fprintf ppf \"@;<1 -2>@[%a@]\"\n (Format.pp_print_list ~pp_sep:space\n (fun ppf f -> f.Location.txt ppf)\n )\n (List.rev l)\n\n(* Printers for leaves *)\nlet core env id x =\n match x with\n | Err.Value_descriptions diff ->\n Format.dprintf \"@[@[%s:@;<1 2>%a@ %s@;<1 2>%a@]%a%a%t@]\"\n \"Values do not match\"\n !Oprint.out_sig_item\n (Printtyp.tree_of_value_description id diff.got)\n \"is not included in\"\n !Oprint.out_sig_item\n (Printtyp.tree_of_value_description id diff.expected)\n (Includecore.report_value_mismatch\n \"the first\" \"the second\" env) diff.symptom\n show_locs (diff.got.val_loc, diff.expected.val_loc)\n Printtyp.Conflicts.print_explanations\n | Err.Type_declarations diff ->\n Format.dprintf \"@[@[%s:@;<1 2>%a@ %s@;<1 2>%a@]%a%a%t@]\"\n \"Type declarations do not match\"\n !Oprint.out_sig_item\n (Printtyp.tree_of_type_declaration id diff.got Trec_first)\n \"is not included in\"\n !Oprint.out_sig_item\n (Printtyp.tree_of_type_declaration id diff.expected Trec_first)\n (Includecore.report_type_mismatch\n \"the first\" \"the second\" \"declaration\" env) diff.symptom\n show_locs (diff.got.type_loc, diff.expected.type_loc)\n Printtyp.Conflicts.print_explanations\n | Err.Extension_constructors diff ->\n Format.dprintf \"@[@[%s:@;<1 2>%a@ %s@;<1 2>%a@]@ %a%a%t@]\"\n \"Extension declarations do not match\"\n !Oprint.out_sig_item\n (Printtyp.tree_of_extension_constructor id diff.got Text_first)\n \"is not included in\"\n !Oprint.out_sig_item\n (Printtyp.tree_of_extension_constructor id diff.expected Text_first)\n (Includecore.report_extension_constructor_mismatch\n \"the first\" \"the second\" \"declaration\" env) diff.symptom\n show_locs (diff.got.ext_loc, diff.expected.ext_loc)\n Printtyp.Conflicts.print_explanations\n | Err.Class_type_declarations diff ->\n Format.dprintf\n \"@[Class type declarations do not match:@ \\\n %a@;<1 -2>does not match@ %a@]@ %a%t\"\n !Oprint.out_sig_item\n (Printtyp.tree_of_cltype_declaration id diff.got Trec_first)\n !Oprint.out_sig_item\n (Printtyp.tree_of_cltype_declaration id diff.expected Trec_first)\n (Includeclass.report_error Type_scheme) diff.symptom\n Printtyp.Conflicts.print_explanations\n | Err.Class_declarations {got;expected;symptom} ->\n let t1 = Printtyp.tree_of_class_declaration id got Trec_first in\n let t2 = Printtyp.tree_of_class_declaration id expected Trec_first in\n Format.dprintf\n \"@[Class declarations do not match:@ \\\n %a@;<1 -2>does not match@ %a@]@ %a%t\"\n !Oprint.out_sig_item t1\n !Oprint.out_sig_item t2\n (Includeclass.report_error Type_scheme) symptom\n Printtyp.Conflicts.print_explanations\n\nlet missing_field ppf item =\n let id, loc, kind = Includemod.item_ident_name item in\n Format.fprintf ppf \"The %s `%a' is required but not provided%a\"\n (Includemod.kind_of_field_desc kind) Printtyp.ident id\n (show_loc \"Expected declaration\") loc\n\nlet module_types {Err.got=mty1; expected=mty2} =\n Format.dprintf\n \"@[Modules do not match:@ \\\n %a@;<1 -2>is not included in@ %a@]\"\n !Oprint.out_module_type (Printtyp.tree_of_modtype mty1)\n !Oprint.out_module_type (Printtyp.tree_of_modtype mty2)\n\nlet eq_module_types {Err.got=mty1; expected=mty2} =\n Format.dprintf\n \"@[Module types do not match:@ \\\n %a@;<1 -2>is not equal to@ %a@]\"\n !Oprint.out_module_type (Printtyp.tree_of_modtype mty1)\n !Oprint.out_module_type (Printtyp.tree_of_modtype mty2)\n\nlet module_type_declarations id {Err.got=d1 ; expected=d2} =\n Format.dprintf\n \"@[Module type declarations do not match:@ \\\n %a@;<1 -2>does not match@ %a@]\"\n !Oprint.out_sig_item (Printtyp.tree_of_modtype_declaration id d1)\n !Oprint.out_sig_item (Printtyp.tree_of_modtype_declaration id d2)\n\nlet interface_mismatch ppf (diff: _ Err.diff) =\n Format.fprintf ppf\n \"The implementation %s@ does not match the interface %s:@ \"\n diff.got diff.expected\n\nlet core_module_type_symptom (x:Err.core_module_type_symptom) =\n match x with\n | Not_an_alias | Not_an_identifier | Abstract_module_type\n | Incompatible_aliases ->\n if Printtyp.Conflicts.exists () then\n Some Printtyp.Conflicts.print_explanations\n else None\n | Unbound_module_path path ->\n Some(Format.dprintf \"Unbound module %a\" Printtyp.path path)\n\n(* Construct a linearized error message from the error tree *)\n\nlet rec module_type ~expansion_token ~eqmode ~env ~before ~ctx diff =\n match diff.symptom with\n | Invalid_module_alias _ (* the difference is non-informative here *)\n | After_alias_expansion _ (* we print only the expanded module types *) ->\n module_type_symptom ~eqmode ~expansion_token ~env ~before ~ctx\n diff.symptom\n | Functor Params d -> (* We jump directly to the functor param error *)\n functor_params ~expansion_token ~env ~before ~ctx d\n | _ ->\n let inner = if eqmode then eq_module_types else module_types in\n let next = dwith_context_and_elision ctx inner diff in\n let before = next :: before in\n module_type_symptom ~eqmode ~expansion_token ~env ~before ~ctx\n diff.symptom\n\nand module_type_symptom ~eqmode ~expansion_token ~env ~before ~ctx = function\n | Mt_core core ->\n begin match core_module_type_symptom core with\n | None -> before\n | Some msg -> Location.msg \"%t\" msg :: before\n end\n | Signature s -> signature ~expansion_token ~env ~before ~ctx s\n | Functor f -> functor_symptom ~expansion_token ~env ~before ~ctx f\n | After_alias_expansion diff ->\n module_type ~eqmode ~expansion_token ~env ~before ~ctx diff\n | Invalid_module_alias path ->\n let printer =\n Format.dprintf \"Module %a cannot be aliased\" Printtyp.path path\n in\n dwith_context ctx printer :: before\n\nand functor_params ~expansion_token ~env ~before ~ctx {got;expected;_} =\n let d = Functor_suberror.Inclusion.patch env got expected in\n let actual = Functor_suberror.Inclusion.got d in\n let expected = Functor_suberror.expected d in\n let main =\n Format.dprintf\n \"@[Modules do not match:@ \\\n @[functor@ %t@ -> ...@]@;<1 -2>is not included in@ \\\n @[functor@ %t@ -> ...@]@]\"\n actual expected\n in\n let msgs = dwith_context ctx main :: before in\n let functor_suberrors =\n if expansion_token then\n Functor_suberror.params functor_arg_diff ~expansion_token env d\n else []\n in\n functor_suberrors @ msgs\n\nand functor_symptom ~expansion_token ~env ~before ~ctx = function\n | Result res ->\n module_type ~expansion_token ~eqmode:false ~env ~before ~ctx res\n | Params d -> functor_params ~expansion_token ~env ~before ~ctx d\n\nand signature ~expansion_token ~env:_ ~before ~ctx sgs =\n Printtyp.wrap_printing_env ~error:true sgs.env (fun () ->\n match sgs.missings, sgs.incompatibles with\n | a :: l , _ ->\n if expansion_token then\n with_context ctx missing_field a\n :: List.map (Location.msg \"%a\" missing_field) l\n @ before\n else\n before\n | [], a :: _ -> sigitem ~expansion_token ~env:sgs.env ~before ~ctx a\n | [], [] -> assert false\n )\nand sigitem ~expansion_token ~env ~before ~ctx (name,s) = match s with\n | Core c ->\n dwith_context ctx (core env name c) :: before\n | Module_type diff ->\n module_type ~expansion_token ~eqmode:false ~env ~before\n ~ctx:(Context.Module name :: ctx) diff\n | Module_type_declaration diff ->\n module_type_decl ~expansion_token ~env ~before ~ctx name diff\nand module_type_decl ~expansion_token ~env ~before ~ctx id diff =\n let next =\n dwith_context_and_elision ctx (module_type_declarations id) diff in\n let before = next :: before in\n match diff.symptom with\n | Not_less_than mts ->\n let before =\n Location.msg \"The first module type is not included in the second\"\n :: before\n in\n module_type ~expansion_token ~eqmode:true ~before ~env\n ~ctx:(Context.Modtype id :: ctx) mts\n | Not_greater_than mts ->\n let before =\n Location.msg \"The second module type is not included in the first\"\n :: before in\n module_type ~expansion_token ~eqmode:true ~before ~env\n ~ctx:(Context.Modtype id :: ctx) mts\n | Incomparable mts ->\n module_type ~expansion_token ~eqmode:true ~env ~before\n ~ctx:(Context.Modtype id :: ctx) mts.less_than\n | Illegal_permutation c ->\n begin match diff.got.Types.mtd_type with\n | None -> assert false\n | Some mty ->\n with_context (Modtype id::ctx)\n (Illegal_permutation.pp Context.alt_pp env) (mty,c)\n :: before\n end\n\nand functor_arg_diff ~expansion_token env (patch: _ Diffing.change) =\n match patch with\n | Insert mty -> Functor_suberror.Inclusion.insert mty\n | Delete mty -> Functor_suberror.Inclusion.delete mty\n | Keep (x, y, _) -> Functor_suberror.Inclusion.ok x y\n | Change (_, _, Err.Incompatible_params (i,_)) ->\n Functor_suberror.Inclusion.incompatible i\n | Change (g, e, Err.Mismatch mty_diff) ->\n let more () =\n subcase_list @@\n module_type_symptom ~eqmode:false ~expansion_token ~env ~before:[]\n ~ctx:[] mty_diff.symptom\n in\n Functor_suberror.Inclusion.diff g e more\n\nlet functor_app_diff ~expansion_token env (patch: _ Diffing.change) =\n match patch with\n | Insert mty -> Functor_suberror.App.insert mty\n | Delete mty -> Functor_suberror.App.delete mty\n | Keep (x, y, _) -> Functor_suberror.App.ok x y\n | Change (_, _, Err.Incompatible_params (i,_)) ->\n Functor_suberror.App.incompatible i\n | Change (g, e, Err.Mismatch mty_diff) ->\n let more () =\n subcase_list @@\n module_type_symptom ~eqmode:false ~expansion_token ~env ~before:[]\n ~ctx:[] mty_diff.symptom\n in\n Functor_suberror.App.diff g e more\n\nlet module_type_subst ~env id diff =\n match diff.symptom with\n | Not_less_than mts ->\n module_type ~expansion_token:true ~eqmode:true ~before:[] ~env\n ~ctx:[Modtype id] mts\n | Not_greater_than mts ->\n module_type ~expansion_token:true ~eqmode:true ~before:[] ~env\n ~ctx:[Modtype id] mts\n | Incomparable mts ->\n module_type ~expansion_token:true ~eqmode:true ~env ~before:[]\n ~ctx:[Modtype id] mts.less_than\n | Illegal_permutation c ->\n let mty = diff.got in\n let main =\n with_context [Modtype id]\n (Illegal_permutation.pp Context.alt_pp env) (mty,c) in\n [main]\n\nlet all env = function\n | In_Compilation_unit diff ->\n let first = Location.msg \"%a\" interface_mismatch diff in\n signature ~expansion_token:true ~env ~before:[first] ~ctx:[] diff.symptom\n | In_Type_declaration (id,reason) ->\n [Location.msg \"%t\" (core env id reason)]\n | In_Module_type diff ->\n module_type ~expansion_token:true ~eqmode:false ~before:[] ~env ~ctx:[]\n diff\n | In_Module_type_substitution (id,diff) ->\n module_type_subst ~env id diff\n | In_Signature diff ->\n signature ~expansion_token:true ~before:[] ~env ~ctx:[] diff\n | In_Expansion cmts ->\n match core_module_type_symptom cmts with\n | None -> assert false\n | Some main -> [Location.msg \"%t\" main]\n\n(* General error reporting *)\n\nlet err_msgs (env, err) =\n Printtyp.Conflicts.reset();\n Printtyp.wrap_printing_env ~error:true env\n (fun () -> coalesce @@ all env err)\n\nlet report_error err =\n let main = err_msgs err in\n Location.errorf ~loc:Location.(in_file !input_name) \"%t\" main\n\nlet report_apply_error ~loc env (lid_app, mty_f, args) =\n let may_print_app ppf = match lid_app with\n | None -> ()\n | Some lid -> Format.fprintf ppf \"%a \" Printtyp.longident lid\n in\n let d = Functor_suberror.App.patch env ~f:mty_f ~args in\n match d with\n (* We specialize the one change and one argument case to remove the\n presentation of the functor arguments *)\n | [ _, Change (_, _, Err.Incompatible_params (i,_)) ] ->\n Location.errorf ~loc \"%t\" (Functor_suberror.App.incompatible i)\n | [ _, Change (g, e, Err.Mismatch mty_diff) ] ->\n let more () =\n subcase_list @@\n module_type_symptom ~eqmode:false ~expansion_token:true ~env ~before:[]\n ~ctx:[] mty_diff.symptom\n in\n Location.errorf ~loc \"%t\" (Functor_suberror.App.single_diff g e more)\n | _ ->\n let actual = Functor_suberror.App.got d in\n let expected = Functor_suberror.expected d in\n let sub =\n List.rev @@\n Functor_suberror.params functor_app_diff env ~expansion_token:true d\n in\n Location.errorf ~loc ~sub\n \"@[The functor application %tis ill-typed.@ \\\n These arguments:@;<1 2>\\\n @[%t@]@ do not match these parameters:@;<1 2>@[functor@ %t@ -> ...@]@]\"\n may_print_app\n actual expected\n\nlet register () =\n Location.register_error_of_exn\n (function\n | Includemod.Error err -> Some (report_error err)\n | Includemod.Apply_error {loc; env; lid_app; mty_f; args} ->\n Some (Printtyp.wrap_printing_env env ~error:true (fun () ->\n report_apply_error ~loc env (lid_app, mty_f, args))\n )\n | _ -> None\n )\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Frederic Bour, Tarides *)\n(* Thomas Refis, Tarides *)\n(* *)\n(* Copyright 2020 Tarides *)\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 ref_and_reset =\n | Table : { ref: 'a ref; init: unit -> 'a } -> ref_and_reset\n | Ref : { ref: 'a ref; mutable snapshot: 'a } -> ref_and_reset\n\ntype bindings = {\n mutable refs: ref_and_reset list;\n mutable frozen : bool;\n mutable is_bound: bool;\n}\n\nlet global_bindings =\n { refs = []; is_bound = false; frozen = false }\n\nlet is_bound () = global_bindings.is_bound\n\nlet reset () =\n assert (is_bound ());\n List.iter (function\n | Table { ref; init } -> ref := init ()\n | Ref { ref; snapshot } -> ref := snapshot\n ) global_bindings.refs\n\nlet s_table create size =\n let init () = create size in\n let ref = ref (init ()) in\n assert (not global_bindings.frozen);\n global_bindings.refs <- (Table { ref; init }) :: global_bindings.refs;\n ref\n\nlet s_ref k =\n let ref = ref k in\n assert (not global_bindings.frozen);\n global_bindings.refs <-\n (Ref { ref; snapshot = k }) :: global_bindings.refs;\n ref\n\ntype slot = Slot : { ref : 'a ref; mutable value : 'a } -> slot\ntype store = slot list\n\nlet fresh () =\n let slots =\n List.map (function\n | Table { ref; init } -> Slot {ref; value = init ()}\n | Ref r ->\n if not global_bindings.frozen then r.snapshot <- !(r.ref);\n Slot { ref = r.ref; value = r.snapshot }\n ) global_bindings.refs\n in\n global_bindings.frozen <- true;\n slots\n\nlet with_store slots f =\n assert (not global_bindings.is_bound);\n global_bindings.is_bound <- true;\n List.iter (fun (Slot {ref;value}) -> ref := value) slots;\n Fun.protect f ~finally:(fun () ->\n List.iter (fun (Slot s) -> s.value <- !(s.ref)) slots;\n global_bindings.is_bound <- false;\n )\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Jeremie Dimino, Jane Street Europe *)\n(* *)\n(* Copyright 2018 Jane Street Group LLC *)\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 Local_store\n\nmodule STbl = Misc.Stdlib.String.Tbl\n\n(* Mapping from basenames to full filenames *)\ntype registry = string STbl.t\n\nlet files : registry ref = s_table STbl.create 42\nlet files_uncap : registry ref = s_table STbl.create 42\n\nmodule Dir = struct\n type t = {\n path : string;\n files : string list;\n }\n\n let path t = t.path\n let files t = t.files\n\n (* For backward compatibility reason, simulate the behavior of\n [Misc.find_in_path]: silently ignore directories that don't exist\n + treat [\"\"] as the current directory. *)\n let readdir_compat dir =\n try\n Sys.readdir (if dir = \"\" then Filename.current_dir_name else dir)\n with Sys_error _ ->\n [||]\n\n let create path =\n { path; files = Array.to_list (readdir_compat path) }\nend\n\nlet dirs = s_ref []\n\nlet reset () =\n assert (not Config.merlin || Local_store.is_bound ());\n STbl.clear !files;\n STbl.clear !files_uncap;\n dirs := []\n\nlet get () = List.rev !dirs\nlet get_paths () = List.rev_map Dir.path !dirs\n\n(* Optimized version of [add] below, for use in [init] and [remove_dir]: since\n we are starting from an empty cache, we can avoid checking whether a unit\n name already exists in the cache simply by adding entries in reverse\n order. *)\nlet prepend_add dir =\n List.iter (fun base ->\n let fn = Filename.concat dir.Dir.path base in\n STbl.replace !files base fn;\n STbl.replace !files_uncap (String.uncapitalize_ascii base) fn\n ) dir.Dir.files\n\nlet init l =\n reset ();\n dirs := List.rev_map Dir.create l;\n List.iter prepend_add !dirs\n\nlet remove_dir dir =\n assert (not Config.merlin || Local_store.is_bound ());\n let new_dirs = List.filter (fun d -> Dir.path d <> dir) !dirs in\n if List.compare_lengths new_dirs !dirs <> 0 then begin\n reset ();\n List.iter prepend_add new_dirs;\n dirs := new_dirs\n end\n\n(* General purpose version of function to add a new entry to load path: We only\n add a basename to the cache if it is not already present in the cache, in\n order to enforce left-to-right precedence. *)\nlet add dir =\n assert (not Config.merlin || Local_store.is_bound ());\n List.iter\n (fun base ->\n let fn = Filename.concat dir.Dir.path base in\n if not (STbl.mem !files base) then\n STbl.replace !files base fn;\n let ubase = String.uncapitalize_ascii base in\n if not (STbl.mem !files_uncap ubase) then\n STbl.replace !files_uncap ubase fn)\n dir.Dir.files;\n dirs := dir :: !dirs\n\nlet append_dir = add\n\nlet add_dir dir = add (Dir.create dir)\n\n(* Add the directory at the start of load path - so basenames are\n unconditionally added. *)\nlet prepend_dir dir =\n assert (not Config.merlin || Local_store.is_bound ());\n prepend_add dir;\n dirs := !dirs @ [dir]\n\nlet is_basename fn = Filename.basename fn = fn\n\nlet find fn =\n assert (not Config.merlin || Local_store.is_bound ());\n if is_basename fn && not !Sys.interactive then\n STbl.find !files fn\n else\n Misc.find_in_path (get_paths ()) fn\n\nlet find_uncap fn =\n assert (not Config.merlin || Local_store.is_bound ());\n if is_basename fn && not !Sys.interactive then\n STbl.find !files_uncap (String.uncapitalize_ascii fn)\n else\n Misc.find_in_path_uncap (get_paths ()) fn\n","(**************************************************************************)\n(* *)\n(* OCaml *)\n(* *)\n(* Damien Doligez, projet Para, INRIA Rocquencourt *)\n(* *)\n(* Copyright 1998 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 mk_a f =\n \"-a\", Arg.Unit f, \" Build a library\"\n;;\n\nlet mk_alert f =\n \"-alert\", Arg.String f,\n Printf.sprintf\n \" Enable or disable alerts according to :\\n\\\n \\ + enable alert \\n\\\n \\ - disable alert \\n\\\n \\ ++ treat as fatal error\\n\\\n \\ -- treat as non-fatal\\n\\\n \\ @ enable and treat it as fatal error\\n\\\n \\ can be 'all' to refer to all alert names\";;\n\nlet mk_absname f =\n \"-absname\", Arg.Unit f, \" Show absolute filenames in error messages\"\n;;\n\nlet mk_annot f =\n \"-annot\", Arg.Unit f, \" (deprecated) Save information in .annot\"\n;;\n\nlet mk_binannot f =\n \"-bin-annot\", Arg.Unit f, \" Save typedtree in .cmt\"\n;;\n\nlet mk_c f =\n \"-c\", Arg.Unit f, \" Compile only (do not link)\"\n;;\n\nlet mk_cc f =\n \"-cc\", Arg.String f, \" Use as the C compiler and linker\"\n;;\n\nlet mk_cclib f =\n \"-cclib\", Arg.String f, \" Pass option to the C linker\"\n;;\n\nlet mk_ccopt f =\n \"-ccopt\", Arg.String f,\n \" Pass option to the C compiler and linker\"\n;;\n\nlet mk_clambda_checks f =\n \"-clambda-checks\", Arg.Unit f, \" Instrument clambda code with closure and \\\n field access checks (for debugging the compiler)\"\n;;\n\nlet mk_compact f =\n \"-compact\", Arg.Unit f, \" Optimize code size rather than speed\"\n;;\n\nlet mk_compat_32 f =\n \"-compat-32\", Arg.Unit f,\n \" Check that generated bytecode can run on 32-bit platforms\"\n;;\n\nlet mk_config f =\n \"-config\", Arg.Unit f, \" Print configuration values and exit\"\n;;\n\nlet mk_config_var f =\n \"-config-var\", Arg.String f,\n \" Print the value of a configuration variable, without a newline, and exit\\n\\\n\\ (print nothing and exit with error value if the variable does not exist)\"\n;;\n\nlet mk_custom f =\n \"-custom\", Arg.Unit f, \" Link in custom mode\"\n;;\n\nlet mk_dllib f =\n \"-dllib\", Arg.String f, \" Use the dynamically-loaded library \"\n;;\n\nlet mk_dllpath f =\n \"-dllpath\", Arg.String f,\n \" Add to the run-time search path for shared libraries\"\n;;\n\nlet mk_eval f =\n \"-e\", Arg.String f,\n \"