diff --git a/src/test/contracts/dune b/src/test/contracts/dune index 586fdf5e5..55c1ace75 100644 --- a/src/test/contracts/dune +++ b/src/test/contracts/dune @@ -1,440 +1,728 @@ ;; pretty print contracts to an output file -(rule (targets address.output) (action (with-stdout-to address.output (run ligo "pretty-print" "address.religo"))) (deps address.religo)) -(rule (targets amount.output) (action (with-stdout-to amount.output (run ligo "pretty-print" "amount.religo"))) (deps amount.religo)) -(rule (targets arithmetic.output) (action (with-stdout-to arithmetic.output (run ligo "pretty-print" "arithmetic.religo"))) (deps arithmetic.religo)) -(rule (targets bad_address_format.output) (action (with-stdout-to bad_address_format.output (run ligo "pretty-print" "bad_address_format.religo"))) (deps bad_address_format.religo)) -(rule (targets balance_constant.output) (action (with-stdout-to balance_constant.output (run ligo "pretty-print" "balance_constant.religo"))) (deps balance_constant.religo)) -(rule (targets bitwise_arithmetic.output) (action (with-stdout-to bitwise_arithmetic.output (run ligo "pretty-print" "bitwise_arithmetic.religo"))) (deps bitwise_arithmetic.religo)) -(rule (targets boolean_operators.output) (action (with-stdout-to boolean_operators.output (run ligo "pretty-print" "boolean_operators.religo"))) (deps boolean_operators.religo)) -(rule (targets bytes_arithmetic.output) (action (with-stdout-to bytes_arithmetic.output (run ligo "pretty-print" "bytes_arithmetic.religo"))) (deps bytes_arithmetic.religo)) -(rule (targets bytes_unpack.output) (action (with-stdout-to bytes_unpack.output (run ligo "pretty-print" "bytes_unpack.religo"))) (deps bytes_unpack.religo)) -(rule (targets check_signature.output) (action (with-stdout-to check_signature.output (run ligo "pretty-print" "check_signature.religo"))) (deps check_signature.religo)) -(rule (targets closure.output) (action (with-stdout-to closure.output (run ligo "pretty-print" "closure.religo"))) (deps closure.religo)) -(rule (targets condition-shadowing.output) (action (with-stdout-to condition-shadowing.output (run ligo "pretty-print" "condition-shadowing.religo"))) (deps condition-shadowing.religo)) -(rule (targets condition.output) (action (with-stdout-to condition.output (run ligo "pretty-print" "condition.religo"))) (deps condition.religo)) -(rule (targets counter.output) (action (with-stdout-to counter.output (run ligo "pretty-print" "counter.religo"))) (deps counter.religo)) -(rule (targets crypto.output) (action (with-stdout-to crypto.output (run ligo "pretty-print" "crypto.religo"))) (deps crypto.religo)) -(rule (targets empty_case.output) (action (with-stdout-to empty_case.output (run ligo "pretty-print" "empty_case.religo"))) (deps empty_case.religo)) -(rule (targets eq_bool.output) (action (with-stdout-to eq_bool.output (run ligo "pretty-print" "eq_bool.religo"))) (deps eq_bool.religo)) -(rule (targets failwith.output) (action (with-stdout-to failwith.output (run ligo "pretty-print" "failwith.religo"))) (deps failwith.religo)) -(rule (targets function-shared.output) (action (with-stdout-to function-shared.output (run ligo "pretty-print" "function-shared.religo"))) (deps function-shared.religo)) -(rule (targets high-order.output) (action (with-stdout-to high-order.output (run ligo "pretty-print" "high-order.religo"))) (deps high-order.religo)) -(rule (targets implicit_account.output) (action (with-stdout-to implicit_account.output (run ligo "pretty-print" "implicit_account.religo"))) (deps implicit_account.religo)) -(rule (targets included.output) (action (with-stdout-to included.output (run ligo "pretty-print" "included.religo"))) (deps included.religo)) -(rule (targets includer.output) (action (with-stdout-to includer.output (run ligo "pretty-print" "includer.religo"))) (deps includer.religo)) -(rule (targets key_hash.output) (action (with-stdout-to key_hash.output (run ligo "pretty-print" "key_hash.religo"))) (deps key_hash.religo)) -(rule (targets lambda.output) (action (with-stdout-to lambda.output (run ligo "pretty-print" "lambda.religo"))) (deps lambda.religo)) -(rule (targets lambda2.output) (action (with-stdout-to lambda2.output (run ligo "pretty-print" "lambda2.religo"))) (deps lambda2.religo)) -(rule (targets let_multiple.output) (action (with-stdout-to let_multiple.output (run ligo "pretty-print" "let_multiple.religo"))) (deps let_multiple.religo)) -(rule (targets letin.output) (action (with-stdout-to letin.output (run ligo "pretty-print" "letin.religo"))) (deps letin.religo)) -(rule (targets list.output) (action (with-stdout-to list.output (run ligo "pretty-print" "list.religo"))) (deps list.religo)) -(rule (targets loop.output) (action (with-stdout-to loop.output (run ligo "pretty-print" "loop.religo"))) (deps loop.religo)) -(rule (targets map.output) (action (with-stdout-to map.output (run ligo "pretty-print" "map.religo"))) (deps map.religo)) -(rule (targets match_bis.output) (action (with-stdout-to match_bis.output (run ligo "pretty-print" "match_bis.religo"))) (deps match_bis.religo)) -(rule (targets match.output) (action (with-stdout-to match.output (run ligo "pretty-print" "match.religo"))) (deps match.religo)) -(rule (targets michelson_pair_tree.output) (action (with-stdout-to michelson_pair_tree.output (run ligo "pretty-print" "michelson_pair_tree.religo"))) (deps michelson_pair_tree.religo)) -(rule (targets multiple-parameters.output) (action (with-stdout-to multiple-parameters.output (run ligo "pretty-print" "multiple-parameters.religo"))) (deps multiple-parameters.religo)) -(rule (targets multisig.output) (action (with-stdout-to multisig.output (run ligo "pretty-print" "multisig.religo"))) (deps multisig.religo)) -(rule (targets no_semicolon.output) (action (with-stdout-to no_semicolon.output (run ligo "pretty-print" "no_semicolon.religo"))) (deps no_semicolon.religo)) -(rule (targets pledge.output) (action (with-stdout-to pledge.output (run ligo "pretty-print" "pledge.religo"))) (deps pledge.religo)) -(rule (targets record.output) (action (with-stdout-to record.output (run ligo "pretty-print" "record.religo"))) (deps record.religo)) -(rule (targets recursion.output) (action (with-stdout-to recursion.output (run ligo "pretty-print" "recursion.religo"))) (deps recursion.religo)) -(rule (targets self_address.output) (action (with-stdout-to self_address.output (run ligo "pretty-print" "self_address.religo"))) (deps self_address.religo)) -(rule (targets set_arithmetic.output) (action (with-stdout-to set_arithmetic.output (run ligo "pretty-print" "set_arithmetic.religo"))) (deps set_arithmetic.religo)) -(rule (targets set_delegate.output) (action (with-stdout-to set_delegate.output (run ligo "pretty-print" "set_delegate.religo"))) (deps set_delegate.religo)) -(rule (targets single_record_item.output) (action (with-stdout-to single_record_item.output (run ligo "pretty-print" "single_record_item.religo"))) (deps single_record_item.religo)) -(rule (targets string_arithmetic.output) (action (with-stdout-to string_arithmetic.output (run ligo "pretty-print" "string_arithmetic.religo"))) (deps string_arithmetic.religo)) -(rule (targets super-counter.output) (action (with-stdout-to super-counter.output (run ligo "pretty-print" "super-counter.religo"))) (deps super-counter.religo)) -(rule (targets tuple_list.output) (action (with-stdout-to tuple_list.output (run ligo "pretty-print" "tuple_list.religo"))) (deps tuple_list.religo)) -(rule (targets tuple_param_destruct.output) (action (with-stdout-to tuple_param_destruct.output (run ligo "pretty-print" "tuple_param_destruct.religo"))) (deps tuple_param_destruct.religo)) -(rule (targets tuple_type.output) (action (with-stdout-to tuple_type.output (run ligo "pretty-print" "tuple_type.religo"))) (deps tuple_type.religo)) -(rule (targets tuple.output) (action (with-stdout-to tuple.output (run ligo "pretty-print" "tuple.religo"))) (deps tuple.religo)) -(rule (targets tuples_no_annotation.output) (action (with-stdout-to tuples_no_annotation.output (run ligo "pretty-print" "tuples_no_annotation.religo"))) (deps tuples_no_annotation.religo)) -(rule (targets tuples_sequences_functions.output) (action (with-stdout-to tuples_sequences_functions.output (run ligo "pretty-print" "tuples_sequences_functions.religo"))) (deps tuples_sequences_functions.religo)) -(rule (targets variant.output) (action (with-stdout-to variant.output (run ligo "pretty-print" "variant.religo"))) (deps variant.religo)) -(rule (targets website2.output) (action (with-stdout-to website2.output (run ligo "pretty-print" "website2.religo"))) (deps website2.religo)) +;; reasonligo +(rule (targets address.religo_output) (action (with-stdout-to address.religo_output (run ligo "pretty-print" "address.religo"))) (deps address.religo)) +(rule (targets amount.religo_output) (action (with-stdout-to amount.religo_output (run ligo "pretty-print" "amount.religo"))) (deps amount.religo)) +(rule (targets arithmetic.religo_output) (action (with-stdout-to arithmetic.religo_output (run ligo "pretty-print" "arithmetic.religo"))) (deps arithmetic.religo)) +(rule (targets bad_address_format.religo_output) (action (with-stdout-to bad_address_format.religo_output (run ligo "pretty-print" "bad_address_format.religo"))) (deps bad_address_format.religo)) +(rule (targets balance_constant.religo_output) (action (with-stdout-to balance_constant.religo_output (run ligo "pretty-print" "balance_constant.religo"))) (deps balance_constant.religo)) +(rule (targets bitwise_arithmetic.religo_output) (action (with-stdout-to bitwise_arithmetic.religo_output (run ligo "pretty-print" "bitwise_arithmetic.religo"))) (deps bitwise_arithmetic.religo)) +(rule (targets boolean_operators.religo_output) (action (with-stdout-to boolean_operators.religo_output (run ligo "pretty-print" "boolean_operators.religo"))) (deps boolean_operators.religo)) +(rule (targets bytes_arithmetic.religo_output) (action (with-stdout-to bytes_arithmetic.religo_output (run ligo "pretty-print" "bytes_arithmetic.religo"))) (deps bytes_arithmetic.religo)) +(rule (targets bytes_unpack.religo_output) (action (with-stdout-to bytes_unpack.religo_output (run ligo "pretty-print" "bytes_unpack.religo"))) (deps bytes_unpack.religo)) +(rule (targets check_signature.religo_output) (action (with-stdout-to check_signature.religo_output (run ligo "pretty-print" "check_signature.religo"))) (deps check_signature.religo)) +(rule (targets closure.religo_output) (action (with-stdout-to closure.religo_output (run ligo "pretty-print" "closure.religo"))) (deps closure.religo)) +(rule (targets condition-shadowing.religo_output) (action (with-stdout-to condition-shadowing.religo_output (run ligo "pretty-print" "condition-shadowing.religo"))) (deps condition-shadowing.religo)) +(rule (targets condition.religo_output) (action (with-stdout-to condition.religo_output (run ligo "pretty-print" "condition.religo"))) (deps condition.religo)) +(rule (targets counter.religo_output) (action (with-stdout-to counter.religo_output (run ligo "pretty-print" "counter.religo"))) (deps counter.religo)) +(rule (targets crypto.religo_output) (action (with-stdout-to crypto.religo_output (run ligo "pretty-print" "crypto.religo"))) (deps crypto.religo)) +(rule (targets empty_case.religo_output) (action (with-stdout-to empty_case.religo_output (run ligo "pretty-print" "empty_case.religo"))) (deps empty_case.religo)) +(rule (targets eq_bool.religo_output) (action (with-stdout-to eq_bool.religo_output (run ligo "pretty-print" "eq_bool.religo"))) (deps eq_bool.religo)) +(rule (targets failwith.religo_output) (action (with-stdout-to failwith.religo_output (run ligo "pretty-print" "failwith.religo"))) (deps failwith.religo)) +(rule (targets function-shared.religo_output) (action (with-stdout-to function-shared.religo_output (run ligo "pretty-print" "function-shared.religo"))) (deps function-shared.religo)) +(rule (targets high-order.religo_output) (action (with-stdout-to high-order.religo_output (run ligo "pretty-print" "high-order.religo"))) (deps high-order.religo)) +(rule (targets implicit_account.religo_output) (action (with-stdout-to implicit_account.religo_output (run ligo "pretty-print" "implicit_account.religo"))) (deps implicit_account.religo)) +(rule (targets included.religo_output) (action (with-stdout-to included.religo_output (run ligo "pretty-print" "included.religo"))) (deps included.religo)) +(rule (targets includer.religo_output) (action (with-stdout-to includer.religo_output (run ligo "pretty-print" "includer.religo"))) (deps includer.religo)) +(rule (targets key_hash.religo_output) (action (with-stdout-to key_hash.religo_output (run ligo "pretty-print" "key_hash.religo"))) (deps key_hash.religo)) +(rule (targets lambda.religo_output) (action (with-stdout-to lambda.religo_output (run ligo "pretty-print" "lambda.religo"))) (deps lambda.religo)) +(rule (targets lambda2.religo_output) (action (with-stdout-to lambda2.religo_output (run ligo "pretty-print" "lambda2.religo"))) (deps lambda2.religo)) +(rule (targets let_multiple.religo_output) (action (with-stdout-to let_multiple.religo_output (run ligo "pretty-print" "let_multiple.religo"))) (deps let_multiple.religo)) +(rule (targets letin.religo_output) (action (with-stdout-to letin.religo_output (run ligo "pretty-print" "letin.religo"))) (deps letin.religo)) +(rule (targets list.religo_output) (action (with-stdout-to list.religo_output (run ligo "pretty-print" "list.religo"))) (deps list.religo)) +(rule (targets loop.religo_output) (action (with-stdout-to loop.religo_output (run ligo "pretty-print" "loop.religo"))) (deps loop.religo)) +(rule (targets map.religo_output) (action (with-stdout-to map.religo_output (run ligo "pretty-print" "map.religo"))) (deps map.religo)) +(rule (targets match_bis.religo_output) (action (with-stdout-to match_bis.religo_output (run ligo "pretty-print" "match_bis.religo"))) (deps match_bis.religo)) +(rule (targets match.religo_output) (action (with-stdout-to match.religo_output (run ligo "pretty-print" "match.religo"))) (deps match.religo)) +(rule (targets michelson_pair_tree.religo_output) (action (with-stdout-to michelson_pair_tree.religo_output (run ligo "pretty-print" "michelson_pair_tree.religo"))) (deps michelson_pair_tree.religo)) +(rule (targets multiple-parameters.religo_output) (action (with-stdout-to multiple-parameters.religo_output (run ligo "pretty-print" "multiple-parameters.religo"))) (deps multiple-parameters.religo)) +(rule (targets multisig.religo_output) (action (with-stdout-to multisig.religo_output (run ligo "pretty-print" "multisig.religo"))) (deps multisig.religo)) +(rule (targets no_semicolon.religo_output) (action (with-stdout-to no_semicolon.religo_output (run ligo "pretty-print" "no_semicolon.religo"))) (deps no_semicolon.religo)) +(rule (targets pledge.religo_output) (action (with-stdout-to pledge.religo_output (run ligo "pretty-print" "pledge.religo"))) (deps pledge.religo)) +(rule (targets record.religo_output) (action (with-stdout-to record.religo_output (run ligo "pretty-print" "record.religo"))) (deps record.religo)) +(rule (targets recursion.religo_output) (action (with-stdout-to recursion.religo_output (run ligo "pretty-print" "recursion.religo"))) (deps recursion.religo)) +(rule (targets self_address.religo_output) (action (with-stdout-to self_address.religo_output (run ligo "pretty-print" "self_address.religo"))) (deps self_address.religo)) +(rule (targets set_arithmetic.religo_output) (action (with-stdout-to set_arithmetic.religo_output (run ligo "pretty-print" "set_arithmetic.religo"))) (deps set_arithmetic.religo)) +(rule (targets set_delegate.religo_output) (action (with-stdout-to set_delegate.religo_output (run ligo "pretty-print" "set_delegate.religo"))) (deps set_delegate.religo)) +(rule (targets single_record_item.religo_output) (action (with-stdout-to single_record_item.religo_output (run ligo "pretty-print" "single_record_item.religo"))) (deps single_record_item.religo)) +(rule (targets string_arithmetic.religo_output) (action (with-stdout-to string_arithmetic.religo_output (run ligo "pretty-print" "string_arithmetic.religo"))) (deps string_arithmetic.religo)) +(rule (targets super-counter.religo_output) (action (with-stdout-to super-counter.religo_output (run ligo "pretty-print" "super-counter.religo"))) (deps super-counter.religo)) +(rule (targets tuple_list.religo_output) (action (with-stdout-to tuple_list.religo_output (run ligo "pretty-print" "tuple_list.religo"))) (deps tuple_list.religo)) +(rule (targets tuple_param_destruct.religo_output) (action (with-stdout-to tuple_param_destruct.religo_output (run ligo "pretty-print" "tuple_param_destruct.religo"))) (deps tuple_param_destruct.religo)) +(rule (targets tuple_type.religo_output) (action (with-stdout-to tuple_type.religo_output (run ligo "pretty-print" "tuple_type.religo"))) (deps tuple_type.religo)) +(rule (targets tuple.religo_output) (action (with-stdout-to tuple.religo_output (run ligo "pretty-print" "tuple.religo"))) (deps tuple.religo)) +(rule (targets tuples_no_annotation.religo_output) (action (with-stdout-to tuples_no_annotation.religo_output (run ligo "pretty-print" "tuples_no_annotation.religo"))) (deps tuples_no_annotation.religo)) +(rule (targets tuples_sequences_functions.religo_output) (action (with-stdout-to tuples_sequences_functions.religo_output (run ligo "pretty-print" "tuples_sequences_functions.religo"))) (deps tuples_sequences_functions.religo)) +(rule (targets variant.religo_output) (action (with-stdout-to variant.religo_output (run ligo "pretty-print" "variant.religo"))) (deps variant.religo)) +(rule (targets website2.religo_output) (action (with-stdout-to website2.religo_output (run ligo "pretty-print" "website2.religo"))) (deps website2.religo)) + +;; cameligo +(rule (targets assert.mligo_output) (action (with-stdout-to assert.mligo_output (run ligo pretty-print assert.mligo))) (deps assert.mligo)) +(rule (targets address.mligo_output) (action (with-stdout-to address.mligo_output (run ligo pretty-print address.mligo))) (deps address.mligo)) +(rule (targets amount_lambda.mligo_output) (action (with-stdout-to amount_lambda.mligo_output (run ligo pretty-print amount_lambda.mligo))) (deps amount_lambda.mligo)) +(rule (targets amount.mligo_output) (action (with-stdout-to amount.mligo_output (run ligo pretty-print amount.mligo))) (deps amount.mligo)) +(rule (targets arithmetic.mligo_output) (action (with-stdout-to arithmetic.mligo_output (run ligo pretty-print arithmetic.mligo))) (deps arithmetic.mligo)) +(rule (targets attributes.mligo_output) (action (with-stdout-to attributes.mligo_output (run ligo pretty-print attributes.mligo))) (deps attributes.mligo)) +(rule (targets balance_constant.mligo_output) (action (with-stdout-to balance_constant.mligo_output (run ligo pretty-print balance_constant.mligo))) (deps balance_constant.mligo)) +(rule (targets basic.mligo_output) (action (with-stdout-to basic.mligo_output (run ligo pretty-print basic.mligo))) (deps basic.mligo)) +(rule (targets big_map.mligo_output) (action (with-stdout-to big_map.mligo_output (run ligo pretty-print big_map.mligo))) (deps big_map.mligo)) +(rule (targets bitwise_arithmetic.mligo_output) (action (with-stdout-to bitwise_arithmetic.mligo_output (run ligo pretty-print bitwise_arithmetic.mligo))) (deps bitwise_arithmetic.mligo)) +(rule (targets boolean_operators.mligo_output) (action (with-stdout-to boolean_operators.mligo_output (run ligo pretty-print boolean_operators.mligo))) (deps boolean_operators.mligo)) +(rule (targets bytes_arithmetic.mligo_output) (action (with-stdout-to bytes_arithmetic.mligo_output (run ligo pretty-print bytes_arithmetic.mligo))) (deps bytes_arithmetic.mligo)) +(rule (targets bytes_unpack.mligo_output) (action (with-stdout-to bytes_unpack.mligo_output (run ligo pretty-print bytes_unpack.mligo))) (deps bytes_unpack.mligo)) +(rule (targets check_signature.mligo_output) (action (with-stdout-to check_signature.mligo_output (run ligo pretty-print check_signature.mligo))) (deps check_signature.mligo)) +(rule (targets closure.mligo_output) (action (with-stdout-to closure.mligo_output (run ligo pretty-print closure.mligo))) (deps closure.mligo)) +(rule (targets comparable.mligo_output) (action (with-stdout-to comparable.mligo_output (run ligo pretty-print comparable.mligo))) (deps comparable.mligo)) +(rule (targets condition-annot.mligo_output) (action (with-stdout-to condition-annot.mligo_output (run ligo pretty-print condition-annot.mligo))) (deps condition-annot.mligo)) +(rule (targets condition-shadowing.mligo_output) (action (with-stdout-to condition-shadowing.mligo_output (run ligo pretty-print condition-shadowing.mligo))) (deps condition-shadowing.mligo)) +(rule (targets condition.mligo_output) (action (with-stdout-to condition.mligo_output (run ligo pretty-print condition.mligo))) (deps condition.mligo)) +(rule (targets counter.mligo_output) (action (with-stdout-to counter.mligo_output (run ligo pretty-print counter.mligo))) (deps counter.mligo)) +(rule (targets create_contract.mligo_output) (action (with-stdout-to create_contract.mligo_output (run ligo pretty-print create_contract.mligo))) (deps create_contract.mligo)) +(rule (targets crypto.mligo_output) (action (with-stdout-to crypto.mligo_output (run ligo pretty-print crypto.mligo))) (deps crypto.mligo)) +(rule (targets curry.mligo_output) (action (with-stdout-to curry.mligo_output (run ligo pretty-print curry.mligo))) (deps curry.mligo)) +(rule (targets double_michelson_or.mligo_output) (action (with-stdout-to double_michelson_or.mligo_output (run ligo pretty-print double_michelson_or.mligo))) (deps double_michelson_or.mligo)) +(rule (targets empty_case.mligo_output) (action (with-stdout-to empty_case.mligo_output (run ligo pretty-print empty_case.mligo))) (deps empty_case.mligo)) +(rule (targets eq_bool.mligo_output) (action (with-stdout-to eq_bool.mligo_output (run ligo pretty-print eq_bool.mligo))) (deps eq_bool.mligo)) +(rule (targets FA1.2.mligo_output) (action (with-stdout-to FA1.2.mligo_output (run ligo pretty-print FA1.2.mligo))) (deps FA1.2.mligo)) +(rule (targets failwith.mligo_output) (action (with-stdout-to failwith.mligo_output (run ligo pretty-print failwith.mligo))) (deps failwith.mligo)) +(rule (targets fibo.mligo_output) (action (with-stdout-to fibo.mligo_output (run ligo pretty-print fibo.mligo))) (deps fibo.mligo)) +(rule (targets fibo2.mligo_output) (action (with-stdout-to fibo2.mligo_output (run ligo pretty-print fibo2.mligo))) (deps fibo2.mligo)) +(rule (targets fibo3.mligo_output) (action (with-stdout-to fibo3.mligo_output (run ligo pretty-print fibo3.mligo))) (deps fibo3.mligo)) +(rule (targets fibo4.mligo_output) (action (with-stdout-to fibo4.mligo_output (run ligo pretty-print fibo4.mligo))) (deps fibo4.mligo)) +(rule (targets function-shared.mligo_output) (action (with-stdout-to function-shared.mligo_output (run ligo pretty-print function-shared.mligo))) (deps function-shared.mligo)) +(rule (targets guess_string.mligo_output) (action (with-stdout-to guess_string.mligo_output (run ligo pretty-print guess_string.mligo))) (deps guess_string.mligo)) + ;; compare the output with the expected result -(alias (name runtest) (action (diff expected/address.religo address.output))) -(alias (name runtest) (action (diff expected/amount.religo amount.output))) -(alias (name runtest) (action (diff expected/arithmetic.religo arithmetic.output))) -(alias (name runtest) (action (diff expected/bad_address_format.religo bad_address_format.output))) -(alias (name runtest) (action (diff expected/balance_constant.religo balance_constant.output))) -(alias (name runtest) (action (diff expected/bitwise_arithmetic.religo bitwise_arithmetic.output))) -(alias (name runtest) (action (diff expected/boolean_operators.religo boolean_operators.output))) -(alias (name runtest) (action (diff expected/bytes_arithmetic.religo bytes_arithmetic.output))) -(alias (name runtest) (action (diff expected/bytes_unpack.religo bytes_unpack.output))) -(alias (name runtest) (action (diff expected/check_signature.religo check_signature.output))) -(alias (name runtest) (action (diff expected/closure.religo closure.output))) -(alias (name runtest) (action (diff expected/condition-shadowing.religo condition-shadowing.output))) -(alias (name runtest) (action (diff expected/condition.religo condition.output))) -(alias (name runtest) (action (diff expected/counter.religo counter.output))) -(alias (name runtest) (action (diff expected/crypto.religo crypto.output))) -(alias (name runtest) (action (diff expected/empty_case.religo empty_case.output))) -(alias (name runtest) (action (diff expected/eq_bool.religo eq_bool.output))) -(alias (name runtest) (action (diff expected/failwith.religo failwith.output))) -(alias (name runtest) (action (diff expected/function-shared.religo function-shared.output))) -(alias (name runtest) (action (diff expected/high-order.religo high-order.output))) -(alias (name runtest) (action (diff expected/implicit_account.religo implicit_account.output))) -(alias (name runtest) (action (diff expected/included.religo included.output))) -(alias (name runtest) (action (diff expected/includer.religo includer.output))) -(alias (name runtest) (action (diff expected/key_hash.religo key_hash.output))) -(alias (name runtest) (action (diff expected/lambda.religo lambda.output))) -(alias (name runtest) (action (diff expected/lambda2.religo lambda2.output))) -(alias (name runtest) (action (diff expected/let_multiple.religo let_multiple.output))) -(alias (name runtest) (action (diff expected/letin.religo letin.output))) -(alias (name runtest) (action (diff expected/list.religo list.output))) -(alias (name runtest) (action (diff expected/loop.religo loop.output))) -(alias (name runtest) (action (diff expected/map.religo map.output))) -(alias (name runtest) (action (diff expected/match_bis.religo match_bis.output))) -(alias (name runtest) (action (diff expected/match.religo match.output))) -(alias (name runtest) (action (diff expected/michelson_pair_tree.religo michelson_pair_tree.output))) -(alias (name runtest) (action (diff expected/multiple-parameters.religo multiple-parameters.output))) -(alias (name runtest) (action (diff expected/multisig.religo multisig.output))) -(alias (name runtest) (action (diff expected/no_semicolon.religo no_semicolon.output))) -(alias (name runtest) (action (diff expected/pledge.religo pledge.output))) -(alias (name runtest) (action (diff expected/record.religo record.output))) -(alias (name runtest) (action (diff expected/recursion.religo recursion.output))) -(alias (name runtest) (action (diff expected/self_address.religo self_address.output))) -(alias (name runtest) (action (diff expected/set_arithmetic.religo set_arithmetic.output))) -(alias (name runtest) (action (diff expected/set_delegate.religo set_delegate.output))) -(alias (name runtest) (action (diff expected/single_record_item.religo single_record_item.output))) -(alias (name runtest) (action (diff expected/string_arithmetic.religo string_arithmetic.output))) -(alias (name runtest) (action (diff expected/super-counter.religo super-counter.output))) -(alias (name runtest) (action (diff expected/tuple_list.religo tuple_list.output))) -(alias (name runtest) (action (diff expected/tuple_param_destruct.religo tuple_param_destruct.output))) -(alias (name runtest) (action (diff expected/tuple_type.religo tuple_type.output))) -(alias (name runtest) (action (diff expected/tuple.religo tuple.output))) -(alias (name runtest) (action (diff expected/tuples_no_annotation.religo tuples_no_annotation.output))) -(alias (name runtest) (action (diff expected/tuples_sequences_functions.religo tuples_sequences_functions.output))) -(alias (name runtest) (action (diff expected/variant.religo variant.output))) -(alias (name runtest) (action (diff expected/website2.religo website2.output))) +;; reasonligo +(alias (name runtest) (action (diff expected/address.religo address.religo_output))) +(alias (name runtest) (action (diff expected/amount.religo amount.religo_output))) +(alias (name runtest) (action (diff expected/arithmetic.religo arithmetic.religo_output))) +(alias (name runtest) (action (diff expected/bad_address_format.religo bad_address_format.religo_output))) +(alias (name runtest) (action (diff expected/balance_constant.religo balance_constant.religo_output))) +(alias (name runtest) (action (diff expected/bitwise_arithmetic.religo bitwise_arithmetic.religo_output))) +(alias (name runtest) (action (diff expected/boolean_operators.religo boolean_operators.religo_output))) +(alias (name runtest) (action (diff expected/bytes_arithmetic.religo bytes_arithmetic.religo_output))) +(alias (name runtest) (action (diff expected/bytes_unpack.religo bytes_unpack.religo_output))) +(alias (name runtest) (action (diff expected/check_signature.religo check_signature.religo_output))) +(alias (name runtest) (action (diff expected/closure.religo closure.religo_output))) +(alias (name runtest) (action (diff expected/condition-shadowing.religo condition-shadowing.religo_output))) +(alias (name runtest) (action (diff expected/condition.religo condition.religo_output))) +(alias (name runtest) (action (diff expected/counter.religo counter.religo_output))) +(alias (name runtest) (action (diff expected/crypto.religo crypto.religo_output))) +(alias (name runtest) (action (diff expected/empty_case.religo empty_case.religo_output))) +(alias (name runtest) (action (diff expected/eq_bool.religo eq_bool.religo_output))) +(alias (name runtest) (action (diff expected/failwith.religo failwith.religo_output))) +(alias (name runtest) (action (diff expected/function-shared.religo function-shared.religo_output))) +(alias (name runtest) (action (diff expected/high-order.religo high-order.religo_output))) +(alias (name runtest) (action (diff expected/implicit_account.religo implicit_account.religo_output))) +(alias (name runtest) (action (diff expected/included.religo included.religo_output))) +(alias (name runtest) (action (diff expected/includer.religo includer.religo_output))) +(alias (name runtest) (action (diff expected/key_hash.religo key_hash.religo_output))) +(alias (name runtest) (action (diff expected/lambda.religo lambda.religo_output))) +(alias (name runtest) (action (diff expected/lambda2.religo lambda2.religo_output))) +(alias (name runtest) (action (diff expected/let_multiple.religo let_multiple.religo_output))) +(alias (name runtest) (action (diff expected/letin.religo letin.religo_output))) +(alias (name runtest) (action (diff expected/list.religo list.religo_output))) +(alias (name runtest) (action (diff expected/loop.religo loop.religo_output))) +(alias (name runtest) (action (diff expected/map.religo map.religo_output))) +(alias (name runtest) (action (diff expected/match_bis.religo match_bis.religo_output))) +(alias (name runtest) (action (diff expected/match.religo match.religo_output))) +(alias (name runtest) (action (diff expected/michelson_pair_tree.religo michelson_pair_tree.religo_output))) +(alias (name runtest) (action (diff expected/multiple-parameters.religo multiple-parameters.religo_output))) +(alias (name runtest) (action (diff expected/multisig.religo multisig.religo_output))) +(alias (name runtest) (action (diff expected/no_semicolon.religo no_semicolon.religo_output))) +(alias (name runtest) (action (diff expected/pledge.religo pledge.religo_output))) +(alias (name runtest) (action (diff expected/record.religo record.religo_output))) +(alias (name runtest) (action (diff expected/recursion.religo recursion.religo_output))) +(alias (name runtest) (action (diff expected/self_address.religo self_address.religo_output))) +(alias (name runtest) (action (diff expected/set_arithmetic.religo set_arithmetic.religo_output))) +(alias (name runtest) (action (diff expected/set_delegate.religo set_delegate.religo_output))) +(alias (name runtest) (action (diff expected/single_record_item.religo single_record_item.religo_output))) +(alias (name runtest) (action (diff expected/string_arithmetic.religo string_arithmetic.religo_output))) +(alias (name runtest) (action (diff expected/super-counter.religo super-counter.religo_output))) +(alias (name runtest) (action (diff expected/tuple_list.religo tuple_list.religo_output))) +(alias (name runtest) (action (diff expected/tuple_param_destruct.religo tuple_param_destruct.religo_output))) +(alias (name runtest) (action (diff expected/tuple_type.religo tuple_type.religo_output))) +(alias (name runtest) (action (diff expected/tuple.religo tuple.religo_output))) +(alias (name runtest) (action (diff expected/tuples_no_annotation.religo tuples_no_annotation.religo_output))) +(alias (name runtest) (action (diff expected/tuples_sequences_functions.religo tuples_sequences_functions.religo_output))) +(alias (name runtest) (action (diff expected/variant.religo variant.religo_output))) +(alias (name runtest) (action (diff expected/website2.religo website2.religo_output))) + +;; cameligo +(alias (name runtest) (action (diff expected/assert.mligo assert.mligo_output))) +(alias (name runtest) (action (diff expected/address.mligo address.mligo_output))) +(alias (name runtest) (action (diff expected/amount_lambda.mligo amount_lambda.mligo_output))) +(alias (name runtest) (action (diff expected/amount.mligo amount.mligo_output))) +(alias (name runtest) (action (diff expected/arithmetic.mligo arithmetic.mligo_output))) +(alias (name runtest) (action (diff expected/attributes.mligo attributes.mligo_output))) +(alias (name runtest) (action (diff expected/balance_constant.mligo balance_constant.mligo_output))) +(alias (name runtest) (action (diff expected/basic.mligo basic.mligo_output))) +(alias (name runtest) (action (diff expected/big_map.mligo big_map.mligo_output))) +(alias (name runtest) (action (diff expected/bitwise_arithmetic.mligo bitwise_arithmetic.mligo_output))) +(alias (name runtest) (action (diff expected/boolean_operators.mligo boolean_operators.mligo_output))) +(alias (name runtest) (action (diff expected/bytes_arithmetic.mligo bytes_arithmetic.mligo_output))) +(alias (name runtest) (action (diff expected/bytes_unpack.mligo bytes_unpack.mligo_output))) +(alias (name runtest) (action (diff expected/check_signature.mligo check_signature.mligo_output))) +(alias (name runtest) (action (diff expected/closure.mligo closure.mligo_output))) +(alias (name runtest) (action (diff expected/comparable.mligo comparable.mligo_output))) +(alias (name runtest) (action (diff expected/condition-annot.mligo condition-annot.mligo_output))) +(alias (name runtest) (action (diff expected/condition-shadowing.mligo condition-shadowing.mligo_output))) +(alias (name runtest) (action (diff expected/condition.mligo condition.mligo_output))) +(alias (name runtest) (action (diff expected/counter.mligo counter.mligo_output))) +(alias (name runtest) (action (diff expected/create_contract.mligo create_contract.mligo_output))) +(alias (name runtest) (action (diff expected/crypto.mligo crypto.mligo_output))) +(alias (name runtest) (action (diff expected/curry.mligo curry.mligo_output))) +(alias (name runtest) (action (diff expected/double_michelson_or.mligo double_michelson_or.mligo_output))) +(alias (name runtest) (action (diff expected/empty_case.mligo empty_case.mligo_output))) +(alias (name runtest) (action (diff expected/eq_bool.mligo eq_bool.mligo_output))) +(alias (name runtest) (action (diff expected/FA1.2.mligo FA1.2.mligo_output))) +(alias (name runtest) (action (diff expected/failwith.mligo failwith.mligo_output))) +(alias (name runtest) (action (diff expected/fibo.mligo fibo.mligo_output))) +(alias (name runtest) (action (diff expected/fibo2.mligo fibo2.mligo_output))) +(alias (name runtest) (action (diff expected/fibo3.mligo fibo3.mligo_output))) +(alias (name runtest) (action (diff expected/fibo4.mligo fibo4.mligo_output))) +(alias (name runtest) (action (diff expected/function-shared.mligo function-shared.mligo_output))) +(alias (name runtest) (action (diff expected/guess_string.mligo guess_string.mligo_output))) ;; try to parse the generated contracts -(alias (name runtest) (action (ignore-stdout (run ligo print-cst address.output -s reasonligo))) (deps address.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst amount.output -s reasonligo))) (deps amount.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst arithmetic.output -s reasonligo))) (deps arithmetic.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst bad_address_format.output -s reasonligo))) (deps bad_address_format.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst balance_constant.output -s reasonligo))) (deps balance_constant.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst bitwise_arithmetic.output -s reasonligo))) (deps bitwise_arithmetic.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst boolean_operators.output -s reasonligo))) (deps boolean_operators.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst bytes_arithmetic.output -s reasonligo))) (deps bytes_arithmetic.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst bytes_unpack.output -s reasonligo))) (deps bytes_unpack.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst check_signature.output -s reasonligo))) (deps check_signature.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst closure.output -s reasonligo))) (deps closure.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst condition-shadowing.output -s reasonligo))) (deps condition-shadowing.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst condition.output -s reasonligo))) (deps condition.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst counter.output -s reasonligo))) (deps counter.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst crypto.output -s reasonligo))) (deps crypto.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst empty_case.output -s reasonligo))) (deps empty_case.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst eq_bool.output -s reasonligo))) (deps eq_bool.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst failwith.output -s reasonligo))) (deps failwith.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst function-shared.output -s reasonligo))) (deps function-shared.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst high-order.output -s reasonligo))) (deps high-order.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst implicit_account.output -s reasonligo))) (deps implicit_account.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst included.output -s reasonligo))) (deps included.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst includer.output -s reasonligo))) (deps includer.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst key_hash.output -s reasonligo))) (deps key_hash.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst lambda.output -s reasonligo))) (deps lambda.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst lambda2.output -s reasonligo))) (deps lambda2.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst let_multiple.output -s reasonligo))) (deps let_multiple.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst letin.output -s reasonligo))) (deps letin.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst list.output -s reasonligo))) (deps list.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst loop.output -s reasonligo))) (deps loop.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst map.output -s reasonligo))) (deps map.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst match_bis.output -s reasonligo))) (deps match_bis.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst match.output -s reasonligo))) (deps match.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst michelson_pair_tree.output -s reasonligo))) (deps michelson_pair_tree.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst multiple-parameters.output -s reasonligo))) (deps multiple-parameters.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst multisig.output -s reasonligo))) (deps multisig.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst no_semicolon.output -s reasonligo))) (deps no_semicolon.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst pledge.output -s reasonligo))) (deps pledge.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst record.output -s reasonligo))) (deps record.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst recursion.output -s reasonligo))) (deps recursion.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst self_address.output -s reasonligo))) (deps self_address.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst set_arithmetic.output -s reasonligo))) (deps set_arithmetic.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst set_delegate.output -s reasonligo))) (deps set_delegate.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst single_record_item.output -s reasonligo))) (deps single_record_item.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst string_arithmetic.output -s reasonligo))) (deps string_arithmetic.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst super-counter.output -s reasonligo))) (deps super-counter.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuple_list.output -s reasonligo))) (deps tuple_list.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuple_param_destruct.output -s reasonligo))) (deps tuple_param_destruct.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuple_type.output -s reasonligo))) (deps tuple_type.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuple.output -s reasonligo))) (deps tuple.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuples_no_annotation.output -s reasonligo))) (deps tuples_no_annotation.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuples_sequences_functions.output -s reasonligo))) (deps tuples_sequences_functions.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst variant.output -s reasonligo))) (deps variant.output)) -(alias (name runtest) (action (ignore-stdout (run ligo print-cst website2.output -s reasonligo))) (deps website2.output)) +;; reasonligo +(alias (name runtest) (action (ignore-stdout (run ligo print-cst address.religo_output -s reasonligo))) (deps address.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst amount.religo_output -s reasonligo))) (deps amount.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst arithmetic.religo_output -s reasonligo))) (deps arithmetic.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst bad_address_format.religo_output -s reasonligo))) (deps bad_address_format.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst balance_constant.religo_output -s reasonligo))) (deps balance_constant.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst bitwise_arithmetic.religo_output -s reasonligo))) (deps bitwise_arithmetic.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst boolean_operators.religo_output -s reasonligo))) (deps boolean_operators.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst bytes_arithmetic.religo_output -s reasonligo))) (deps bytes_arithmetic.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst bytes_unpack.religo_output -s reasonligo))) (deps bytes_unpack.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst check_signature.religo_output -s reasonligo))) (deps check_signature.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst closure.religo_output -s reasonligo))) (deps closure.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst condition-shadowing.religo_output -s reasonligo))) (deps condition-shadowing.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst condition.religo_output -s reasonligo))) (deps condition.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst counter.religo_output -s reasonligo))) (deps counter.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst crypto.religo_output -s reasonligo))) (deps crypto.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst empty_case.religo_output -s reasonligo))) (deps empty_case.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst eq_bool.religo_output -s reasonligo))) (deps eq_bool.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst failwith.religo_output -s reasonligo))) (deps failwith.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst function-shared.religo_output -s reasonligo))) (deps function-shared.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst high-order.religo_output -s reasonligo))) (deps high-order.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst implicit_account.religo_output -s reasonligo))) (deps implicit_account.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst included.religo_output -s reasonligo))) (deps included.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst includer.religo_output -s reasonligo))) (deps includer.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst key_hash.religo_output -s reasonligo))) (deps key_hash.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst lambda.religo_output -s reasonligo))) (deps lambda.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst lambda2.religo_output -s reasonligo))) (deps lambda2.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst let_multiple.religo_output -s reasonligo))) (deps let_multiple.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst letin.religo_output -s reasonligo))) (deps letin.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst list.religo_output -s reasonligo))) (deps list.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst loop.religo_output -s reasonligo))) (deps loop.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst map.religo_output -s reasonligo))) (deps map.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst match_bis.religo_output -s reasonligo))) (deps match_bis.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst match.religo_output -s reasonligo))) (deps match.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst michelson_pair_tree.religo_output -s reasonligo))) (deps michelson_pair_tree.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst multiple-parameters.religo_output -s reasonligo))) (deps multiple-parameters.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst multisig.religo_output -s reasonligo))) (deps multisig.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst no_semicolon.religo_output -s reasonligo))) (deps no_semicolon.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst pledge.religo_output -s reasonligo))) (deps pledge.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst record.religo_output -s reasonligo))) (deps record.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst recursion.religo_output -s reasonligo))) (deps recursion.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst self_address.religo_output -s reasonligo))) (deps self_address.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst set_arithmetic.religo_output -s reasonligo))) (deps set_arithmetic.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst set_delegate.religo_output -s reasonligo))) (deps set_delegate.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst single_record_item.religo_output -s reasonligo))) (deps single_record_item.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst string_arithmetic.religo_output -s reasonligo))) (deps string_arithmetic.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst super-counter.religo_output -s reasonligo))) (deps super-counter.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuple_list.religo_output -s reasonligo))) (deps tuple_list.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuple_param_destruct.religo_output -s reasonligo))) (deps tuple_param_destruct.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuple_type.religo_output -s reasonligo))) (deps tuple_type.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuple.religo_output -s reasonligo))) (deps tuple.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuples_no_annotation.religo_output -s reasonligo))) (deps tuples_no_annotation.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst tuples_sequences_functions.religo_output -s reasonligo))) (deps tuples_sequences_functions.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst variant.religo_output -s reasonligo))) (deps variant.religo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst website2.religo_output -s reasonligo))) (deps website2.religo_output)) + +;; cameligo +(alias (name runtest) (action (ignore-stdout (run ligo print-cst assert.mligo_output -s cameligo))) (deps assert.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst address.mligo_output -s cameligo))) (deps address.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst amount_lambda.mligo_output -s cameligo))) (deps amount_lambda.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst amount.mligo_output -s cameligo))) (deps amount.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst arithmetic.mligo_output -s cameligo))) (deps arithmetic.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst attributes.mligo_output -s cameligo))) (deps attributes.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst balance_constant.mligo_output -s cameligo))) (deps balance_constant.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst basic.mligo_output -s cameligo))) (deps basic.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst big_map.mligo_output -s cameligo))) (deps big_map.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst bitwise_arithmetic.mligo_output -s cameligo))) (deps bitwise_arithmetic.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst boolean_operators.mligo_output -s cameligo))) (deps boolean_operators.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst bytes_arithmetic.mligo_output -s cameligo))) (deps bytes_arithmetic.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst bytes_unpack.mligo_output -s cameligo))) (deps bytes_unpack.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst check_signature.mligo_output -s cameligo))) (deps check_signature.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst closure.mligo_output -s cameligo))) (deps closure.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst comparable.mligo_output -s cameligo))) (deps comparable.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst condition-annot.mligo_output -s cameligo))) (deps condition-annot.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst condition-shadowing.mligo_output -s cameligo))) (deps condition-shadowing.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst condition.mligo_output -s cameligo))) (deps condition.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst counter.mligo_output -s cameligo))) (deps counter.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst create_contract.mligo_output -s cameligo))) (deps create_contract.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst crypto.mligo_output -s cameligo))) (deps crypto.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst curry.mligo_output -s cameligo))) (deps curry.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst double_michelson_or.mligo_output -s cameligo))) (deps double_michelson_or.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst empty_case.mligo_output -s cameligo))) (deps empty_case.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst eq_bool.mligo_output -s cameligo))) (deps eq_bool.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst FA1.2.mligo_output -s cameligo))) (deps FA1.2.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst failwith.mligo_output -s cameligo))) (deps failwith.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst fibo.mligo_output -s cameligo))) (deps fibo.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst fibo2.mligo_output -s cameligo))) (deps fibo2.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst fibo3.mligo_output -s cameligo))) (deps fibo3.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst fibo4.mligo_output -s cameligo))) (deps fibo4.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst function-shared.mligo_output -s cameligo))) (deps function-shared.mligo_output)) +(alias (name runtest) (action (ignore-stdout (run ligo print-cst guess_string.mligo_output -s cameligo))) (deps guess_string.mligo_output)) ;; pretty print with the former pretty printed contracts as input -(rule (targets address.output2) (action (with-stdout-to address.output2 (run ligo pretty-print address.output -s reasonligo))) (deps address.output)) -(rule (targets amount.output2) (action (with-stdout-to amount.output2 (run ligo pretty-print amount.output -s reasonligo))) (deps amount.output)) -(rule (targets arithmetic.output2) (action (with-stdout-to arithmetic.output2 (run ligo pretty-print arithmetic.output -s reasonligo))) (deps arithmetic.output)) -(rule (targets bad_address_format.output2) (action (with-stdout-to bad_address_format.output2 (run ligo pretty-print bad_address_format.output -s reasonligo))) (deps bad_address_format.output)) -(rule (targets balance_constant.output2) (action (with-stdout-to balance_constant.output2 (run ligo pretty-print balance_constant.output -s reasonligo))) (deps balance_constant.output)) -(rule (targets bitwise_arithmetic.output2) (action (with-stdout-to bitwise_arithmetic.output2 (run ligo pretty-print bitwise_arithmetic.output -s reasonligo))) (deps bitwise_arithmetic.output)) -(rule (targets boolean_operators.output2) (action (with-stdout-to boolean_operators.output2 (run ligo pretty-print boolean_operators.output -s reasonligo))) (deps boolean_operators.output)) -(rule (targets bytes_arithmetic.output2) (action (with-stdout-to bytes_arithmetic.output2 (run ligo pretty-print bytes_arithmetic.output -s reasonligo))) (deps bytes_arithmetic.output)) -(rule (targets bytes_unpack.output2) (action (with-stdout-to bytes_unpack.output2 (run ligo pretty-print bytes_unpack.output -s reasonligo))) (deps bytes_unpack.output)) -(rule (targets check_signature.output2) (action (with-stdout-to check_signature.output2 (run ligo pretty-print check_signature.output -s reasonligo))) (deps check_signature.output)) -(rule (targets closure.output2) (action (with-stdout-to closure.output2 (run ligo pretty-print closure.output -s reasonligo))) (deps closure.output)) -(rule (targets condition-shadowing.output2) (action (with-stdout-to condition-shadowing.output2 (run ligo pretty-print condition-shadowing.output -s reasonligo))) (deps condition-shadowing.output)) -(rule (targets condition.output2) (action (with-stdout-to condition.output2 (run ligo pretty-print condition.output -s reasonligo))) (deps condition.output)) -(rule (targets counter.output2) (action (with-stdout-to counter.output2 (run ligo pretty-print counter.output -s reasonligo))) (deps counter.output)) -(rule (targets crypto.output2) (action (with-stdout-to crypto.output2 (run ligo pretty-print crypto.output -s reasonligo))) (deps crypto.output)) -(rule (targets empty_case.output2) (action (with-stdout-to empty_case.output2 (run ligo pretty-print empty_case.output -s reasonligo))) (deps empty_case.output)) -(rule (targets eq_bool.output2) (action (with-stdout-to eq_bool.output2 (run ligo pretty-print eq_bool.output -s reasonligo))) (deps eq_bool.output)) -(rule (targets failwith.output2) (action (with-stdout-to failwith.output2 (run ligo pretty-print failwith.output -s reasonligo))) (deps failwith.output)) -(rule (targets function-shared.output2) (action (with-stdout-to function-shared.output2 (run ligo pretty-print function-shared.output -s reasonligo))) (deps function-shared.output)) -(rule (targets high-order.output2) (action (with-stdout-to high-order.output2 (run ligo pretty-print high-order.output -s reasonligo))) (deps high-order.output)) -(rule (targets implicit_account.output2) (action (with-stdout-to implicit_account.output2 (run ligo pretty-print implicit_account.output -s reasonligo))) (deps implicit_account.output)) -(rule (targets included.output2) (action (with-stdout-to included.output2 (run ligo pretty-print included.output -s reasonligo))) (deps included.output)) +;; reasonligo +(rule (targets address.religo_output2) (action (with-stdout-to address.religo_output2 (run ligo pretty-print address.religo_output -s reasonligo))) (deps address.religo_output)) +(rule (targets amount.religo_output2) (action (with-stdout-to amount.religo_output2 (run ligo pretty-print amount.religo_output -s reasonligo))) (deps amount.religo_output)) +(rule (targets arithmetic.religo_output2) (action (with-stdout-to arithmetic.religo_output2 (run ligo pretty-print arithmetic.religo_output -s reasonligo))) (deps arithmetic.religo_output)) +(rule (targets bad_address_format.religo_output2) (action (with-stdout-to bad_address_format.religo_output2 (run ligo pretty-print bad_address_format.religo_output -s reasonligo))) (deps bad_address_format.religo_output)) +(rule (targets balance_constant.religo_output2) (action (with-stdout-to balance_constant.religo_output2 (run ligo pretty-print balance_constant.religo_output -s reasonligo))) (deps balance_constant.religo_output)) +(rule (targets bitwise_arithmetic.religo_output2) (action (with-stdout-to bitwise_arithmetic.religo_output2 (run ligo pretty-print bitwise_arithmetic.religo_output -s reasonligo))) (deps bitwise_arithmetic.religo_output)) +(rule (targets boolean_operators.religo_output2) (action (with-stdout-to boolean_operators.religo_output2 (run ligo pretty-print boolean_operators.religo_output -s reasonligo))) (deps boolean_operators.religo_output)) +(rule (targets bytes_arithmetic.religo_output2) (action (with-stdout-to bytes_arithmetic.religo_output2 (run ligo pretty-print bytes_arithmetic.religo_output -s reasonligo))) (deps bytes_arithmetic.religo_output)) +(rule (targets bytes_unpack.religo_output2) (action (with-stdout-to bytes_unpack.religo_output2 (run ligo pretty-print bytes_unpack.religo_output -s reasonligo))) (deps bytes_unpack.religo_output)) +(rule (targets check_signature.religo_output2) (action (with-stdout-to check_signature.religo_output2 (run ligo pretty-print check_signature.religo_output -s reasonligo))) (deps check_signature.religo_output)) +(rule (targets closure.religo_output2) (action (with-stdout-to closure.religo_output2 (run ligo pretty-print closure.religo_output -s reasonligo))) (deps closure.religo_output)) +(rule (targets condition-shadowing.religo_output2) (action (with-stdout-to condition-shadowing.religo_output2 (run ligo pretty-print condition-shadowing.religo_output -s reasonligo))) (deps condition-shadowing.religo_output)) +(rule (targets condition.religo_output2) (action (with-stdout-to condition.religo_output2 (run ligo pretty-print condition.religo_output -s reasonligo))) (deps condition.religo_output)) +(rule (targets counter.religo_output2) (action (with-stdout-to counter.religo_output2 (run ligo pretty-print counter.religo_output -s reasonligo))) (deps counter.religo_output)) +(rule (targets crypto.religo_output2) (action (with-stdout-to crypto.religo_output2 (run ligo pretty-print crypto.religo_output -s reasonligo))) (deps crypto.religo_output)) +(rule (targets empty_case.religo_output2) (action (with-stdout-to empty_case.religo_output2 (run ligo pretty-print empty_case.religo_output -s reasonligo))) (deps empty_case.religo_output)) +(rule (targets eq_bool.religo_output2) (action (with-stdout-to eq_bool.religo_output2 (run ligo pretty-print eq_bool.religo_output -s reasonligo))) (deps eq_bool.religo_output)) +(rule (targets failwith.religo_output2) (action (with-stdout-to failwith.religo_output2 (run ligo pretty-print failwith.religo_output -s reasonligo))) (deps failwith.religo_output)) +(rule (targets function-shared.religo_output2) (action (with-stdout-to function-shared.religo_output2 (run ligo pretty-print function-shared.religo_output -s reasonligo))) (deps function-shared.religo_output)) +(rule (targets high-order.religo_output2) (action (with-stdout-to high-order.religo_output2 (run ligo pretty-print high-order.religo_output -s reasonligo))) (deps high-order.religo_output)) +(rule (targets implicit_account.religo_output2) (action (with-stdout-to implicit_account.religo_output2 (run ligo pretty-print implicit_account.religo_output -s reasonligo))) (deps implicit_account.religo_output)) +(rule (targets included.religo_output2) (action (with-stdout-to included.religo_output2 (run ligo pretty-print included.religo_output -s reasonligo))) (deps included.religo_output)) +(rule (targets includer.religo_output2) (action (with-stdout-to includer.religo_output2 (run ligo pretty-print includer.religo_output -s reasonligo))) (deps includer.religo_output)) +(rule (targets key_hash.religo_output2) (action (with-stdout-to key_hash.religo_output2 (run ligo pretty-print key_hash.religo_output -s reasonligo))) (deps key_hash.religo_output)) +(rule (targets lambda.religo_output2) (action (with-stdout-to lambda.religo_output2 (run ligo pretty-print lambda.religo_output -s reasonligo))) (deps lambda.religo_output)) +(rule (targets lambda2.religo_output2) (action (with-stdout-to lambda2.religo_output2 (run ligo pretty-print lambda2.religo_output -s reasonligo))) (deps lambda2.religo_output)) +(rule (targets let_multiple.religo_output2) (action (with-stdout-to let_multiple.religo_output2 (run ligo pretty-print let_multiple.religo_output -s reasonligo))) (deps let_multiple.religo_output)) +(rule (targets letin.religo_output2) (action (with-stdout-to letin.religo_output2 (run ligo pretty-print letin.religo_output -s reasonligo))) (deps letin.religo_output)) +(rule (targets list.religo_output2) (action (with-stdout-to list.religo_output2 (run ligo pretty-print list.religo_output -s reasonligo))) (deps list.religo_output)) +(rule (targets loop.religo_output2) (action (with-stdout-to loop.religo_output2 (run ligo pretty-print loop.religo_output -s reasonligo))) (deps loop.religo_output)) +(rule (targets map.religo_output2) (action (with-stdout-to map.religo_output2 (run ligo pretty-print map.religo_output -s reasonligo))) (deps map.religo_output)) +(rule (targets match_bis.religo_output2) (action (with-stdout-to match_bis.religo_output2 (run ligo pretty-print match_bis.religo_output -s reasonligo))) (deps match_bis.religo_output)) +(rule (targets match.religo_output2) (action (with-stdout-to match.religo_output2 (run ligo pretty-print match.religo_output -s reasonligo))) (deps match.religo_output)) +(rule (targets michelson_pair_tree.religo_output2) (action (with-stdout-to michelson_pair_tree.religo_output2 (run ligo pretty-print michelson_pair_tree.religo_output -s reasonligo))) (deps michelson_pair_tree.religo_output)) +(rule (targets multiple-parameters.religo_output2) (action (with-stdout-to multiple-parameters.religo_output2 (run ligo pretty-print multiple-parameters.religo_output -s reasonligo))) (deps multiple-parameters.religo_output)) +(rule (targets multisig.religo_output2) (action (with-stdout-to multisig.religo_output2 (run ligo pretty-print multisig.religo_output -s reasonligo))) (deps multisig.religo_output)) +(rule (targets no_semicolon.religo_output2) (action (with-stdout-to no_semicolon.religo_output2 (run ligo pretty-print no_semicolon.religo_output -s reasonligo))) (deps no_semicolon.religo_output)) +(rule (targets pledge.religo_output2) (action (with-stdout-to pledge.religo_output2 (run ligo pretty-print pledge.religo_output -s reasonligo))) (deps pledge.religo_output)) +(rule (targets record.religo_output2) (action (with-stdout-to record.religo_output2 (run ligo pretty-print record.religo_output -s reasonligo))) (deps record.religo_output)) +(rule (targets recursion.religo_output2) (action (with-stdout-to recursion.religo_output2 (run ligo pretty-print recursion.religo_output -s reasonligo))) (deps recursion.religo_output)) +(rule (targets self_address.religo_output2) (action (with-stdout-to self_address.religo_output2 (run ligo pretty-print self_address.religo_output -s reasonligo))) (deps self_address.religo_output)) +(rule (targets set_arithmetic.religo_output2) (action (with-stdout-to set_arithmetic.religo_output2 (run ligo pretty-print set_arithmetic.religo_output -s reasonligo))) (deps set_arithmetic.religo_output)) +(rule (targets set_delegate.religo_output2) (action (with-stdout-to set_delegate.religo_output2 (run ligo pretty-print set_delegate.religo_output -s reasonligo))) (deps set_delegate.religo_output)) +(rule (targets single_record_item.religo_output2) (action (with-stdout-to single_record_item.religo_output2 (run ligo pretty-print single_record_item.religo_output -s reasonligo))) (deps single_record_item.religo_output)) +(rule (targets string_arithmetic.religo_output2) (action (with-stdout-to string_arithmetic.religo_output2 (run ligo pretty-print string_arithmetic.religo_output -s reasonligo))) (deps string_arithmetic.religo_output)) +(rule (targets super-counter.religo_output2) (action (with-stdout-to super-counter.religo_output2 (run ligo pretty-print super-counter.religo_output -s reasonligo))) (deps super-counter.religo_output)) +(rule (targets tuple_list.religo_output2) (action (with-stdout-to tuple_list.religo_output2 (run ligo pretty-print tuple_list.religo_output -s reasonligo))) (deps tuple_list.religo_output)) +(rule (targets tuple_param_destruct.religo_output2) (action (with-stdout-to tuple_param_destruct.religo_output2 (run ligo pretty-print tuple_param_destruct.religo_output -s reasonligo))) (deps tuple_param_destruct.religo_output)) +(rule (targets tuple_type.religo_output2) (action (with-stdout-to tuple_type.religo_output2 (run ligo pretty-print tuple_type.religo_output -s reasonligo))) (deps tuple_type.religo_output)) +(rule (targets tuple.religo_output2) (action (with-stdout-to tuple.religo_output2 (run ligo pretty-print tuple.religo_output -s reasonligo))) (deps tuple.religo_output)) +(rule (targets tuples_no_annotation.religo_output2) (action (with-stdout-to tuples_no_annotation.religo_output2 (run ligo pretty-print tuples_no_annotation.religo_output -s reasonligo))) (deps tuples_no_annotation.religo_output)) +(rule (targets tuples_sequences_functions.religo_output2) (action (with-stdout-to tuples_sequences_functions.religo_output2 (run ligo pretty-print tuples_sequences_functions.religo_output -s reasonligo))) (deps tuples_sequences_functions.religo_output)) +(rule (targets variant.religo_output2) (action (with-stdout-to variant.religo_output2 (run ligo pretty-print variant.religo_output -s reasonligo))) (deps variant.religo_output)) +(rule (targets website2.religo_output2) (action (with-stdout-to website2.religo_output2 (run ligo pretty-print website2.religo_output -s reasonligo))) (deps website2.religo_output)) -(rule (targets includer.output2) (action (with-stdout-to includer.output2 (run ligo pretty-print includer.output -s reasonligo))) (deps includer.output)) -(rule (targets key_hash.output2) (action (with-stdout-to key_hash.output2 (run ligo pretty-print key_hash.output -s reasonligo))) (deps key_hash.output)) -(rule (targets lambda.output2) (action (with-stdout-to lambda.output2 (run ligo pretty-print lambda.output -s reasonligo))) (deps lambda.output)) -(rule (targets lambda2.output2) (action (with-stdout-to lambda2.output2 (run ligo pretty-print lambda2.output -s reasonligo))) (deps lambda2.output)) -(rule (targets let_multiple.output2) (action (with-stdout-to let_multiple.output2 (run ligo pretty-print let_multiple.output -s reasonligo))) (deps let_multiple.output)) -(rule (targets letin.output2) (action (with-stdout-to letin.output2 (run ligo pretty-print letin.output -s reasonligo))) (deps letin.output)) -(rule (targets list.output2) (action (with-stdout-to list.output2 (run ligo pretty-print list.output -s reasonligo))) (deps list.output)) -(rule (targets loop.output2) (action (with-stdout-to loop.output2 (run ligo pretty-print loop.output -s reasonligo))) (deps loop.output)) -(rule (targets map.output2) (action (with-stdout-to map.output2 (run ligo pretty-print map.output -s reasonligo))) (deps map.output)) -(rule (targets match_bis.output2) (action (with-stdout-to match_bis.output2 (run ligo pretty-print match_bis.output -s reasonligo))) (deps match_bis.output)) -(rule (targets match.output2) (action (with-stdout-to match.output2 (run ligo pretty-print match.output -s reasonligo))) (deps match.output)) -(rule (targets michelson_pair_tree.output2) (action (with-stdout-to michelson_pair_tree.output2 (run ligo pretty-print michelson_pair_tree.output -s reasonligo))) (deps michelson_pair_tree.output)) -(rule (targets multiple-parameters.output2) (action (with-stdout-to multiple-parameters.output2 (run ligo pretty-print multiple-parameters.output -s reasonligo))) (deps multiple-parameters.output)) -(rule (targets multisig.output2) (action (with-stdout-to multisig.output2 (run ligo pretty-print multisig.output -s reasonligo))) (deps multisig.output)) -(rule (targets no_semicolon.output2) (action (with-stdout-to no_semicolon.output2 (run ligo pretty-print no_semicolon.output -s reasonligo))) (deps no_semicolon.output)) -(rule (targets pledge.output2) (action (with-stdout-to pledge.output2 (run ligo pretty-print pledge.output -s reasonligo))) (deps pledge.output)) -(rule (targets record.output2) (action (with-stdout-to record.output2 (run ligo pretty-print record.output -s reasonligo))) (deps record.output)) -(rule (targets recursion.output2) (action (with-stdout-to recursion.output2 (run ligo pretty-print recursion.output -s reasonligo))) (deps recursion.output)) -(rule (targets self_address.output2) (action (with-stdout-to self_address.output2 (run ligo pretty-print self_address.output -s reasonligo))) (deps self_address.output)) -(rule (targets set_arithmetic.output2) (action (with-stdout-to set_arithmetic.output2 (run ligo pretty-print set_arithmetic.output -s reasonligo))) (deps set_arithmetic.output)) -(rule (targets set_delegate.output2) (action (with-stdout-to set_delegate.output2 (run ligo pretty-print set_delegate.output -s reasonligo))) (deps set_delegate.output)) -(rule (targets single_record_item.output2) (action (with-stdout-to single_record_item.output2 (run ligo pretty-print single_record_item.output -s reasonligo))) (deps single_record_item.output)) -(rule (targets string_arithmetic.output2) (action (with-stdout-to string_arithmetic.output2 (run ligo pretty-print string_arithmetic.output -s reasonligo))) (deps string_arithmetic.output)) -(rule (targets super-counter.output2) (action (with-stdout-to super-counter.output2 (run ligo pretty-print super-counter.output -s reasonligo))) (deps super-counter.output)) -(rule (targets tuple_list.output2) (action (with-stdout-to tuple_list.output2 (run ligo pretty-print tuple_list.output -s reasonligo))) (deps tuple_list.output)) -(rule (targets tuple_param_destruct.output2) (action (with-stdout-to tuple_param_destruct.output2 (run ligo pretty-print tuple_param_destruct.output -s reasonligo))) (deps tuple_param_destruct.output)) -(rule (targets tuple_type.output2) (action (with-stdout-to tuple_type.output2 (run ligo pretty-print tuple_type.output -s reasonligo))) (deps tuple_type.output)) -(rule (targets tuple.output2) (action (with-stdout-to tuple.output2 (run ligo pretty-print tuple.output -s reasonligo))) (deps tuple.output)) -(rule (targets tuples_no_annotation.output2) (action (with-stdout-to tuples_no_annotation.output2 (run ligo pretty-print tuples_no_annotation.output -s reasonligo))) (deps tuples_no_annotation.output)) -(rule (targets tuples_sequences_functions.output2) (action (with-stdout-to tuples_sequences_functions.output2 (run ligo pretty-print tuples_sequences_functions.output -s reasonligo))) (deps tuples_sequences_functions.output)) -(rule (targets variant.output2) (action (with-stdout-to variant.output2 (run ligo pretty-print variant.output -s reasonligo))) (deps variant.output)) -(rule (targets website2.output2) (action (with-stdout-to website2.output2 (run ligo pretty-print website2.output -s reasonligo))) (deps website2.output)) +(rule (targets assert.mligo_output2) (action (with-stdout-to assert.mligo_output2 (run ligo pretty-print assert.mligo -s cameligo))) (deps assert.mligo_output)) +(rule (targets address.mligo_output2) (action (with-stdout-to address.mligo_output2 (run ligo pretty-print address.mligo -s cameligo))) (deps address.mligo_output)) +(rule (targets amount_lambda.mligo_output2) (action (with-stdout-to amount_lambda.mligo_output2 (run ligo pretty-print amount_lambda.mligo -s cameligo))) (deps amount_lambda.mligo_output)) +(rule (targets amount.mligo_output2) (action (with-stdout-to amount.mligo_output2 (run ligo pretty-print amount.mligo -s cameligo))) (deps amount.mligo_output)) +(rule (targets arithmetic.mligo_output2) (action (with-stdout-to arithmetic.mligo_output2 (run ligo pretty-print arithmetic.mligo -s cameligo))) (deps arithmetic.mligo_output)) +(rule (targets attributes.mligo_output2) (action (with-stdout-to attributes.mligo_output2 (run ligo pretty-print attributes.mligo -s cameligo))) (deps attributes.mligo_output)) +(rule (targets balance_constant.mligo_output2) (action (with-stdout-to balance_constant.mligo_output2 (run ligo pretty-print balance_constant.mligo -s cameligo))) (deps balance_constant.mligo_output)) +(rule (targets basic.mligo_output2) (action (with-stdout-to basic.mligo_output2 (run ligo pretty-print basic.mligo -s cameligo))) (deps basic.mligo_output)) +(rule (targets big_map.mligo_output2) (action (with-stdout-to big_map.mligo_output2 (run ligo pretty-print big_map.mligo -s cameligo))) (deps big_map.mligo_output)) +(rule (targets bitwise_arithmetic.mligo_output2) (action (with-stdout-to bitwise_arithmetic.mligo_output2 (run ligo pretty-print bitwise_arithmetic.mligo -s cameligo))) (deps bitwise_arithmetic.mligo_output)) +(rule (targets boolean_operators.mligo_output2) (action (with-stdout-to boolean_operators.mligo_output2 (run ligo pretty-print boolean_operators.mligo -s cameligo))) (deps boolean_operators.mligo_output)) +(rule (targets bytes_arithmetic.mligo_output2) (action (with-stdout-to bytes_arithmetic.mligo_output2 (run ligo pretty-print bytes_arithmetic.mligo -s cameligo))) (deps bytes_arithmetic.mligo_output)) +(rule (targets bytes_unpack.mligo_output2) (action (with-stdout-to bytes_unpack.mligo_output2 (run ligo pretty-print bytes_unpack.mligo -s cameligo))) (deps bytes_unpack.mligo_output)) +(rule (targets check_signature.mligo_output2) (action (with-stdout-to check_signature.mligo_output2 (run ligo pretty-print check_signature.mligo -s cameligo))) (deps check_signature.mligo_output)) +(rule (targets closure.mligo_output2) (action (with-stdout-to closure.mligo_output2 (run ligo pretty-print closure.mligo -s cameligo))) (deps closure.mligo_output)) +(rule (targets comparable.mligo_output2) (action (with-stdout-to comparable.mligo_output2 (run ligo pretty-print comparable.mligo -s cameligo))) (deps comparable.mligo_output)) +(rule (targets condition-annot.mligo_output2) (action (with-stdout-to condition-annot.mligo_output2 (run ligo pretty-print condition-annot.mligo -s cameligo))) (deps condition-annot.mligo_output)) +(rule (targets condition-shadowing.mligo_output2) (action (with-stdout-to condition-shadowing.mligo_output2 (run ligo pretty-print condition-shadowing.mligo -s cameligo))) (deps condition-shadowing.mligo_output)) +(rule (targets condition.mligo_output2) (action (with-stdout-to condition.mligo_output2 (run ligo pretty-print condition.mligo -s cameligo))) (deps condition.mligo_output)) +(rule (targets counter.mligo_output2) (action (with-stdout-to counter.mligo_output2 (run ligo pretty-print counter.mligo -s cameligo))) (deps counter.mligo_output)) +(rule (targets create_contract.mligo_output2) (action (with-stdout-to create_contract.mligo_output2 (run ligo pretty-print create_contract.mligo -s cameligo))) (deps create_contract.mligo_output)) +(rule (targets crypto.mligo_output2) (action (with-stdout-to crypto.mligo_output2 (run ligo pretty-print crypto.mligo -s cameligo))) (deps crypto.mligo_output)) +(rule (targets curry.mligo_output2) (action (with-stdout-to curry.mligo_output2 (run ligo pretty-print curry.mligo -s cameligo))) (deps curry.mligo_output)) +(rule (targets double_michelson_or.mligo_output2) (action (with-stdout-to double_michelson_or.mligo_output2 (run ligo pretty-print double_michelson_or.mligo -s cameligo))) (deps double_michelson_or.mligo_output)) +(rule (targets empty_case.mligo_output2) (action (with-stdout-to empty_case.mligo_output2 (run ligo pretty-print empty_case.mligo -s cameligo))) (deps empty_case.mligo_output)) +(rule (targets eq_bool.mligo_output2) (action (with-stdout-to eq_bool.mligo_output2 (run ligo pretty-print eq_bool.mligo -s cameligo))) (deps eq_bool.mligo_output)) +(rule (targets FA1.2.mligo_output2) (action (with-stdout-to FA1.2.mligo_output2 (run ligo pretty-print FA1.2.mligo -s cameligo))) (deps FA1.2.mligo_output)) +(rule (targets failwith.mligo_output2) (action (with-stdout-to failwith.mligo_output2 (run ligo pretty-print failwith.mligo -s cameligo))) (deps failwith.mligo_output)) +(rule (targets fibo.mligo_output2) (action (with-stdout-to fibo.mligo_output2 (run ligo pretty-print fibo.mligo -s cameligo))) (deps fibo.mligo_output)) +(rule (targets fibo2.mligo_output2) (action (with-stdout-to fibo2.mligo_output2 (run ligo pretty-print fibo2.mligo -s cameligo))) (deps fibo2.mligo_output)) +(rule (targets fibo3.mligo_output2) (action (with-stdout-to fibo3.mligo_output2 (run ligo pretty-print fibo3.mligo -s cameligo))) (deps fibo3.mligo_output)) +(rule (targets fibo4.mligo_output2) (action (with-stdout-to fibo4.mligo_output2 (run ligo pretty-print fibo4.mligo -s cameligo))) (deps fibo4.mligo_output)) +(rule (targets function-shared.mligo_output2) (action (with-stdout-to function-shared.mligo_output2 (run ligo pretty-print function-shared.mligo -s cameligo))) (deps function-shared.mligo_output)) +(rule (targets guess_string.mligo_output2) (action (with-stdout-to guess_string.mligo_output2 (run ligo pretty-print guess_string.mligo -s cameligo))) (deps guess_string.mligo_output)) ;; diff the pretty printed contract with the pretty printed pretty printed contract -(alias (name runtest) (action (diff address.output address.output2)) (deps address.output address.output2)) -(alias (name runtest) (action (diff amount.output amount.output2)) (deps amount.output amount.output2)) -(alias (name runtest) (action (diff arithmetic.output arithmetic.output2)) (deps arithmetic.output arithmetic.output2)) -(alias (name runtest) (action (diff bad_address_format.output bad_address_format.output2)) (deps bad_address_format.output bad_address_format.output2)) -(alias (name runtest) (action (diff balance_constant.output balance_constant.output2)) (deps balance_constant.output balance_constant.output2)) -(alias (name runtest) (action (diff bitwise_arithmetic.output bitwise_arithmetic.output2)) (deps bitwise_arithmetic.output bitwise_arithmetic.output2)) -(alias (name runtest) (action (diff boolean_operators.output boolean_operators.output2)) (deps boolean_operators.output boolean_operators.output2)) -(alias (name runtest) (action (diff bytes_arithmetic.output bytes_arithmetic.output2)) (deps bytes_arithmetic.output bytes_arithmetic.output2)) -(alias (name runtest) (action (diff bytes_unpack.output bytes_unpack.output2)) (deps bytes_unpack.output bytes_unpack.output2)) -(alias (name runtest) (action (diff check_signature.output check_signature.output2)) (deps check_signature.output check_signature.output2)) -(alias (name runtest) (action (diff closure.output closure.output2)) (deps closure.output closure.output2)) -(alias (name runtest) (action (diff condition-shadowing.output condition-shadowing.output2)) (deps condition-shadowing.output condition-shadowing.output2)) -(alias (name runtest) (action (diff condition.output condition.output2)) (deps condition.output condition.output2)) -(alias (name runtest) (action (diff counter.output counter.output2)) (deps counter.output counter.output2)) -(alias (name runtest) (action (diff crypto.output crypto.output2)) (deps crypto.output crypto.output2)) -(alias (name runtest) (action (diff empty_case.output empty_case.output2)) (deps empty_case.output empty_case.output2)) -(alias (name runtest) (action (diff eq_bool.output eq_bool.output2)) (deps eq_bool.output eq_bool.output2)) -(alias (name runtest) (action (diff failwith.output failwith.output2)) (deps failwith.output failwith.output2)) -(alias (name runtest) (action (diff function-shared.output function-shared.output2)) (deps function-shared.output function-shared.output2)) -(alias (name runtest) (action (diff high-order.output high-order.output2)) (deps high-order.output high-order.output2)) -(alias (name runtest) (action (diff implicit_account.output implicit_account.output2)) (deps implicit_account.output implicit_account.output2)) -(alias (name runtest) (action (diff included.output included.output2)) (deps included.output included.output2)) -(alias (name runtest) (action (diff includer.output includer.output2)) (deps includer.output includer.output2)) -(alias (name runtest) (action (diff key_hash.output key_hash.output2)) (deps key_hash.output key_hash.output2)) -(alias (name runtest) (action (diff lambda.output lambda.output2)) (deps lambda.output lambda.output2)) -(alias (name runtest) (action (diff lambda2.output lambda2.output2)) (deps lambda2.output lambda2.output2)) -(alias (name runtest) (action (diff let_multiple.output let_multiple.output2)) (deps let_multiple.output let_multiple.output2)) -(alias (name runtest) (action (diff letin.output letin.output2)) (deps letin.output letin.output2)) -(alias (name runtest) (action (diff list.output list.output2)) (deps list.output list.output2)) -(alias (name runtest) (action (diff loop.output loop.output2)) (deps loop.output loop.output2)) -(alias (name runtest) (action (diff map.output map.output2)) (deps map.output map.output2)) -(alias (name runtest) (action (diff match_bis.output match_bis.output2)) (deps match_bis.output match_bis.output2)) -(alias (name runtest) (action (diff match.output match.output2)) (deps match.output match.output2)) -(alias (name runtest) (action (diff michelson_pair_tree.output michelson_pair_tree.output2)) (deps michelson_pair_tree.output michelson_pair_tree.output2)) -(alias (name runtest) (action (diff multiple-parameters.output multiple-parameters.output2)) (deps multiple-parameters.output multiple-parameters.output2)) -(alias (name runtest) (action (diff multisig.output multisig.output2)) (deps multisig.output multisig.output2)) -(alias (name runtest) (action (diff no_semicolon.output no_semicolon.output2)) (deps no_semicolon.output no_semicolon.output2)) -(alias (name runtest) (action (diff pledge.output pledge.output2)) (deps pledge.output pledge.output2)) -(alias (name runtest) (action (diff record.output record.output2)) (deps record.output record.output2)) -(alias (name runtest) (action (diff recursion.output recursion.output2)) (deps recursion.output recursion.output2)) -(alias (name runtest) (action (diff self_address.output self_address.output2)) (deps self_address.output self_address.output2)) -(alias (name runtest) (action (diff set_arithmetic.output set_arithmetic.output2)) (deps set_arithmetic.output set_arithmetic.output2)) -(alias (name runtest) (action (diff set_delegate.output set_delegate.output2)) (deps set_delegate.output set_delegate.output2)) -(alias (name runtest) (action (diff single_record_item.output single_record_item.output2)) (deps single_record_item.output single_record_item.output2)) -(alias (name runtest) (action (diff string_arithmetic.output string_arithmetic.output2)) (deps string_arithmetic.output string_arithmetic.output2)) -(alias (name runtest) (action (diff super-counter.output super-counter.output2)) (deps super-counter.output super-counter.output2)) -(alias (name runtest) (action (diff tuple_list.output tuple_list.output2)) (deps tuple_list.output tuple_list.output2)) -(alias (name runtest) (action (diff tuple_param_destruct.output tuple_param_destruct.output2)) (deps tuple_param_destruct.output tuple_param_destruct.output2)) -(alias (name runtest) (action (diff tuple_type.output tuple_type.output2)) (deps tuple_type.output tuple_type.output2)) -(alias (name runtest) (action (diff tuple.output tuple.output2)) (deps tuple.output tuple.output2)) -(alias (name runtest) (action (diff tuples_no_annotation.output tuples_no_annotation.output2)) (deps tuples_no_annotation.output tuples_no_annotation.output2)) -(alias (name runtest) (action (diff tuples_sequences_functions.output tuples_sequences_functions.output2)) (deps tuples_sequences_functions.output tuples_sequences_functions.output2)) -(alias (name runtest) (action (diff variant.output variant.output2)) (deps variant.output variant.output2)) -(alias (name runtest) (action (diff website2.output website2.output2)) (deps website2.output website2.output2)) +;; reasonligo +(alias (name runtest) (action (diff address.religo_output address.religo_output2)) (deps address.religo_output address.religo_output2)) +(alias (name runtest) (action (diff amount.religo_output amount.religo_output2)) (deps amount.religo_output amount.religo_output2)) +(alias (name runtest) (action (diff arithmetic.religo_output arithmetic.religo_output2)) (deps arithmetic.religo_output arithmetic.religo_output2)) +(alias (name runtest) (action (diff bad_address_format.religo_output bad_address_format.religo_output2)) (deps bad_address_format.religo_output bad_address_format.religo_output2)) +(alias (name runtest) (action (diff balance_constant.religo_output balance_constant.religo_output2)) (deps balance_constant.religo_output balance_constant.religo_output2)) +(alias (name runtest) (action (diff bitwise_arithmetic.religo_output bitwise_arithmetic.religo_output2)) (deps bitwise_arithmetic.religo_output bitwise_arithmetic.religo_output2)) +(alias (name runtest) (action (diff boolean_operators.religo_output boolean_operators.religo_output2)) (deps boolean_operators.religo_output boolean_operators.religo_output2)) +(alias (name runtest) (action (diff bytes_arithmetic.religo_output bytes_arithmetic.religo_output2)) (deps bytes_arithmetic.religo_output bytes_arithmetic.religo_output2)) +(alias (name runtest) (action (diff bytes_unpack.religo_output bytes_unpack.religo_output2)) (deps bytes_unpack.religo_output bytes_unpack.religo_output2)) +(alias (name runtest) (action (diff check_signature.religo_output check_signature.religo_output2)) (deps check_signature.religo_output check_signature.religo_output2)) +(alias (name runtest) (action (diff closure.religo_output closure.religo_output2)) (deps closure.religo_output closure.religo_output2)) +(alias (name runtest) (action (diff condition-shadowing.religo_output condition-shadowing.religo_output2)) (deps condition-shadowing.religo_output condition-shadowing.religo_output2)) +(alias (name runtest) (action (diff condition.religo_output condition.religo_output2)) (deps condition.religo_output condition.religo_output2)) +(alias (name runtest) (action (diff counter.religo_output counter.religo_output2)) (deps counter.religo_output counter.religo_output2)) +(alias (name runtest) (action (diff crypto.religo_output crypto.religo_output2)) (deps crypto.religo_output crypto.religo_output2)) +(alias (name runtest) (action (diff empty_case.religo_output empty_case.religo_output2)) (deps empty_case.religo_output empty_case.religo_output2)) +(alias (name runtest) (action (diff eq_bool.religo_output eq_bool.religo_output2)) (deps eq_bool.religo_output eq_bool.religo_output2)) +(alias (name runtest) (action (diff failwith.religo_output failwith.religo_output2)) (deps failwith.religo_output failwith.religo_output2)) +(alias (name runtest) (action (diff function-shared.religo_output function-shared.religo_output2)) (deps function-shared.religo_output function-shared.religo_output2)) +(alias (name runtest) (action (diff high-order.religo_output high-order.religo_output2)) (deps high-order.religo_output high-order.religo_output2)) +(alias (name runtest) (action (diff implicit_account.religo_output implicit_account.religo_output2)) (deps implicit_account.religo_output implicit_account.religo_output2)) +(alias (name runtest) (action (diff included.religo_output included.religo_output2)) (deps included.religo_output included.religo_output2)) +(alias (name runtest) (action (diff includer.religo_output includer.religo_output2)) (deps includer.religo_output includer.religo_output2)) +(alias (name runtest) (action (diff key_hash.religo_output key_hash.religo_output2)) (deps key_hash.religo_output key_hash.religo_output2)) +(alias (name runtest) (action (diff lambda.religo_output lambda.religo_output2)) (deps lambda.religo_output lambda.religo_output2)) +(alias (name runtest) (action (diff lambda2.religo_output lambda2.religo_output2)) (deps lambda2.religo_output lambda2.religo_output2)) +(alias (name runtest) (action (diff let_multiple.religo_output let_multiple.religo_output2)) (deps let_multiple.religo_output let_multiple.religo_output2)) +(alias (name runtest) (action (diff letin.religo_output letin.religo_output2)) (deps letin.religo_output letin.religo_output2)) +(alias (name runtest) (action (diff list.religo_output list.religo_output2)) (deps list.religo_output list.religo_output2)) +(alias (name runtest) (action (diff loop.religo_output loop.religo_output2)) (deps loop.religo_output loop.religo_output2)) +(alias (name runtest) (action (diff map.religo_output map.religo_output2)) (deps map.religo_output map.religo_output2)) +(alias (name runtest) (action (diff match_bis.religo_output match_bis.religo_output2)) (deps match_bis.religo_output match_bis.religo_output2)) +(alias (name runtest) (action (diff match.religo_output match.religo_output2)) (deps match.religo_output match.religo_output2)) +(alias (name runtest) (action (diff michelson_pair_tree.religo_output michelson_pair_tree.religo_output2)) (deps michelson_pair_tree.religo_output michelson_pair_tree.religo_output2)) +(alias (name runtest) (action (diff multiple-parameters.religo_output multiple-parameters.religo_output2)) (deps multiple-parameters.religo_output multiple-parameters.religo_output2)) +(alias (name runtest) (action (diff multisig.religo_output multisig.religo_output2)) (deps multisig.religo_output multisig.religo_output2)) +(alias (name runtest) (action (diff no_semicolon.religo_output no_semicolon.religo_output2)) (deps no_semicolon.religo_output no_semicolon.religo_output2)) +(alias (name runtest) (action (diff pledge.religo_output pledge.religo_output2)) (deps pledge.religo_output pledge.religo_output2)) +(alias (name runtest) (action (diff record.religo_output record.religo_output2)) (deps record.religo_output record.religo_output2)) +(alias (name runtest) (action (diff recursion.religo_output recursion.religo_output2)) (deps recursion.religo_output recursion.religo_output2)) +(alias (name runtest) (action (diff self_address.religo_output self_address.religo_output2)) (deps self_address.religo_output self_address.religo_output2)) +(alias (name runtest) (action (diff set_arithmetic.religo_output set_arithmetic.religo_output2)) (deps set_arithmetic.religo_output set_arithmetic.religo_output2)) +(alias (name runtest) (action (diff set_delegate.religo_output set_delegate.religo_output2)) (deps set_delegate.religo_output set_delegate.religo_output2)) +(alias (name runtest) (action (diff single_record_item.religo_output single_record_item.religo_output2)) (deps single_record_item.religo_output single_record_item.religo_output2)) +(alias (name runtest) (action (diff string_arithmetic.religo_output string_arithmetic.religo_output2)) (deps string_arithmetic.religo_output string_arithmetic.religo_output2)) +(alias (name runtest) (action (diff super-counter.religo_output super-counter.religo_output2)) (deps super-counter.religo_output super-counter.religo_output2)) +(alias (name runtest) (action (diff tuple_list.religo_output tuple_list.religo_output2)) (deps tuple_list.religo_output tuple_list.religo_output2)) +(alias (name runtest) (action (diff tuple_param_destruct.religo_output tuple_param_destruct.religo_output2)) (deps tuple_param_destruct.religo_output tuple_param_destruct.religo_output2)) +(alias (name runtest) (action (diff tuple_type.religo_output tuple_type.religo_output2)) (deps tuple_type.religo_output tuple_type.religo_output2)) +(alias (name runtest) (action (diff tuple.religo_output tuple.religo_output2)) (deps tuple.religo_output tuple.religo_output2)) +(alias (name runtest) (action (diff tuples_no_annotation.religo_output tuples_no_annotation.religo_output2)) (deps tuples_no_annotation.religo_output tuples_no_annotation.religo_output2)) +(alias (name runtest) (action (diff tuples_sequences_functions.religo_output tuples_sequences_functions.religo_output2)) (deps tuples_sequences_functions.religo_output tuples_sequences_functions.religo_output2)) +(alias (name runtest) (action (diff variant.religo_output variant.religo_output2)) (deps variant.religo_output variant.religo_output2)) +(alias (name runtest) (action (diff website2.religo_output website2.religo_output2)) (deps website2.religo_output website2.religo_output2)) -(rule (targets address.ast) (action (with-stdout-to address.ast (run ligo print-ast address.religo -s reasonligo))) (deps address.religo)) -(rule (targets amount.ast) (action (with-stdout-to amount.ast (run ligo print-ast amount.religo -s reasonligo))) (deps amount.religo)) -(rule (targets arithmetic.ast) (action (with-stdout-to arithmetic.ast (run ligo print-ast arithmetic.religo -s reasonligo))) (deps arithmetic.religo)) -(rule (targets balance_constant.ast) (action (with-stdout-to balance_constant.ast (run ligo print-ast balance_constant.religo -s reasonligo))) (deps balance_constant.religo)) -(rule (targets bitwise_arithmetic.ast) (action (with-stdout-to bitwise_arithmetic.ast (run ligo print-ast bitwise_arithmetic.religo -s reasonligo))) (deps bitwise_arithmetic.religo)) -(rule (targets boolean_operators.ast) (action (with-stdout-to boolean_operators.ast (run ligo print-ast boolean_operators.religo -s reasonligo))) (deps boolean_operators.religo)) -(rule (targets bytes_arithmetic.ast) (action (with-stdout-to bytes_arithmetic.ast (run ligo print-ast bytes_arithmetic.religo -s reasonligo))) (deps bytes_arithmetic.religo)) -(rule (targets bytes_unpack.ast) (action (with-stdout-to bytes_unpack.ast (run ligo print-ast bytes_unpack.religo -s reasonligo))) (deps bytes_unpack.religo)) -(rule (targets check_signature.ast) (action (with-stdout-to check_signature.ast (run ligo print-ast check_signature.religo -s reasonligo))) (deps check_signature.religo)) -(rule (targets closure.ast) (action (with-stdout-to closure.ast (run ligo print-ast closure.religo -s reasonligo))) (deps closure.religo)) -(rule (targets condition-shadowing.ast) (action (with-stdout-to condition-shadowing.ast (run ligo print-ast condition-shadowing.religo -s reasonligo))) (deps condition-shadowing.religo)) -(rule (targets condition.ast) (action (with-stdout-to condition.ast (run ligo print-ast condition.religo -s reasonligo))) (deps condition.religo)) -(rule (targets counter.ast) (action (with-stdout-to counter.ast (run ligo print-ast counter.religo -s reasonligo))) (deps counter.religo)) -(rule (targets crypto.ast) (action (with-stdout-to crypto.ast (run ligo print-ast crypto.religo -s reasonligo))) (deps crypto.religo)) -(rule (targets empty_case.ast) (action (with-stdout-to empty_case.ast (run ligo print-ast empty_case.religo -s reasonligo))) (deps empty_case.religo)) -(rule (targets eq_bool.ast) (action (with-stdout-to eq_bool.ast (run ligo print-ast eq_bool.religo -s reasonligo))) (deps eq_bool.religo)) -(rule (targets function-shared.ast) (action (with-stdout-to function-shared.ast (run ligo print-ast function-shared.religo -s reasonligo))) (deps function-shared.religo)) -(rule (targets high-order.ast) (action (with-stdout-to high-order.ast (run ligo print-ast high-order.religo -s reasonligo))) (deps high-order.religo)) -(rule (targets implicit_account.ast) (action (with-stdout-to implicit_account.ast (run ligo print-ast implicit_account.religo -s reasonligo))) (deps implicit_account.religo)) -(rule (targets included.ast) (action (with-stdout-to included.ast (run ligo print-ast included.religo -s reasonligo))) (deps included.religo)) -(rule (targets includer.ast) (action (with-stdout-to includer.ast (run ligo print-ast includer.religo -s reasonligo))) (deps includer.religo)) -(rule (targets key_hash.ast) (action (with-stdout-to key_hash.ast (run ligo print-ast key_hash.religo -s reasonligo))) (deps key_hash.religo)) -(rule (targets lambda.ast) (action (with-stdout-to lambda.ast (run ligo print-ast lambda.religo -s reasonligo))) (deps lambda.religo)) -(rule (targets lambda2.ast) (action (with-stdout-to lambda2.ast (run ligo print-ast lambda2.religo -s reasonligo))) (deps lambda2.religo)) -(rule (targets let_multiple.ast) (action (with-stdout-to let_multiple.ast (run ligo print-ast let_multiple.religo -s reasonligo))) (deps let_multiple.religo)) -(rule (targets letin.ast) (action (with-stdout-to letin.ast (run ligo print-ast letin.religo -s reasonligo))) (deps letin.religo)) -(rule (targets list.ast) (action (with-stdout-to list.ast (run ligo print-ast list.religo -s reasonligo))) (deps list.religo)) -(rule (targets loop.ast) (action (with-stdout-to loop.ast (run ligo print-ast loop.religo -s reasonligo))) (deps loop.religo)) -(rule (targets map.ast) (action (with-stdout-to map.ast (run ligo print-ast map.religo -s reasonligo))) (deps map.religo)) -(rule (targets match_bis.ast) (action (with-stdout-to match_bis.ast (run ligo print-ast match_bis.religo -s reasonligo))) (deps match_bis.religo)) -(rule (targets match.ast) (action (with-stdout-to match.ast (run ligo print-ast match.religo -s reasonligo))) (deps match.religo)) -(rule (targets michelson_pair_tree.ast) (action (with-stdout-to michelson_pair_tree.ast (run ligo print-ast michelson_pair_tree.religo -s reasonligo))) (deps michelson_pair_tree.religo)) -(rule (targets multiple-parameters.ast) (action (with-stdout-to multiple-parameters.ast (run ligo print-ast multiple-parameters.religo -s reasonligo))) (deps multiple-parameters.religo)) -(rule (targets multisig.ast) (action (with-stdout-to multisig.ast (run ligo print-ast multisig.religo -s reasonligo))) (deps multisig.religo)) -(rule (targets no_semicolon.ast) (action (with-stdout-to no_semicolon.ast (run ligo print-ast no_semicolon.religo -s reasonligo))) (deps no_semicolon.religo)) -(rule (targets pledge.ast) (action (with-stdout-to pledge.ast (run ligo print-ast pledge.religo -s reasonligo))) (deps pledge.religo)) -(rule (targets record.ast) (action (with-stdout-to record.ast (run ligo print-ast record.religo -s reasonligo))) (deps record.religo)) -(rule (targets recursion.ast) (action (with-stdout-to recursion.ast (run ligo print-ast recursion.religo -s reasonligo))) (deps recursion.religo)) -(rule (targets self_address.ast) (action (with-stdout-to self_address.ast (run ligo print-ast self_address.religo -s reasonligo))) (deps self_address.religo)) -(rule (targets set_arithmetic.ast) (action (with-stdout-to set_arithmetic.ast (run ligo print-ast set_arithmetic.religo -s reasonligo))) (deps set_arithmetic.religo)) -(rule (targets set_delegate.ast) (action (with-stdout-to set_delegate.ast (run ligo print-ast set_delegate.religo -s reasonligo))) (deps set_delegate.religo)) -(rule (targets single_record_item.ast) (action (with-stdout-to single_record_item.ast (run ligo print-ast single_record_item.religo -s reasonligo))) (deps single_record_item.religo)) -(rule (targets string_arithmetic.ast) (action (with-stdout-to string_arithmetic.ast (run ligo print-ast string_arithmetic.religo -s reasonligo))) (deps string_arithmetic.religo)) -(rule (targets super-counter.ast) (action (with-stdout-to super-counter.ast (run ligo print-ast super-counter.religo -s reasonligo))) (deps super-counter.religo)) -(rule (targets tuple_list.ast) (action (with-stdout-to tuple_list.ast (run ligo print-ast tuple_list.religo -s reasonligo))) (deps tuple_list.religo)) -(rule (targets tuple_param_destruct.ast) (action (with-stdout-to tuple_param_destruct.ast (run ligo print-ast tuple_param_destruct.religo -s reasonligo))) (deps tuple_param_destruct.religo)) -(rule (targets tuple_type.ast) (action (with-stdout-to tuple_type.ast (run ligo print-ast tuple_type.religo -s reasonligo))) (deps tuple_type.religo)) -(rule (targets tuple.ast) (action (with-stdout-to tuple.ast (run ligo print-ast tuple.religo -s reasonligo))) (deps tuple.religo)) -(rule (targets tuples_no_annotation.ast) (action (with-stdout-to tuples_no_annotation.ast (run ligo print-ast tuples_no_annotation.religo -s reasonligo))) (deps tuples_no_annotation.religo)) -(rule (targets tuples_sequences_functions.ast) (action (with-stdout-to tuples_sequences_functions.ast (run ligo print-ast tuples_sequences_functions.religo -s reasonligo))) (deps tuples_sequences_functions.religo)) -(rule (targets variant.ast) (action (with-stdout-to variant.ast (run ligo print-ast variant.religo -s reasonligo))) (deps variant.religo)) -(rule (targets website2.ast) (action (with-stdout-to website2.ast (run ligo print-ast website2.religo -s reasonligo))) (deps website2.religo)) +(alias (name runtest) (action (diff assert.mligo_output assert.mligo_output2)) (deps assert.mligo_output assert.mligo_output2)) +(alias (name runtest) (action (diff address.mligo_output address.mligo_output2)) (deps address.mligo_output address.mligo_output2)) +(alias (name runtest) (action (diff amount_lambda.mligo_output amount_lambda.mligo_output2)) (deps amount_lambda.mligo_output amount_lambda.mligo_output2)) +(alias (name runtest) (action (diff amount.mligo_output amount.mligo_output2)) (deps amount.mligo_output amount.mligo_output2)) +(alias (name runtest) (action (diff arithmetic.mligo_output arithmetic.mligo_output2)) (deps arithmetic.mligo_output arithmetic.mligo_output2)) +(alias (name runtest) (action (diff attributes.mligo_output attributes.mligo_output2)) (deps attributes.mligo_output attributes.mligo_output2)) +(alias (name runtest) (action (diff balance_constant.mligo_output balance_constant.mligo_output2)) (deps balance_constant.mligo_output balance_constant.mligo_output2)) +(alias (name runtest) (action (diff basic.mligo_output basic.mligo_output2)) (deps basic.mligo_output basic.mligo_output2)) +(alias (name runtest) (action (diff big_map.mligo_output big_map.mligo_output2)) (deps big_map.mligo_output big_map.mligo_output2)) +(alias (name runtest) (action (diff bitwise_arithmetic.mligo_output bitwise_arithmetic.mligo_output2)) (deps bitwise_arithmetic.mligo_output bitwise_arithmetic.mligo_output2)) +(alias (name runtest) (action (diff boolean_operators.mligo_output boolean_operators.mligo_output2)) (deps boolean_operators.mligo_output boolean_operators.mligo_output2)) +(alias (name runtest) (action (diff bytes_arithmetic.mligo_output bytes_arithmetic.mligo_output2)) (deps bytes_arithmetic.mligo_output bytes_arithmetic.mligo_output2)) +(alias (name runtest) (action (diff bytes_unpack.mligo_output bytes_unpack.mligo_output2)) (deps bytes_unpack.mligo_output bytes_unpack.mligo_output2)) +(alias (name runtest) (action (diff check_signature.mligo_output check_signature.mligo_output2)) (deps check_signature.mligo_output check_signature.mligo_output2)) +(alias (name runtest) (action (diff closure.mligo_output closure.mligo_output2)) (deps closure.mligo_output closure.mligo_output2)) +(alias (name runtest) (action (diff comparable.mligo_output comparable.mligo_output2)) (deps comparable.mligo_output comparable.mligo_output2)) +(alias (name runtest) (action (diff condition-annot.mligo_output condition-annot.mligo_output2)) (deps condition-annot.mligo_output condition-annot.mligo_output2)) +(alias (name runtest) (action (diff condition-shadowing.mligo_output condition-shadowing.mligo_output2)) (deps condition-shadowing.mligo_output condition-shadowing.mligo_output2)) +(alias (name runtest) (action (diff condition.mligo_output condition.mligo_output2)) (deps condition.mligo_output condition.mligo_output2)) +(alias (name runtest) (action (diff counter.mligo_output counter.mligo_output2)) (deps counter.mligo_output counter.mligo_output2)) +(alias (name runtest) (action (diff create_contract.mligo_output create_contract.mligo_output2)) (deps create_contract.mligo_output create_contract.mligo_output2)) +(alias (name runtest) (action (diff crypto.mligo_output crypto.mligo_output2)) (deps crypto.mligo_output crypto.mligo_output2)) +(alias (name runtest) (action (diff curry.mligo_output curry.mligo_output2)) (deps curry.mligo_output curry.mligo_output2)) +(alias (name runtest) (action (diff double_michelson_or.mligo_output double_michelson_or.mligo_output2)) (deps double_michelson_or.mligo_output double_michelson_or.mligo_output2)) +(alias (name runtest) (action (diff empty_case.mligo_output empty_case.mligo_output2)) (deps empty_case.mligo_output empty_case.mligo_output2)) +(alias (name runtest) (action (diff eq_bool.mligo_output eq_bool.mligo_output2)) (deps eq_bool.mligo_output eq_bool.mligo_output2)) +(alias (name runtest) (action (diff FA1.2.mligo_output FA1.2.mligo_output2)) (deps FA1.2.mligo_output FA1.2.mligo_output2)) +(alias (name runtest) (action (diff failwith.mligo_output failwith.mligo_output2)) (deps failwith.mligo_output failwith.mligo_output2)) +(alias (name runtest) (action (diff fibo.mligo_output fibo.mligo_output2)) (deps fibo.mligo_output fibo.mligo_output2)) +(alias (name runtest) (action (diff fibo2.mligo_output fibo2.mligo_output2)) (deps fibo2.mligo_output fibo2.mligo_output2)) +(alias (name runtest) (action (diff fibo3.mligo_output fibo3.mligo_output2)) (deps fibo3.mligo_output fibo3.mligo_output2)) +(alias (name runtest) (action (diff fibo4.mligo_output fibo4.mligo_output2)) (deps fibo4.mligo_output fibo4.mligo_output2)) +(alias (name runtest) (action (diff function-shared.mligo_output function-shared.mligo_output2)) (deps function-shared.mligo_output function-shared.mligo_output2)) +(alias (name runtest) (action (diff guess_string.mligo_output guess_string.mligo_output2)) (deps guess_string.mligo_output guess_string.mligo_output2)) + +(rule (targets address.religo_ast) (action (with-stdout-to address.religo_ast (run ligo print-ast address.religo -s reasonligo))) (deps address.religo)) +(rule (targets amount.religo_ast) (action (with-stdout-to amount.religo_ast (run ligo print-ast amount.religo -s reasonligo))) (deps amount.religo)) +(rule (targets arithmetic.religo_ast) (action (with-stdout-to arithmetic.religo_ast (run ligo print-ast arithmetic.religo -s reasonligo))) (deps arithmetic.religo)) +(rule (targets balance_constant.religo_ast) (action (with-stdout-to balance_constant.religo_ast (run ligo print-ast balance_constant.religo -s reasonligo))) (deps balance_constant.religo)) +(rule (targets bitwise_arithmetic.religo_ast) (action (with-stdout-to bitwise_arithmetic.religo_ast (run ligo print-ast bitwise_arithmetic.religo -s reasonligo))) (deps bitwise_arithmetic.religo)) +(rule (targets boolean_operators.religo_ast) (action (with-stdout-to boolean_operators.religo_ast (run ligo print-ast boolean_operators.religo -s reasonligo))) (deps boolean_operators.religo)) +(rule (targets bytes_arithmetic.religo_ast) (action (with-stdout-to bytes_arithmetic.religo_ast (run ligo print-ast bytes_arithmetic.religo -s reasonligo))) (deps bytes_arithmetic.religo)) +(rule (targets bytes_unpack.religo_ast) (action (with-stdout-to bytes_unpack.religo_ast (run ligo print-ast bytes_unpack.religo -s reasonligo))) (deps bytes_unpack.religo)) +(rule (targets check_signature.religo_ast) (action (with-stdout-to check_signature.religo_ast (run ligo print-ast check_signature.religo -s reasonligo))) (deps check_signature.religo)) +(rule (targets closure.religo_ast) (action (with-stdout-to closure.religo_ast (run ligo print-ast closure.religo -s reasonligo))) (deps closure.religo)) +(rule (targets condition-shadowing.religo_ast) (action (with-stdout-to condition-shadowing.religo_ast (run ligo print-ast condition-shadowing.religo -s reasonligo))) (deps condition-shadowing.religo)) +(rule (targets condition.religo_ast) (action (with-stdout-to condition.religo_ast (run ligo print-ast condition.religo -s reasonligo))) (deps condition.religo)) +(rule (targets counter.religo_ast) (action (with-stdout-to counter.religo_ast (run ligo print-ast counter.religo -s reasonligo))) (deps counter.religo)) +(rule (targets crypto.religo_ast) (action (with-stdout-to crypto.religo_ast (run ligo print-ast crypto.religo -s reasonligo))) (deps crypto.religo)) +(rule (targets empty_case.religo_ast) (action (with-stdout-to empty_case.religo_ast (run ligo print-ast empty_case.religo -s reasonligo))) (deps empty_case.religo)) +(rule (targets eq_bool.religo_ast) (action (with-stdout-to eq_bool.religo_ast (run ligo print-ast eq_bool.religo -s reasonligo))) (deps eq_bool.religo)) +(rule (targets function-shared.religo_ast) (action (with-stdout-to function-shared.religo_ast (run ligo print-ast function-shared.religo -s reasonligo))) (deps function-shared.religo)) +(rule (targets high-order.religo_ast) (action (with-stdout-to high-order.religo_ast (run ligo print-ast high-order.religo -s reasonligo))) (deps high-order.religo)) +(rule (targets implicit_account.religo_ast) (action (with-stdout-to implicit_account.religo_ast (run ligo print-ast implicit_account.religo -s reasonligo))) (deps implicit_account.religo)) +(rule (targets included.religo_ast) (action (with-stdout-to included.religo_ast (run ligo print-ast included.religo -s reasonligo))) (deps included.religo)) +(rule (targets includer.religo_ast) (action (with-stdout-to includer.religo_ast (run ligo print-ast includer.religo -s reasonligo))) (deps includer.religo)) +(rule (targets key_hash.religo_ast) (action (with-stdout-to key_hash.religo_ast (run ligo print-ast key_hash.religo -s reasonligo))) (deps key_hash.religo)) +(rule (targets lambda.religo_ast) (action (with-stdout-to lambda.religo_ast (run ligo print-ast lambda.religo -s reasonligo))) (deps lambda.religo)) +(rule (targets lambda2.religo_ast) (action (with-stdout-to lambda2.religo_ast (run ligo print-ast lambda2.religo -s reasonligo))) (deps lambda2.religo)) +(rule (targets let_multiple.religo_ast) (action (with-stdout-to let_multiple.religo_ast (run ligo print-ast let_multiple.religo -s reasonligo))) (deps let_multiple.religo)) +(rule (targets letin.religo_ast) (action (with-stdout-to letin.religo_ast (run ligo print-ast letin.religo -s reasonligo))) (deps letin.religo)) +(rule (targets list.religo_ast) (action (with-stdout-to list.religo_ast (run ligo print-ast list.religo -s reasonligo))) (deps list.religo)) +(rule (targets loop.religo_ast) (action (with-stdout-to loop.religo_ast (run ligo print-ast loop.religo -s reasonligo))) (deps loop.religo)) +(rule (targets map.religo_ast) (action (with-stdout-to map.religo_ast (run ligo print-ast map.religo -s reasonligo))) (deps map.religo)) +(rule (targets match_bis.religo_ast) (action (with-stdout-to match_bis.religo_ast (run ligo print-ast match_bis.religo -s reasonligo))) (deps match_bis.religo)) +(rule (targets match.religo_ast) (action (with-stdout-to match.religo_ast (run ligo print-ast match.religo -s reasonligo))) (deps match.religo)) +(rule (targets michelson_pair_tree.religo_ast) (action (with-stdout-to michelson_pair_tree.religo_ast (run ligo print-ast michelson_pair_tree.religo -s reasonligo))) (deps michelson_pair_tree.religo)) +(rule (targets multiple-parameters.religo_ast) (action (with-stdout-to multiple-parameters.religo_ast (run ligo print-ast multiple-parameters.religo -s reasonligo))) (deps multiple-parameters.religo)) +(rule (targets multisig.religo_ast) (action (with-stdout-to multisig.religo_ast (run ligo print-ast multisig.religo -s reasonligo))) (deps multisig.religo)) +(rule (targets no_semicolon.religo_ast) (action (with-stdout-to no_semicolon.religo_ast (run ligo print-ast no_semicolon.religo -s reasonligo))) (deps no_semicolon.religo)) +(rule (targets pledge.religo_ast) (action (with-stdout-to pledge.religo_ast (run ligo print-ast pledge.religo -s reasonligo))) (deps pledge.religo)) +(rule (targets record.religo_ast) (action (with-stdout-to record.religo_ast (run ligo print-ast record.religo -s reasonligo))) (deps record.religo)) +(rule (targets recursion.religo_ast) (action (with-stdout-to recursion.religo_ast (run ligo print-ast recursion.religo -s reasonligo))) (deps recursion.religo)) +(rule (targets self_address.religo_ast) (action (with-stdout-to self_address.religo_ast (run ligo print-ast self_address.religo -s reasonligo))) (deps self_address.religo)) +(rule (targets set_arithmetic.religo_ast) (action (with-stdout-to set_arithmetic.religo_ast (run ligo print-ast set_arithmetic.religo -s reasonligo))) (deps set_arithmetic.religo)) +(rule (targets set_delegate.religo_ast) (action (with-stdout-to set_delegate.religo_ast (run ligo print-ast set_delegate.religo -s reasonligo))) (deps set_delegate.religo)) +(rule (targets single_record_item.religo_ast) (action (with-stdout-to single_record_item.religo_ast (run ligo print-ast single_record_item.religo -s reasonligo))) (deps single_record_item.religo)) +(rule (targets string_arithmetic.religo_ast) (action (with-stdout-to string_arithmetic.religo_ast (run ligo print-ast string_arithmetic.religo -s reasonligo))) (deps string_arithmetic.religo)) +(rule (targets super-counter.religo_ast) (action (with-stdout-to super-counter.religo_ast (run ligo print-ast super-counter.religo -s reasonligo))) (deps super-counter.religo)) +(rule (targets tuple_list.religo_ast) (action (with-stdout-to tuple_list.religo_ast (run ligo print-ast tuple_list.religo -s reasonligo))) (deps tuple_list.religo)) +(rule (targets tuple_param_destruct.religo_ast) (action (with-stdout-to tuple_param_destruct.religo_ast (run ligo print-ast tuple_param_destruct.religo -s reasonligo))) (deps tuple_param_destruct.religo)) +(rule (targets tuple_type.religo_ast) (action (with-stdout-to tuple_type.religo_ast (run ligo print-ast tuple_type.religo -s reasonligo))) (deps tuple_type.religo)) +(rule (targets tuple.religo_ast) (action (with-stdout-to tuple.religo_ast (run ligo print-ast tuple.religo -s reasonligo))) (deps tuple.religo)) +(rule (targets tuples_no_annotation.religo_ast) (action (with-stdout-to tuples_no_annotation.religo_ast (run ligo print-ast tuples_no_annotation.religo -s reasonligo))) (deps tuples_no_annotation.religo)) +(rule (targets tuples_sequences_functions.religo_ast) (action (with-stdout-to tuples_sequences_functions.religo_ast (run ligo print-ast tuples_sequences_functions.religo -s reasonligo))) (deps tuples_sequences_functions.religo)) +(rule (targets variant.religo_ast) (action (with-stdout-to variant.religo_ast (run ligo print-ast variant.religo -s reasonligo))) (deps variant.religo)) +(rule (targets website2.religo_ast) (action (with-stdout-to website2.religo_ast (run ligo print-ast website2.religo -s reasonligo))) (deps website2.religo)) + +(rule (targets assert.mligo_ast) (action (with-stdout-to assert.mligo_ast (run ligo print-ast assert.mligo -s cameligo))) (deps assert.mligo)) +(rule (targets address.mligo_ast) (action (with-stdout-to address.mligo_ast (run ligo print-ast address.mligo -s cameligo))) (deps address.mligo)) +(rule (targets amount_lambda.mligo_ast) (action (with-stdout-to amount_lambda.mligo_ast (run ligo print-ast amount_lambda.mligo -s cameligo))) (deps amount_lambda.mligo)) +(rule (targets amount.mligo_ast) (action (with-stdout-to amount.mligo_ast (run ligo print-ast amount.mligo -s cameligo))) (deps amount.mligo)) +(rule (targets arithmetic.mligo_ast) (action (with-stdout-to arithmetic.mligo_ast (run ligo print-ast arithmetic.mligo -s cameligo))) (deps arithmetic.mligo)) +(rule (targets attributes.mligo_ast) (action (with-stdout-to attributes.mligo_ast (run ligo print-ast attributes.mligo -s cameligo))) (deps attributes.mligo)) +(rule (targets balance_constant.mligo_ast) (action (with-stdout-to balance_constant.mligo_ast (run ligo print-ast balance_constant.mligo -s cameligo))) (deps balance_constant.mligo)) +(rule (targets basic.mligo_ast) (action (with-stdout-to basic.mligo_ast (run ligo print-ast basic.mligo -s cameligo))) (deps basic.mligo)) +(rule (targets big_map.mligo_ast) (action (with-stdout-to big_map.mligo_ast (run ligo print-ast big_map.mligo -s cameligo))) (deps big_map.mligo)) +(rule (targets bitwise_arithmetic.mligo_ast) (action (with-stdout-to bitwise_arithmetic.mligo_ast (run ligo print-ast bitwise_arithmetic.mligo -s cameligo))) (deps bitwise_arithmetic.mligo)) +(rule (targets boolean_operators.mligo_ast) (action (with-stdout-to boolean_operators.mligo_ast (run ligo print-ast boolean_operators.mligo -s cameligo))) (deps boolean_operators.mligo)) +(rule (targets bytes_arithmetic.mligo_ast) (action (with-stdout-to bytes_arithmetic.mligo_ast (run ligo print-ast bytes_arithmetic.mligo -s cameligo))) (deps bytes_arithmetic.mligo)) +(rule (targets bytes_unpack.mligo_ast) (action (with-stdout-to bytes_unpack.mligo_ast (run ligo print-ast bytes_unpack.mligo -s cameligo))) (deps bytes_unpack.mligo)) +(rule (targets check_signature.mligo_ast) (action (with-stdout-to check_signature.mligo_ast (run ligo print-ast check_signature.mligo -s cameligo))) (deps check_signature.mligo)) +(rule (targets closure.mligo_ast) (action (with-stdout-to closure.mligo_ast (run ligo print-ast closure.mligo -s cameligo))) (deps closure.mligo)) +(rule (targets comparable.mligo_ast) (action (with-stdout-to comparable.mligo_ast (run ligo print-ast comparable.mligo -s cameligo))) (deps comparable.mligo)) +(rule (targets condition-annot.mligo_ast) (action (with-stdout-to condition-annot.mligo_ast (run ligo print-ast condition-annot.mligo -s cameligo))) (deps condition-annot.mligo)) +(rule (targets condition-shadowing.mligo_ast) (action (with-stdout-to condition-shadowing.mligo_ast (run ligo print-ast condition-shadowing.mligo -s cameligo))) (deps condition-shadowing.mligo)) +(rule (targets condition.mligo_ast) (action (with-stdout-to condition.mligo_ast (run ligo print-ast condition.mligo -s cameligo))) (deps condition.mligo)) +(rule (targets counter.mligo_ast) (action (with-stdout-to counter.mligo_ast (run ligo print-ast counter.mligo -s cameligo))) (deps counter.mligo)) +(rule (targets create_contract.mligo_ast) (action (with-stdout-to create_contract.mligo_ast (run ligo print-ast create_contract.mligo -s cameligo))) (deps create_contract.mligo)) +(rule (targets crypto.mligo_ast) (action (with-stdout-to crypto.mligo_ast (run ligo print-ast crypto.mligo -s cameligo))) (deps crypto.mligo)) +(rule (targets curry.mligo_ast) (action (with-stdout-to curry.mligo_ast (run ligo print-ast curry.mligo -s cameligo))) (deps curry.mligo)) +(rule (targets double_michelson_or.mligo_ast) (action (with-stdout-to double_michelson_or.mligo_ast (run ligo print-ast double_michelson_or.mligo -s cameligo))) (deps double_michelson_or.mligo)) +(rule (targets empty_case.mligo_ast) (action (with-stdout-to empty_case.mligo_ast (run ligo print-ast empty_case.mligo -s cameligo))) (deps empty_case.mligo)) +(rule (targets eq_bool.mligo_ast) (action (with-stdout-to eq_bool.mligo_ast (run ligo print-ast eq_bool.mligo -s cameligo))) (deps eq_bool.mligo)) +(rule (targets FA1.2.mligo_ast) (action (with-stdout-to FA1.2.mligo_ast (run ligo print-ast FA1.2.mligo -s cameligo))) (deps FA1.2.mligo)) +(rule (targets failwith.mligo_ast) (action (with-stdout-to failwith.mligo_ast (run ligo print-ast failwith.mligo -s cameligo))) (deps failwith.mligo)) +(rule (targets fibo.mligo_ast) (action (with-stdout-to fibo.mligo_ast (run ligo print-ast fibo.mligo -s cameligo))) (deps fibo.mligo)) +(rule (targets fibo2.mligo_ast) (action (with-stdout-to fibo2.mligo_ast (run ligo print-ast fibo2.mligo -s cameligo))) (deps fibo2.mligo)) +(rule (targets fibo3.mligo_ast) (action (with-stdout-to fibo3.mligo_ast (run ligo print-ast fibo3.mligo -s cameligo))) (deps fibo3.mligo)) +(rule (targets fibo4.mligo_ast) (action (with-stdout-to fibo4.mligo_ast (run ligo print-ast fibo4.mligo -s cameligo))) (deps fibo4.mligo)) +(rule (targets function-shared.mligo_ast) (action (with-stdout-to function-shared.mligo_ast (run ligo print-ast function-shared.mligo -s cameligo))) (deps function-shared.mligo)) +(rule (targets guess_string.mligo_ast) (action (with-stdout-to guess_string.mligo_ast (run ligo print-ast guess_string.mligo -s cameligo))) (deps guess_string.mligo)) -(rule (targets address.ast_pretty) (action (with-stdout-to address.ast_pretty (run ligo print-ast address.output -s reasonligo))) (deps address.output)) -(rule (targets amount.ast_pretty) (action (with-stdout-to amount.ast_pretty (run ligo print-ast amount.output -s reasonligo))) (deps amount.output)) -(rule (targets arithmetic.ast_pretty) (action (with-stdout-to arithmetic.ast_pretty (run ligo print-ast arithmetic.output -s reasonligo))) (deps arithmetic.output)) -(rule (targets balance_constant.ast_pretty) (action (with-stdout-to balance_constant.ast_pretty (run ligo print-ast balance_constant.output -s reasonligo))) (deps balance_constant.output)) -(rule (targets bitwise_arithmetic.ast_pretty) (action (with-stdout-to bitwise_arithmetic.ast_pretty (run ligo print-ast bitwise_arithmetic.output -s reasonligo))) (deps bitwise_arithmetic.output)) -(rule (targets boolean_operators.ast_pretty) (action (with-stdout-to boolean_operators.ast_pretty (run ligo print-ast boolean_operators.output -s reasonligo))) (deps boolean_operators.output)) -(rule (targets bytes_arithmetic.ast_pretty) (action (with-stdout-to bytes_arithmetic.ast_pretty (run ligo print-ast bytes_arithmetic.output -s reasonligo))) (deps bytes_arithmetic.output)) -(rule (targets bytes_unpack.ast_pretty) (action (with-stdout-to bytes_unpack.ast_pretty (run ligo print-ast bytes_unpack.output -s reasonligo))) (deps bytes_unpack.output)) -(rule (targets check_signature.ast_pretty) (action (with-stdout-to check_signature.ast_pretty (run ligo print-ast check_signature.output -s reasonligo))) (deps check_signature.output)) -(rule (targets closure.ast_pretty) (action (with-stdout-to closure.ast_pretty (run ligo print-ast closure.output -s reasonligo))) (deps closure.output)) -(rule (targets condition-shadowing.ast_pretty) (action (with-stdout-to condition-shadowing.ast_pretty (run ligo print-ast condition-shadowing.output -s reasonligo))) (deps condition-shadowing.output)) -(rule (targets condition.ast_pretty) (action (with-stdout-to condition.ast_pretty (run ligo print-ast condition.output -s reasonligo))) (deps condition.output)) -(rule (targets counter.ast_pretty) (action (with-stdout-to counter.ast_pretty (run ligo print-ast counter.output -s reasonligo))) (deps counter.output)) -(rule (targets crypto.ast_pretty) (action (with-stdout-to crypto.ast_pretty (run ligo print-ast crypto.output -s reasonligo))) (deps crypto.output)) -(rule (targets empty_case.ast_pretty) (action (with-stdout-to empty_case.ast_pretty (run ligo print-ast empty_case.output -s reasonligo))) (deps empty_case.output)) -(rule (targets eq_bool.ast_pretty) (action (with-stdout-to eq_bool.ast_pretty (run ligo print-ast eq_bool.output -s reasonligo))) (deps eq_bool.output)) -(rule (targets function-shared.ast_pretty) (action (with-stdout-to function-shared.ast_pretty (run ligo print-ast function-shared.output -s reasonligo))) (deps function-shared.output)) -(rule (targets high-order.ast_pretty) (action (with-stdout-to high-order.ast_pretty (run ligo print-ast high-order.output -s reasonligo))) (deps high-order.output)) -(rule (targets implicit_account.ast_pretty) (action (with-stdout-to implicit_account.ast_pretty (run ligo print-ast implicit_account.output -s reasonligo))) (deps implicit_account.output)) -(rule (targets included.ast_pretty) (action (with-stdout-to included.ast_pretty (run ligo print-ast included.output -s reasonligo))) (deps included.output)) -(rule (targets includer.ast_pretty) (action (with-stdout-to includer.ast_pretty (run ligo print-ast includer.output -s reasonligo))) (deps includer.output)) -(rule (targets key_hash.ast_pretty) (action (with-stdout-to key_hash.ast_pretty (run ligo print-ast key_hash.output -s reasonligo))) (deps key_hash.output)) -(rule (targets lambda.ast_pretty) (action (with-stdout-to lambda.ast_pretty (run ligo print-ast lambda.output -s reasonligo))) (deps lambda.output)) -(rule (targets lambda2.ast_pretty) (action (with-stdout-to lambda2.ast_pretty (run ligo print-ast lambda2.output -s reasonligo))) (deps lambda2.output)) -(rule (targets let_multiple.ast_pretty) (action (with-stdout-to let_multiple.ast_pretty (run ligo print-ast let_multiple.output -s reasonligo))) (deps let_multiple.output)) -(rule (targets letin.ast_pretty) (action (with-stdout-to letin.ast_pretty (run ligo print-ast letin.output -s reasonligo))) (deps letin.output)) -(rule (targets list.ast_pretty) (action (with-stdout-to list.ast_pretty (run ligo print-ast list.output -s reasonligo))) (deps list.output)) -(rule (targets loop.ast_pretty) (action (with-stdout-to loop.ast_pretty (run ligo print-ast loop.output -s reasonligo))) (deps loop.output)) -(rule (targets map.ast_pretty) (action (with-stdout-to map.ast_pretty (run ligo print-ast map.output -s reasonligo))) (deps map.output)) -(rule (targets match_bis.ast_pretty) (action (with-stdout-to match_bis.ast_pretty (run ligo print-ast match_bis.output -s reasonligo))) (deps match_bis.output)) -(rule (targets match.ast_pretty) (action (with-stdout-to match.ast_pretty (run ligo print-ast match.output -s reasonligo))) (deps match.output)) -(rule (targets michelson_pair_tree.ast_pretty) (action (with-stdout-to michelson_pair_tree.ast_pretty (run ligo print-ast michelson_pair_tree.output -s reasonligo))) (deps michelson_pair_tree.output)) -(rule (targets multiple-parameters.ast_pretty) (action (with-stdout-to multiple-parameters.ast_pretty (run ligo print-ast multiple-parameters.output -s reasonligo))) (deps multiple-parameters.output)) -(rule (targets multisig.ast_pretty) (action (with-stdout-to multisig.ast_pretty (run ligo print-ast multisig.output -s reasonligo))) (deps multisig.output)) -(rule (targets no_semicolon.ast_pretty) (action (with-stdout-to no_semicolon.ast_pretty (run ligo print-ast no_semicolon.output -s reasonligo))) (deps no_semicolon.output)) -(rule (targets pledge.ast_pretty) (action (with-stdout-to pledge.ast_pretty (run ligo print-ast pledge.output -s reasonligo))) (deps pledge.output)) -(rule (targets record.ast_pretty) (action (with-stdout-to record.ast_pretty (run ligo print-ast record.output -s reasonligo))) (deps record.output)) -(rule (targets recursion.ast_pretty) (action (with-stdout-to recursion.ast_pretty (run ligo print-ast recursion.output -s reasonligo))) (deps recursion.output)) -(rule (targets self_address.ast_pretty) (action (with-stdout-to self_address.ast_pretty (run ligo print-ast self_address.output -s reasonligo))) (deps self_address.output)) -(rule (targets set_arithmetic.ast_pretty) (action (with-stdout-to set_arithmetic.ast_pretty (run ligo print-ast set_arithmetic.output -s reasonligo))) (deps set_arithmetic.output)) -(rule (targets set_delegate.ast_pretty) (action (with-stdout-to set_delegate.ast_pretty (run ligo print-ast set_delegate.output -s reasonligo))) (deps set_delegate.output)) -(rule (targets single_record_item.ast_pretty) (action (with-stdout-to single_record_item.ast_pretty (run ligo print-ast single_record_item.output -s reasonligo))) (deps single_record_item.output)) -(rule (targets string_arithmetic.ast_pretty) (action (with-stdout-to string_arithmetic.ast_pretty (run ligo print-ast string_arithmetic.output -s reasonligo))) (deps string_arithmetic.output)) -(rule (targets super-counter.ast_pretty) (action (with-stdout-to super-counter.ast_pretty (run ligo print-ast super-counter.output -s reasonligo))) (deps super-counter.output)) -(rule (targets tuple_list.ast_pretty) (action (with-stdout-to tuple_list.ast_pretty (run ligo print-ast tuple_list.output -s reasonligo))) (deps tuple_list.output)) -(rule (targets tuple_param_destruct.ast_pretty) (action (with-stdout-to tuple_param_destruct.ast_pretty (run ligo print-ast tuple_param_destruct.output -s reasonligo))) (deps tuple_param_destruct.output)) -(rule (targets tuple_type.ast_pretty) (action (with-stdout-to tuple_type.ast_pretty (run ligo print-ast tuple_type.output -s reasonligo))) (deps tuple_type.output)) -(rule (targets tuple.ast_pretty) (action (with-stdout-to tuple.ast_pretty (run ligo print-ast tuple.output -s reasonligo))) (deps tuple.output)) -(rule (targets tuples_no_annotation.ast_pretty) (action (with-stdout-to tuples_no_annotation.ast_pretty (run ligo print-ast tuples_no_annotation.output -s reasonligo))) (deps tuples_no_annotation.output)) -(rule (targets tuples_sequences_functions.ast_pretty) (action (with-stdout-to tuples_sequences_functions.ast_pretty (run ligo print-ast tuples_sequences_functions.output -s reasonligo))) (deps tuples_sequences_functions.output)) -(rule (targets variant.ast_pretty) (action (with-stdout-to variant.ast_pretty (run ligo print-ast variant.output -s reasonligo))) (deps variant.output)) -(rule (targets website2.ast_pretty) (action (with-stdout-to website2.ast_pretty (run ligo print-ast website2.output -s reasonligo))) (deps website2.output)) +(rule (targets address.religo_ast_pretty) (action (with-stdout-to address.religo_ast_pretty (run ligo print-ast address.religo_output -s reasonligo))) (deps address.religo_output)) +(rule (targets amount.religo_ast_pretty) (action (with-stdout-to amount.religo_ast_pretty (run ligo print-ast amount.religo_output -s reasonligo))) (deps amount.religo_output)) +(rule (targets arithmetic.religo_ast_pretty) (action (with-stdout-to arithmetic.religo_ast_pretty (run ligo print-ast arithmetic.religo_output -s reasonligo))) (deps arithmetic.religo_output)) +(rule (targets balance_constant.religo_ast_pretty) (action (with-stdout-to balance_constant.religo_ast_pretty (run ligo print-ast balance_constant.religo_output -s reasonligo))) (deps balance_constant.religo_output)) +(rule (targets bitwise_arithmetic.religo_ast_pretty) (action (with-stdout-to bitwise_arithmetic.religo_ast_pretty (run ligo print-ast bitwise_arithmetic.religo_output -s reasonligo))) (deps bitwise_arithmetic.religo_output)) +(rule (targets boolean_operators.religo_ast_pretty) (action (with-stdout-to boolean_operators.religo_ast_pretty (run ligo print-ast boolean_operators.religo_output -s reasonligo))) (deps boolean_operators.religo_output)) +(rule (targets bytes_arithmetic.religo_ast_pretty) (action (with-stdout-to bytes_arithmetic.religo_ast_pretty (run ligo print-ast bytes_arithmetic.religo_output -s reasonligo))) (deps bytes_arithmetic.religo_output)) +(rule (targets bytes_unpack.religo_ast_pretty) (action (with-stdout-to bytes_unpack.religo_ast_pretty (run ligo print-ast bytes_unpack.religo_output -s reasonligo))) (deps bytes_unpack.religo_output)) +(rule (targets check_signature.religo_ast_pretty) (action (with-stdout-to check_signature.religo_ast_pretty (run ligo print-ast check_signature.religo_output -s reasonligo))) (deps check_signature.religo_output)) +(rule (targets closure.religo_ast_pretty) (action (with-stdout-to closure.religo_ast_pretty (run ligo print-ast closure.religo_output -s reasonligo))) (deps closure.religo_output)) +(rule (targets condition-shadowing.religo_ast_pretty) (action (with-stdout-to condition-shadowing.religo_ast_pretty (run ligo print-ast condition-shadowing.religo_output -s reasonligo))) (deps condition-shadowing.religo_output)) +(rule (targets condition.religo_ast_pretty) (action (with-stdout-to condition.religo_ast_pretty (run ligo print-ast condition.religo_output -s reasonligo))) (deps condition.religo_output)) +(rule (targets counter.religo_ast_pretty) (action (with-stdout-to counter.religo_ast_pretty (run ligo print-ast counter.religo_output -s reasonligo))) (deps counter.religo_output)) +(rule (targets crypto.religo_ast_pretty) (action (with-stdout-to crypto.religo_ast_pretty (run ligo print-ast crypto.religo_output -s reasonligo))) (deps crypto.religo_output)) +(rule (targets empty_case.religo_ast_pretty) (action (with-stdout-to empty_case.religo_ast_pretty (run ligo print-ast empty_case.religo_output -s reasonligo))) (deps empty_case.religo_output)) +(rule (targets eq_bool.religo_ast_pretty) (action (with-stdout-to eq_bool.religo_ast_pretty (run ligo print-ast eq_bool.religo_output -s reasonligo))) (deps eq_bool.religo_output)) +(rule (targets function-shared.religo_ast_pretty) (action (with-stdout-to function-shared.religo_ast_pretty (run ligo print-ast function-shared.religo_output -s reasonligo))) (deps function-shared.religo_output)) +(rule (targets high-order.religo_ast_pretty) (action (with-stdout-to high-order.religo_ast_pretty (run ligo print-ast high-order.religo_output -s reasonligo))) (deps high-order.religo_output)) +(rule (targets implicit_account.religo_ast_pretty) (action (with-stdout-to implicit_account.religo_ast_pretty (run ligo print-ast implicit_account.religo_output -s reasonligo))) (deps implicit_account.religo_output)) +(rule (targets included.religo_ast_pretty) (action (with-stdout-to included.religo_ast_pretty (run ligo print-ast included.religo_output -s reasonligo))) (deps included.religo_output)) +(rule (targets includer.religo_ast_pretty) (action (with-stdout-to includer.religo_ast_pretty (run ligo print-ast includer.religo_output -s reasonligo))) (deps includer.religo_output)) +(rule (targets key_hash.religo_ast_pretty) (action (with-stdout-to key_hash.religo_ast_pretty (run ligo print-ast key_hash.religo_output -s reasonligo))) (deps key_hash.religo_output)) +(rule (targets lambda.religo_ast_pretty) (action (with-stdout-to lambda.religo_ast_pretty (run ligo print-ast lambda.religo_output -s reasonligo))) (deps lambda.religo_output)) +(rule (targets lambda2.religo_ast_pretty) (action (with-stdout-to lambda2.religo_ast_pretty (run ligo print-ast lambda2.religo_output -s reasonligo))) (deps lambda2.religo_output)) +(rule (targets let_multiple.religo_ast_pretty) (action (with-stdout-to let_multiple.religo_ast_pretty (run ligo print-ast let_multiple.religo_output -s reasonligo))) (deps let_multiple.religo_output)) +(rule (targets letin.religo_ast_pretty) (action (with-stdout-to letin.religo_ast_pretty (run ligo print-ast letin.religo_output -s reasonligo))) (deps letin.religo_output)) +(rule (targets list.religo_ast_pretty) (action (with-stdout-to list.religo_ast_pretty (run ligo print-ast list.religo_output -s reasonligo))) (deps list.religo_output)) +(rule (targets loop.religo_ast_pretty) (action (with-stdout-to loop.religo_ast_pretty (run ligo print-ast loop.religo_output -s reasonligo))) (deps loop.religo_output)) +(rule (targets map.religo_ast_pretty) (action (with-stdout-to map.religo_ast_pretty (run ligo print-ast map.religo_output -s reasonligo))) (deps map.religo_output)) +(rule (targets match_bis.religo_ast_pretty) (action (with-stdout-to match_bis.religo_ast_pretty (run ligo print-ast match_bis.religo_output -s reasonligo))) (deps match_bis.religo_output)) +(rule (targets match.religo_ast_pretty) (action (with-stdout-to match.religo_ast_pretty (run ligo print-ast match.religo_output -s reasonligo))) (deps match.religo_output)) +(rule (targets michelson_pair_tree.religo_ast_pretty) (action (with-stdout-to michelson_pair_tree.religo_ast_pretty (run ligo print-ast michelson_pair_tree.religo_output -s reasonligo))) (deps michelson_pair_tree.religo_output)) +(rule (targets multiple-parameters.religo_ast_pretty) (action (with-stdout-to multiple-parameters.religo_ast_pretty (run ligo print-ast multiple-parameters.religo_output -s reasonligo))) (deps multiple-parameters.religo_output)) +(rule (targets multisig.religo_ast_pretty) (action (with-stdout-to multisig.religo_ast_pretty (run ligo print-ast multisig.religo_output -s reasonligo))) (deps multisig.religo_output)) +(rule (targets no_semicolon.religo_ast_pretty) (action (with-stdout-to no_semicolon.religo_ast_pretty (run ligo print-ast no_semicolon.religo_output -s reasonligo))) (deps no_semicolon.religo_output)) +(rule (targets pledge.religo_ast_pretty) (action (with-stdout-to pledge.religo_ast_pretty (run ligo print-ast pledge.religo_output -s reasonligo))) (deps pledge.religo_output)) +(rule (targets record.religo_ast_pretty) (action (with-stdout-to record.religo_ast_pretty (run ligo print-ast record.religo_output -s reasonligo))) (deps record.religo_output)) +(rule (targets recursion.religo_ast_pretty) (action (with-stdout-to recursion.religo_ast_pretty (run ligo print-ast recursion.religo_output -s reasonligo))) (deps recursion.religo_output)) +(rule (targets self_address.religo_ast_pretty) (action (with-stdout-to self_address.religo_ast_pretty (run ligo print-ast self_address.religo_output -s reasonligo))) (deps self_address.religo_output)) +(rule (targets set_arithmetic.religo_ast_pretty) (action (with-stdout-to set_arithmetic.religo_ast_pretty (run ligo print-ast set_arithmetic.religo_output -s reasonligo))) (deps set_arithmetic.religo_output)) +(rule (targets set_delegate.religo_ast_pretty) (action (with-stdout-to set_delegate.religo_ast_pretty (run ligo print-ast set_delegate.religo_output -s reasonligo))) (deps set_delegate.religo_output)) +(rule (targets single_record_item.religo_ast_pretty) (action (with-stdout-to single_record_item.religo_ast_pretty (run ligo print-ast single_record_item.religo_output -s reasonligo))) (deps single_record_item.religo_output)) +(rule (targets string_arithmetic.religo_ast_pretty) (action (with-stdout-to string_arithmetic.religo_ast_pretty (run ligo print-ast string_arithmetic.religo_output -s reasonligo))) (deps string_arithmetic.religo_output)) +(rule (targets super-counter.religo_ast_pretty) (action (with-stdout-to super-counter.religo_ast_pretty (run ligo print-ast super-counter.religo_output -s reasonligo))) (deps super-counter.religo_output)) +(rule (targets tuple_list.religo_ast_pretty) (action (with-stdout-to tuple_list.religo_ast_pretty (run ligo print-ast tuple_list.religo_output -s reasonligo))) (deps tuple_list.religo_output)) +(rule (targets tuple_param_destruct.religo_ast_pretty) (action (with-stdout-to tuple_param_destruct.religo_ast_pretty (run ligo print-ast tuple_param_destruct.religo_output -s reasonligo))) (deps tuple_param_destruct.religo_output)) +(rule (targets tuple_type.religo_ast_pretty) (action (with-stdout-to tuple_type.religo_ast_pretty (run ligo print-ast tuple_type.religo_output -s reasonligo))) (deps tuple_type.religo_output)) +(rule (targets tuple.religo_ast_pretty) (action (with-stdout-to tuple.religo_ast_pretty (run ligo print-ast tuple.religo_output -s reasonligo))) (deps tuple.religo_output)) +(rule (targets tuples_no_annotation.religo_ast_pretty) (action (with-stdout-to tuples_no_annotation.religo_ast_pretty (run ligo print-ast tuples_no_annotation.religo_output -s reasonligo))) (deps tuples_no_annotation.religo_output)) +(rule (targets tuples_sequences_functions.religo_ast_pretty) (action (with-stdout-to tuples_sequences_functions.religo_ast_pretty (run ligo print-ast tuples_sequences_functions.religo_output -s reasonligo))) (deps tuples_sequences_functions.religo_output)) +(rule (targets variant.religo_ast_pretty) (action (with-stdout-to variant.religo_ast_pretty (run ligo print-ast variant.religo_output -s reasonligo))) (deps variant.religo_output)) +(rule (targets website2.religo_ast_pretty) (action (with-stdout-to website2.religo_ast_pretty (run ligo print-ast website2.religo_output -s reasonligo))) (deps website2.religo_output)) -(alias (name runtest) (action (diff address.ast address.ast_pretty)) (deps address.ast address.ast_pretty)) -(alias (name runtest) (action (diff amount.ast amount.ast_pretty)) (deps amount.ast amount.ast_pretty)) -(alias (name runtest) (action (diff arithmetic.ast arithmetic.ast_pretty)) (deps arithmetic.ast arithmetic.ast_pretty)) -(alias (name runtest) (action (diff balance_constant.ast balance_constant.ast_pretty)) (deps balance_constant.ast balance_constant.ast_pretty)) -(alias (name runtest) (action (diff bitwise_arithmetic.ast bitwise_arithmetic.ast_pretty)) (deps bitwise_arithmetic.ast bitwise_arithmetic.ast_pretty)) -(alias (name runtest) (action (diff boolean_operators.ast boolean_operators.ast_pretty)) (deps boolean_operators.ast boolean_operators.ast_pretty)) -(alias (name runtest) (action (diff bytes_arithmetic.ast bytes_arithmetic.ast_pretty)) (deps bytes_arithmetic.ast bytes_arithmetic.ast_pretty)) -(alias (name runtest) (action (diff bytes_unpack.ast bytes_unpack.ast_pretty)) (deps bytes_unpack.ast bytes_unpack.ast_pretty)) -(alias (name runtest) (action (diff check_signature.ast check_signature.ast_pretty)) (deps check_signature.ast check_signature.ast_pretty)) -(alias (name runtest) (action (diff closure.ast closure.ast_pretty)) (deps closure.ast closure.ast_pretty)) -(alias (name runtest) (action (diff condition-shadowing.ast condition-shadowing.ast_pretty)) (deps condition-shadowing.ast condition-shadowing.ast_pretty)) -(alias (name runtest) (action (diff condition.ast condition.ast_pretty)) (deps condition.ast condition.ast_pretty)) -(alias (name runtest) (action (diff counter.ast counter.ast_pretty)) (deps counter.ast counter.ast_pretty)) -(alias (name runtest) (action (diff crypto.ast crypto.ast_pretty)) (deps crypto.ast crypto.ast_pretty)) -(alias (name runtest) (action (diff empty_case.ast empty_case.ast_pretty)) (deps empty_case.ast empty_case.ast_pretty)) -(alias (name runtest) (action (diff eq_bool.ast eq_bool.ast_pretty)) (deps eq_bool.ast eq_bool.ast_pretty)) -(alias (name runtest) (action (diff function-shared.ast function-shared.ast_pretty)) (deps function-shared.ast function-shared.ast_pretty)) -(alias (name runtest) (action (diff high-order.ast high-order.ast_pretty)) (deps high-order.ast high-order.ast_pretty)) -(alias (name runtest) (action (diff implicit_account.ast implicit_account.ast_pretty)) (deps implicit_account.ast implicit_account.ast_pretty)) -(alias (name runtest) (action (diff included.ast included.ast_pretty)) (deps included.ast included.ast_pretty)) -(alias (name runtest) (action (diff includer.ast includer.ast_pretty)) (deps includer.ast includer.ast_pretty)) -(alias (name runtest) (action (diff key_hash.ast key_hash.ast_pretty)) (deps key_hash.ast key_hash.ast_pretty)) -(alias (name runtest) (action (diff lambda.ast lambda.ast_pretty)) (deps lambda.ast lambda.ast_pretty)) -(alias (name runtest) (action (diff lambda2.ast lambda2.ast_pretty)) (deps lambda2.ast lambda2.ast_pretty)) -(alias (name runtest) (action (diff let_multiple.ast let_multiple.ast_pretty)) (deps let_multiple.ast let_multiple.ast_pretty)) -(alias (name runtest) (action (diff letin.ast letin.ast_pretty)) (deps letin.ast letin.ast_pretty)) -(alias (name runtest) (action (diff list.ast list.ast_pretty)) (deps list.ast list.ast_pretty)) -(alias (name runtest) (action (diff loop.ast loop.ast_pretty)) (deps loop.ast loop.ast_pretty)) -(alias (name runtest) (action (diff map.ast map.ast_pretty)) (deps map.ast map.ast_pretty)) -(alias (name runtest) (action (diff match_bis.ast match_bis.ast_pretty)) (deps match_bis.ast match_bis.ast_pretty)) -(alias (name runtest) (action (diff match.ast match.ast_pretty)) (deps match.ast match.ast_pretty)) -(alias (name runtest) (action (diff michelson_pair_tree.ast michelson_pair_tree.ast_pretty)) (deps michelson_pair_tree.ast michelson_pair_tree.ast_pretty)) -(alias (name runtest) (action (diff multiple-parameters.ast multiple-parameters.ast_pretty)) (deps multiple-parameters.ast multiple-parameters.ast_pretty)) -(alias (name runtest) (action (diff multisig.ast multisig.ast_pretty)) (deps multisig.ast multisig.ast_pretty)) -(alias (name runtest) (action (diff no_semicolon.ast no_semicolon.ast_pretty)) (deps no_semicolon.ast no_semicolon.ast_pretty)) -(alias (name runtest) (action (diff pledge.ast pledge.ast_pretty)) (deps pledge.ast pledge.ast_pretty)) -(alias (name runtest) (action (diff record.ast record.ast_pretty)) (deps record.ast record.ast_pretty)) -(alias (name runtest) (action (diff recursion.ast recursion.ast_pretty)) (deps recursion.ast recursion.ast_pretty)) -(alias (name runtest) (action (diff self_address.ast self_address.ast_pretty)) (deps self_address.ast self_address.ast_pretty)) -(alias (name runtest) (action (diff set_arithmetic.ast set_arithmetic.ast_pretty)) (deps set_arithmetic.ast set_arithmetic.ast_pretty)) -(alias (name runtest) (action (diff set_delegate.ast set_delegate.ast_pretty)) (deps set_delegate.ast set_delegate.ast_pretty)) -(alias (name runtest) (action (diff single_record_item.ast single_record_item.ast_pretty)) (deps single_record_item.ast single_record_item.ast_pretty)) -(alias (name runtest) (action (diff string_arithmetic.ast string_arithmetic.ast_pretty)) (deps string_arithmetic.ast string_arithmetic.ast_pretty)) -(alias (name runtest) (action (diff super-counter.ast super-counter.ast_pretty)) (deps super-counter.ast super-counter.ast_pretty)) -(alias (name runtest) (action (diff tuple_list.ast tuple_list.ast_pretty)) (deps tuple_list.ast tuple_list.ast_pretty)) -(alias (name runtest) (action (diff tuple_param_destruct.ast tuple_param_destruct.ast_pretty)) (deps tuple_param_destruct.ast tuple_param_destruct.ast_pretty)) -(alias (name runtest) (action (diff tuple_type.ast tuple_type.ast_pretty)) (deps tuple_type.ast tuple_type.ast_pretty)) -(alias (name runtest) (action (diff tuple.ast tuple.ast_pretty)) (deps tuple.ast tuple.ast_pretty)) -(alias (name runtest) (action (diff tuples_no_annotation.ast tuples_no_annotation.ast_pretty)) (deps tuples_no_annotation.ast tuples_no_annotation.ast_pretty)) -(alias (name runtest) (action (diff tuples_sequences_functions.ast tuples_sequences_functions.ast_pretty)) (deps tuples_sequences_functions.ast tuples_sequences_functions.ast_pretty)) -(alias (name runtest) (action (diff variant.ast variant.ast_pretty)) (deps variant.ast variant.ast_pretty)) -(alias (name runtest) (action (diff website2.ast website2.ast_pretty)) (deps website2.ast website2.ast_pretty)) \ No newline at end of file +(rule (targets assert.mligo_ast_pretty) (action (with-stdout-to assert.mligo_ast_pretty (run ligo print-ast assert.mligo_output -s cameligo))) (deps assert.mligo_output)) +(rule (targets address.mligo_ast_pretty) (action (with-stdout-to address.mligo_ast_pretty (run ligo print-ast address.mligo_output -s cameligo))) (deps address.mligo_output)) +(rule (targets amount_lambda.mligo_ast_pretty) (action (with-stdout-to amount_lambda.mligo_ast_pretty (run ligo print-ast amount_lambda.mligo_output -s cameligo))) (deps amount_lambda.mligo_output)) +(rule (targets amount.mligo_ast_pretty) (action (with-stdout-to amount.mligo_ast_pretty (run ligo print-ast amount.mligo_output -s cameligo))) (deps amount.mligo_output)) +(rule (targets arithmetic.mligo_ast_pretty) (action (with-stdout-to arithmetic.mligo_ast_pretty (run ligo print-ast arithmetic.mligo_output -s cameligo))) (deps arithmetic.mligo_output)) +(rule (targets attributes.mligo_ast_pretty) (action (with-stdout-to attributes.mligo_ast_pretty (run ligo print-ast attributes.mligo_output -s cameligo))) (deps attributes.mligo_output)) +(rule (targets balance_constant.mligo_ast_pretty) (action (with-stdout-to balance_constant.mligo_ast_pretty (run ligo print-ast balance_constant.mligo_output -s cameligo))) (deps balance_constant.mligo_output)) +(rule (targets basic.mligo_ast_pretty) (action (with-stdout-to basic.mligo_ast_pretty (run ligo print-ast basic.mligo_output -s cameligo))) (deps basic.mligo_output)) +(rule (targets big_map.mligo_ast_pretty) (action (with-stdout-to big_map.mligo_ast_pretty (run ligo print-ast big_map.mligo_output -s cameligo))) (deps big_map.mligo_output)) +(rule (targets bitwise_arithmetic.mligo_ast_pretty) (action (with-stdout-to bitwise_arithmetic.mligo_ast_pretty (run ligo print-ast bitwise_arithmetic.mligo_output -s cameligo))) (deps bitwise_arithmetic.mligo_output)) +(rule (targets boolean_operators.mligo_ast_pretty) (action (with-stdout-to boolean_operators.mligo_ast_pretty (run ligo print-ast boolean_operators.mligo_output -s cameligo))) (deps boolean_operators.mligo_output)) +(rule (targets bytes_arithmetic.mligo_ast_pretty) (action (with-stdout-to bytes_arithmetic.mligo_ast_pretty (run ligo print-ast bytes_arithmetic.mligo_output -s cameligo))) (deps bytes_arithmetic.mligo_output)) +(rule (targets bytes_unpack.mligo_ast_pretty) (action (with-stdout-to bytes_unpack.mligo_ast_pretty (run ligo print-ast bytes_unpack.mligo_output -s cameligo))) (deps bytes_unpack.mligo_output)) +(rule (targets check_signature.mligo_ast_pretty) (action (with-stdout-to check_signature.mligo_ast_pretty (run ligo print-ast check_signature.mligo_output -s cameligo))) (deps check_signature.mligo_output)) +(rule (targets closure.mligo_ast_pretty) (action (with-stdout-to closure.mligo_ast_pretty (run ligo print-ast closure.mligo_output -s cameligo))) (deps closure.mligo_output)) +(rule (targets comparable.mligo_ast_pretty) (action (with-stdout-to comparable.mligo_ast_pretty (run ligo print-ast comparable.mligo_output -s cameligo))) (deps comparable.mligo_output)) +(rule (targets condition-annot.mligo_ast_pretty) (action (with-stdout-to condition-annot.mligo_ast_pretty (run ligo print-ast condition-annot.mligo_output -s cameligo))) (deps condition-annot.mligo_output)) +(rule (targets condition-shadowing.mligo_ast_pretty) (action (with-stdout-to condition-shadowing.mligo_ast_pretty (run ligo print-ast condition-shadowing.mligo_output -s cameligo))) (deps condition-shadowing.mligo_output)) +(rule (targets condition.mligo_ast_pretty) (action (with-stdout-to condition.mligo_ast_pretty (run ligo print-ast condition.mligo_output -s cameligo))) (deps condition.mligo_output)) +(rule (targets counter.mligo_ast_pretty) (action (with-stdout-to counter.mligo_ast_pretty (run ligo print-ast counter.mligo_output -s cameligo))) (deps counter.mligo_output)) +(rule (targets create_contract.mligo_ast_pretty) (action (with-stdout-to create_contract.mligo_ast_pretty (run ligo print-ast create_contract.mligo_output -s cameligo))) (deps create_contract.mligo_output)) +(rule (targets crypto.mligo_ast_pretty) (action (with-stdout-to crypto.mligo_ast_pretty (run ligo print-ast crypto.mligo_output -s cameligo))) (deps crypto.mligo_output)) +(rule (targets curry.mligo_ast_pretty) (action (with-stdout-to curry.mligo_ast_pretty (run ligo print-ast curry.mligo_output -s cameligo))) (deps curry.mligo_output)) +(rule (targets double_michelson_or.mligo_ast_pretty) (action (with-stdout-to double_michelson_or.mligo_ast_pretty (run ligo print-ast double_michelson_or.mligo_output -s cameligo))) (deps double_michelson_or.mligo_output)) +(rule (targets empty_case.mligo_ast_pretty) (action (with-stdout-to empty_case.mligo_ast_pretty (run ligo print-ast empty_case.mligo_output -s cameligo))) (deps empty_case.mligo_output)) +(rule (targets eq_bool.mligo_ast_pretty) (action (with-stdout-to eq_bool.mligo_ast_pretty (run ligo print-ast eq_bool.mligo_output -s cameligo))) (deps eq_bool.mligo_output)) +(rule (targets FA1.2.mligo_ast_pretty) (action (with-stdout-to FA1.2.mligo_ast_pretty (run ligo print-ast FA1.2.mligo_output -s cameligo))) (deps FA1.2.mligo_output)) +(rule (targets failwith.mligo_ast_pretty) (action (with-stdout-to failwith.mligo_ast_pretty (run ligo print-ast failwith.mligo_output -s cameligo))) (deps failwith.mligo_output)) +(rule (targets fibo.mligo_ast_pretty) (action (with-stdout-to fibo.mligo_ast_pretty (run ligo print-ast fibo.mligo_output -s cameligo))) (deps fibo.mligo_output)) +(rule (targets fibo2.mligo_ast_pretty) (action (with-stdout-to fibo2.mligo_ast_pretty (run ligo print-ast fibo2.mligo_output -s cameligo))) (deps fibo2.mligo_output)) +(rule (targets fibo3.mligo_ast_pretty) (action (with-stdout-to fibo3.mligo_ast_pretty (run ligo print-ast fibo3.mligo_output -s cameligo))) (deps fibo3.mligo_output)) +(rule (targets fibo4.mligo_ast_pretty) (action (with-stdout-to fibo4.mligo_ast_pretty (run ligo print-ast fibo4.mligo_output -s cameligo))) (deps fibo4.mligo_output)) +(rule (targets function-shared.mligo_ast_pretty) (action (with-stdout-to function-shared.mligo_ast_pretty (run ligo print-ast function-shared.mligo_output -s cameligo))) (deps function-shared.mligo_output)) +(rule (targets guess_string.mligo_ast_pretty) (action (with-stdout-to guess_string.mligo_ast_pretty (run ligo print-ast guess_string.mligo_output -s cameligo))) (deps guess_string.mligo_output)) + +(alias (name runtest) (action (diff address.religo_ast address.religo_ast_pretty)) (deps address.religo_ast address.religo_ast_pretty)) +(alias (name runtest) (action (diff amount.religo_ast amount.religo_ast_pretty)) (deps amount.religo_ast amount.religo_ast_pretty)) +(alias (name runtest) (action (diff arithmetic.religo_ast arithmetic.religo_ast_pretty)) (deps arithmetic.religo_ast arithmetic.religo_ast_pretty)) +(alias (name runtest) (action (diff balance_constant.religo_ast balance_constant.religo_ast_pretty)) (deps balance_constant.religo_ast balance_constant.religo_ast_pretty)) +(alias (name runtest) (action (diff bitwise_arithmetic.religo_ast bitwise_arithmetic.religo_ast_pretty)) (deps bitwise_arithmetic.religo_ast bitwise_arithmetic.religo_ast_pretty)) +(alias (name runtest) (action (diff boolean_operators.religo_ast boolean_operators.religo_ast_pretty)) (deps boolean_operators.religo_ast boolean_operators.religo_ast_pretty)) +(alias (name runtest) (action (diff bytes_arithmetic.religo_ast bytes_arithmetic.religo_ast_pretty)) (deps bytes_arithmetic.religo_ast bytes_arithmetic.religo_ast_pretty)) +(alias (name runtest) (action (diff bytes_unpack.religo_ast bytes_unpack.religo_ast_pretty)) (deps bytes_unpack.religo_ast bytes_unpack.religo_ast_pretty)) +(alias (name runtest) (action (diff check_signature.religo_ast check_signature.religo_ast_pretty)) (deps check_signature.religo_ast check_signature.religo_ast_pretty)) +(alias (name runtest) (action (diff closure.religo_ast closure.religo_ast_pretty)) (deps closure.religo_ast closure.religo_ast_pretty)) +(alias (name runtest) (action (diff condition-shadowing.religo_ast condition-shadowing.religo_ast_pretty)) (deps condition-shadowing.religo_ast condition-shadowing.religo_ast_pretty)) +(alias (name runtest) (action (diff condition.religo_ast condition.religo_ast_pretty)) (deps condition.religo_ast condition.religo_ast_pretty)) +(alias (name runtest) (action (diff counter.religo_ast counter.religo_ast_pretty)) (deps counter.religo_ast counter.religo_ast_pretty)) +(alias (name runtest) (action (diff crypto.religo_ast crypto.religo_ast_pretty)) (deps crypto.religo_ast crypto.religo_ast_pretty)) +(alias (name runtest) (action (diff empty_case.religo_ast empty_case.religo_ast_pretty)) (deps empty_case.religo_ast empty_case.religo_ast_pretty)) +(alias (name runtest) (action (diff eq_bool.religo_ast eq_bool.religo_ast_pretty)) (deps eq_bool.religo_ast eq_bool.religo_ast_pretty)) +(alias (name runtest) (action (diff function-shared.religo_ast function-shared.religo_ast_pretty)) (deps function-shared.religo_ast function-shared.religo_ast_pretty)) +(alias (name runtest) (action (diff high-order.religo_ast high-order.religo_ast_pretty)) (deps high-order.religo_ast high-order.religo_ast_pretty)) +(alias (name runtest) (action (diff implicit_account.religo_ast implicit_account.religo_ast_pretty)) (deps implicit_account.religo_ast implicit_account.religo_ast_pretty)) +(alias (name runtest) (action (diff included.religo_ast included.religo_ast_pretty)) (deps included.religo_ast included.religo_ast_pretty)) +(alias (name runtest) (action (diff includer.religo_ast includer.religo_ast_pretty)) (deps includer.religo_ast includer.religo_ast_pretty)) +(alias (name runtest) (action (diff key_hash.religo_ast key_hash.religo_ast_pretty)) (deps key_hash.religo_ast key_hash.religo_ast_pretty)) +(alias (name runtest) (action (diff lambda.religo_ast lambda.religo_ast_pretty)) (deps lambda.religo_ast lambda.religo_ast_pretty)) +(alias (name runtest) (action (diff lambda2.religo_ast lambda2.religo_ast_pretty)) (deps lambda2.religo_ast lambda2.religo_ast_pretty)) +(alias (name runtest) (action (diff let_multiple.religo_ast let_multiple.religo_ast_pretty)) (deps let_multiple.religo_ast let_multiple.religo_ast_pretty)) +(alias (name runtest) (action (diff letin.religo_ast letin.religo_ast_pretty)) (deps letin.religo_ast letin.religo_ast_pretty)) +(alias (name runtest) (action (diff list.religo_ast list.religo_ast_pretty)) (deps list.religo_ast list.religo_ast_pretty)) +(alias (name runtest) (action (diff loop.religo_ast loop.religo_ast_pretty)) (deps loop.religo_ast loop.religo_ast_pretty)) +(alias (name runtest) (action (diff map.religo_ast map.religo_ast_pretty)) (deps map.religo_ast map.religo_ast_pretty)) +(alias (name runtest) (action (diff match_bis.religo_ast match_bis.religo_ast_pretty)) (deps match_bis.religo_ast match_bis.religo_ast_pretty)) +(alias (name runtest) (action (diff match.religo_ast match.religo_ast_pretty)) (deps match.religo_ast match.religo_ast_pretty)) +(alias (name runtest) (action (diff michelson_pair_tree.religo_ast michelson_pair_tree.religo_ast_pretty)) (deps michelson_pair_tree.religo_ast michelson_pair_tree.religo_ast_pretty)) +(alias (name runtest) (action (diff multiple-parameters.religo_ast multiple-parameters.religo_ast_pretty)) (deps multiple-parameters.religo_ast multiple-parameters.religo_ast_pretty)) +(alias (name runtest) (action (diff multisig.religo_ast multisig.religo_ast_pretty)) (deps multisig.religo_ast multisig.religo_ast_pretty)) +(alias (name runtest) (action (diff no_semicolon.religo_ast no_semicolon.religo_ast_pretty)) (deps no_semicolon.religo_ast no_semicolon.religo_ast_pretty)) +(alias (name runtest) (action (diff pledge.religo_ast pledge.religo_ast_pretty)) (deps pledge.religo_ast pledge.religo_ast_pretty)) +(alias (name runtest) (action (diff record.religo_ast record.religo_ast_pretty)) (deps record.religo_ast record.religo_ast_pretty)) +(alias (name runtest) (action (diff recursion.religo_ast recursion.religo_ast_pretty)) (deps recursion.religo_ast recursion.religo_ast_pretty)) +(alias (name runtest) (action (diff self_address.religo_ast self_address.religo_ast_pretty)) (deps self_address.religo_ast self_address.religo_ast_pretty)) +(alias (name runtest) (action (diff set_arithmetic.religo_ast set_arithmetic.religo_ast_pretty)) (deps set_arithmetic.religo_ast set_arithmetic.religo_ast_pretty)) +(alias (name runtest) (action (diff set_delegate.religo_ast set_delegate.religo_ast_pretty)) (deps set_delegate.religo_ast set_delegate.religo_ast_pretty)) +(alias (name runtest) (action (diff single_record_item.religo_ast single_record_item.religo_ast_pretty)) (deps single_record_item.religo_ast single_record_item.religo_ast_pretty)) +(alias (name runtest) (action (diff string_arithmetic.religo_ast string_arithmetic.religo_ast_pretty)) (deps string_arithmetic.religo_ast string_arithmetic.religo_ast_pretty)) +(alias (name runtest) (action (diff super-counter.religo_ast super-counter.religo_ast_pretty)) (deps super-counter.religo_ast super-counter.religo_ast_pretty)) +(alias (name runtest) (action (diff tuple_list.religo_ast tuple_list.religo_ast_pretty)) (deps tuple_list.religo_ast tuple_list.religo_ast_pretty)) +(alias (name runtest) (action (diff tuple_param_destruct.religo_ast tuple_param_destruct.religo_ast_pretty)) (deps tuple_param_destruct.religo_ast tuple_param_destruct.religo_ast_pretty)) +(alias (name runtest) (action (diff tuple_type.religo_ast tuple_type.religo_ast_pretty)) (deps tuple_type.religo_ast tuple_type.religo_ast_pretty)) +(alias (name runtest) (action (diff tuple.religo_ast tuple.religo_ast_pretty)) (deps tuple.religo_ast tuple.religo_ast_pretty)) +(alias (name runtest) (action (diff tuples_no_annotation.religo_ast tuples_no_annotation.religo_ast_pretty)) (deps tuples_no_annotation.religo_ast tuples_no_annotation.religo_ast_pretty)) +(alias (name runtest) (action (diff tuples_sequences_functions.religo_ast tuples_sequences_functions.religo_ast_pretty)) (deps tuples_sequences_functions.religo_ast tuples_sequences_functions.religo_ast_pretty)) +(alias (name runtest) (action (diff variant.religo_ast variant.religo_ast_pretty)) (deps variant.religo_ast variant.religo_ast_pretty)) +(alias (name runtest) (action (diff website2.religo_ast website2.religo_ast_pretty)) (deps website2.religo_ast website2.religo_ast_pretty)) + +(alias (name runtest) (action (diff assert.mligo_ast assert.mligo_ast_pretty)) (deps assert.mligo_ast assert.mligo_ast_pretty)) +(alias (name runtest) (action (diff address.mligo_ast address.mligo_ast_pretty)) (deps address.mligo_ast address.mligo_ast_pretty)) +(alias (name runtest) (action (diff amount_lambda.mligo_ast amount_lambda.mligo_ast_pretty)) (deps amount_lambda.mligo_ast amount_lambda.mligo_ast_pretty)) +(alias (name runtest) (action (diff amount.mligo_ast amount.mligo_ast_pretty)) (deps amount.mligo_ast amount.mligo_ast_pretty)) +(alias (name runtest) (action (diff arithmetic.mligo_ast arithmetic.mligo_ast_pretty)) (deps arithmetic.mligo_ast arithmetic.mligo_ast_pretty)) +(alias (name runtest) (action (diff attributes.mligo_ast attributes.mligo_ast_pretty)) (deps attributes.mligo_ast attributes.mligo_ast_pretty)) +(alias (name runtest) (action (diff balance_constant.mligo_ast balance_constant.mligo_ast_pretty)) (deps balance_constant.mligo_ast balance_constant.mligo_ast_pretty)) +(alias (name runtest) (action (diff basic.mligo_ast basic.mligo_ast_pretty)) (deps basic.mligo_ast basic.mligo_ast_pretty)) +(alias (name runtest) (action (diff big_map.mligo_ast big_map.mligo_ast_pretty)) (deps big_map.mligo_ast big_map.mligo_ast_pretty)) +(alias (name runtest) (action (diff bitwise_arithmetic.mligo_ast bitwise_arithmetic.mligo_ast_pretty)) (deps bitwise_arithmetic.mligo_ast bitwise_arithmetic.mligo_ast_pretty)) +(alias (name runtest) (action (diff boolean_operators.mligo_ast boolean_operators.mligo_ast_pretty)) (deps boolean_operators.mligo_ast boolean_operators.mligo_ast_pretty)) +(alias (name runtest) (action (diff bytes_arithmetic.mligo_ast bytes_arithmetic.mligo_ast_pretty)) (deps bytes_arithmetic.mligo_ast bytes_arithmetic.mligo_ast_pretty)) +(alias (name runtest) (action (diff bytes_unpack.mligo_ast bytes_unpack.mligo_ast_pretty)) (deps bytes_unpack.mligo_ast bytes_unpack.mligo_ast_pretty)) +(alias (name runtest) (action (diff check_signature.mligo_ast check_signature.mligo_ast_pretty)) (deps check_signature.mligo_ast check_signature.mligo_ast_pretty)) +(alias (name runtest) (action (diff closure.mligo_ast closure.mligo_ast_pretty)) (deps closure.mligo_ast closure.mligo_ast_pretty)) +(alias (name runtest) (action (diff comparable.mligo_ast comparable.mligo_ast_pretty)) (deps comparable.mligo_ast comparable.mligo_ast_pretty)) +(alias (name runtest) (action (diff condition-annot.mligo_ast condition-annot.mligo_ast_pretty)) (deps condition-annot.mligo_ast condition-annot.mligo_ast_pretty)) +(alias (name runtest) (action (diff condition-shadowing.mligo_ast condition-shadowing.mligo_ast_pretty)) (deps condition-shadowing.mligo_ast condition-shadowing.mligo_ast_pretty)) +(alias (name runtest) (action (diff condition.mligo_ast condition.mligo_ast_pretty)) (deps condition.mligo_ast condition.mligo_ast_pretty)) +(alias (name runtest) (action (diff counter.mligo_ast counter.mligo_ast_pretty)) (deps counter.mligo_ast counter.mligo_ast_pretty)) +(alias (name runtest) (action (diff create_contract.mligo_ast create_contract.mligo_ast_pretty)) (deps create_contract.mligo_ast create_contract.mligo_ast_pretty)) +(alias (name runtest) (action (diff crypto.mligo_ast crypto.mligo_ast_pretty)) (deps crypto.mligo_ast crypto.mligo_ast_pretty)) +(alias (name runtest) (action (diff curry.mligo_ast curry.mligo_ast_pretty)) (deps curry.mligo_ast curry.mligo_ast_pretty)) +(alias (name runtest) (action (diff double_michelson_or.mligo_ast double_michelson_or.mligo_ast_pretty)) (deps double_michelson_or.mligo_ast double_michelson_or.mligo_ast_pretty)) +(alias (name runtest) (action (diff empty_case.mligo_ast empty_case.mligo_ast_pretty)) (deps empty_case.mligo_ast empty_case.mligo_ast_pretty)) +(alias (name runtest) (action (diff eq_bool.mligo_ast eq_bool.mligo_ast_pretty)) (deps eq_bool.mligo_ast eq_bool.mligo_ast_pretty)) +(alias (name runtest) (action (diff FA1.2.mligo_ast FA1.2.mligo_ast_pretty)) (deps FA1.2.mligo_ast FA1.2.mligo_ast_pretty)) +(alias (name runtest) (action (diff failwith.mligo_ast failwith.mligo_ast_pretty)) (deps failwith.mligo_ast failwith.mligo_ast_pretty)) +(alias (name runtest) (action (diff fibo.mligo_ast fibo.mligo_ast_pretty)) (deps fibo.mligo_ast fibo.mligo_ast_pretty)) +(alias (name runtest) (action (diff fibo2.mligo_ast fibo2.mligo_ast_pretty)) (deps fibo2.mligo_ast fibo2.mligo_ast_pretty)) +(alias (name runtest) (action (diff fibo3.mligo_ast fibo3.mligo_ast_pretty)) (deps fibo3.mligo_ast fibo3.mligo_ast_pretty)) +(alias (name runtest) (action (diff fibo4.mligo_ast fibo4.mligo_ast_pretty)) (deps fibo4.mligo_ast fibo4.mligo_ast_pretty)) +(alias (name runtest) (action (diff function-shared.mligo_ast function-shared.mligo_ast_pretty)) (deps function-shared.mligo_ast function-shared.mligo_ast_pretty)) +(alias (name runtest) (action (diff guess_string.mligo_ast guess_string.mligo_ast_pretty)) (deps guess_string.mligo_ast guess_string.mligo_ast_pretty)) \ No newline at end of file diff --git a/src/test/contracts/expected/FA1.2.mligo b/src/test/contracts/expected/FA1.2.mligo new file mode 100644 index 000000000..6bfd26c97 --- /dev/null +++ b/src/test/contracts/expected/FA1.2.mligo @@ -0,0 +1,136 @@ +type tokens = (address, nat) big_map + +type allowances = (address * address, nat) big_map + +type storage = + {tokens : tokens; + allowances : allowances; + total_amount : nat} + +type transfer = + {address_from : address; + address_to : address; + value : nat} + +type approve = {spender : address; value : nat} + +type getAllowance = + {owner : address; + spender : address; + callback : nat contract} + +type getBalance = {owner : address; callback : nat contract} + +type getTotalSupply = {callback : nat contract} + +type action = + Transfer of transfer + | Approve of approve + | GetAllowance of getAllowance + | GetBalance of getBalance + | GetTotalSupply of getTotalSupply + +let transfer (p, s : transfer * storage) +: operation list * storage = + let new_allowances = + if Tezos.sender = p.address_from + then s.allowances + else + let authorized_value = + match Big_map.find_opt + (Tezos.sender, p.address_from) + s.allowances + with + Some value -> value + | None -> 0n + in if (authorized_value < p.value) + then (failwith "Not Enough Allowance" : allowances) + else + Big_map.update + (Tezos.sender, p.address_from) + (Some (abs (authorized_value - p.value))) + s.allowances + in let sender_balance = + match Big_map.find_opt p.address_from s.tokens with + Some value -> value + | None -> 0n + in if (sender_balance < p.value) + then + (failwith "Not Enough Balance" + : operation list * storage) + else + let new_tokens = + Big_map.update + p.address_from + (Some (abs (sender_balance - p.value))) + s.tokens + in let receiver_balance = + match Big_map.find_opt p.address_to s.tokens + with + Some value -> value + | None -> 0n + in let new_tokens = + Big_map.update + p.address_to + (Some (receiver_balance + p.value)) + new_tokens + in ([] : operation list), + {s with + tokens = new_tokens; + allowances = new_allowances} + +let approve (p, s : approve * storage) +: operation list * storage = + let previous_value = + match Big_map.find_opt + (p.spender, Tezos.sender) + s.allowances + with + Some value -> value + | None -> 0n + in if previous_value > 0n && p.value > 0n + then + (failwith "Unsafe Allowance Change" + : operation list * storage) + else + let new_allowances = + Big_map.update + (p.spender, Tezos.sender) + (Some (p.value)) + s.allowances + in ([] : operation list), + {s with + allowances = new_allowances} + +let getAllowance (p, s : getAllowance * storage) +: operation list * storage = + let value = + match Big_map.find_opt (p.owner, p.spender) s.allowances + with + Some value -> value + | None -> 0n + in let op = Tezos.transaction value 0mutez p.callback + in ([op], s) + +let getBalance (p, s : getBalance * storage) +: operation list * storage = + let value = + match Big_map.find_opt p.owner s.tokens with + Some value -> value + | None -> 0n + in let op = Tezos.transaction value 0mutez p.callback + in ([op], s) + +let getTotalSupply (p, s : getTotalSupply * storage) +: operation list * storage = + let total = s.total_amount + in let op = Tezos.transaction total 0mutez p.callback + in ([op], s) + +let main (a, s : action * storage) = + match a with + Transfer p -> transfer (p, s) + | Approve p -> approve (p, s) + | GetAllowance p -> getAllowance (p, s) + | GetBalance p -> getBalance (p, s) + | GetTotalSupply p -> getTotalSupply (p, s) diff --git a/src/test/contracts/expected/address.mligo b/src/test/contracts/expected/address.mligo new file mode 100644 index 000000000..e4d873bbe --- /dev/null +++ b/src/test/contracts/expected/address.mligo @@ -0,0 +1,3 @@ +let main (p : key_hash) = + let c : unit contract = Tezos.implicit_account p + in Tezos.address c diff --git a/src/test/contracts/expected/amount.mligo b/src/test/contracts/expected/amount.mligo new file mode 100644 index 000000000..f274aad7a --- /dev/null +++ b/src/test/contracts/expected/amount.mligo @@ -0,0 +1,2 @@ +let check_ (p : unit) : int = + if Tezos.amount = 100000000mutez then 42 else 0 diff --git a/src/test/contracts/expected/amount_lambda.mligo b/src/test/contracts/expected/amount_lambda.mligo new file mode 100644 index 000000000..a9d51b22d --- /dev/null +++ b/src/test/contracts/expected/amount_lambda.mligo @@ -0,0 +1,10 @@ +let f1 (x : unit) : unit -> tez = + let amt : tez = Current.amount + in fun (x : unit) -> amt + +let f2 (x : unit) : unit -> tez = + fun (x : unit) -> Current.amount + +let main (b, s : bool * (unit -> tez)) +: operation list * (unit -> tez) = + (([] : operation list), (if b then f1 () else f2 ())) diff --git a/src/test/contracts/expected/arithmetic.mligo b/src/test/contracts/expected/arithmetic.mligo new file mode 100644 index 000000000..2f6020397 --- /dev/null +++ b/src/test/contracts/expected/arithmetic.mligo @@ -0,0 +1,17 @@ +let mod_op (n : int) : nat = n mod 42 + +let plus_op (n : int) : int = n + 42 + +let minus_op (n : int) : int = n - 42 + +let times_op (n : int) : int = n * 42 + +let div_op (n : int) : int = n / 2 + +let neg_op (n : int) : int = -n + +let foo (n : int) : int = n + 10 + +let neg_op_2 (b : int) : int = -(foo b) + +let ediv_op (n : int) : (int * nat) option = ediv n 2 diff --git a/src/test/contracts/expected/assert.mligo b/src/test/contracts/expected/assert.mligo new file mode 100644 index 000000000..41785c58d --- /dev/null +++ b/src/test/contracts/expected/assert.mligo @@ -0,0 +1,3 @@ +let main (p, s : bool * unit) = + let u : unit = assert p + in ([] : operation list), s diff --git a/src/test/contracts/expected/attributes.mligo b/src/test/contracts/expected/attributes.mligo new file mode 100644 index 000000000..0623ef077 --- /dev/null +++ b/src/test/contracts/expected/attributes.mligo @@ -0,0 +1,14 @@ +let x = 1 [@@inline] + +let foo (a : int) : int = + (let test = 2 + a [@@inline] + in test) [@@inline] + +let y = 1 [@@inline][@@other] + +let bar (b : int) : int = + let test = fun (z : int) -> 2 + b + z + [@@inline] + [@@foo] + [@@bar] + in test b diff --git a/src/test/contracts/expected/balance_constant.mligo b/src/test/contracts/expected/balance_constant.mligo new file mode 100644 index 000000000..e46d05670 --- /dev/null +++ b/src/test/contracts/expected/balance_constant.mligo @@ -0,0 +1,8 @@ +type parameter = unit + +type storage = tez + +type return = operation list * storage + +let main (p, s : parameter * storage) : return = + ([] : operation list), Tezos.balance diff --git a/src/test/contracts/expected/basic.mligo b/src/test/contracts/expected/basic.mligo new file mode 100644 index 000000000..34be829e0 --- /dev/null +++ b/src/test/contracts/expected/basic.mligo @@ -0,0 +1,3 @@ +type toto = int + +let foo : toto = 42 + 127 diff --git a/src/test/contracts/expected/big_map.mligo b/src/test/contracts/expected/big_map.mligo new file mode 100644 index 000000000..36eafe0fd --- /dev/null +++ b/src/test/contracts/expected/big_map.mligo @@ -0,0 +1,22 @@ +type foo = (int, int) big_map + +let set_ (n, m : int * foo) : foo = + Big_map.update 23 (Some n) m + +let add (n, m : int * foo) : foo = Big_map.add 23 n m + +let rm (m : foo) : foo = Big_map.remove 42 m + +let gf (m : foo) : int = Big_map.find 23 m + +let get (m : foo) : int option = Big_map.find_opt 42 m + +let empty_map : foo = Big_map.empty + +let map1 : foo = Big_map.literal [(23, 0); (42, 0)] + +let map1 : foo = Big_map.literal [(23, 0); (42, 0)] + +let mutimaps (m : foo) (n : foo) : foo = + let bar : foo = Big_map.update 42 (Some 0) m + in Big_map.update 42 (get bar) n diff --git a/src/test/contracts/expected/bitwise_arithmetic.mligo b/src/test/contracts/expected/bitwise_arithmetic.mligo new file mode 100644 index 000000000..2100e15e9 --- /dev/null +++ b/src/test/contracts/expected/bitwise_arithmetic.mligo @@ -0,0 +1,9 @@ +let or_op (n : nat) : nat = Bitwise.or n 4n + +let and_op (n : nat) : nat = Bitwise.and n 7n + +let xor_op (n : nat) : nat = Bitwise.xor n 7n + +let lsl_op (n : nat) : nat = Bitwise.shift_left n 7n + +let lsr_op (n : nat) : nat = Bitwise.shift_right n 7n diff --git a/src/test/contracts/expected/boolean_operators.mligo b/src/test/contracts/expected/boolean_operators.mligo new file mode 100644 index 000000000..be77b3592 --- /dev/null +++ b/src/test/contracts/expected/boolean_operators.mligo @@ -0,0 +1,9 @@ +let or_true (b : bool) : bool = b || true + +let or_false (b : bool) : bool = b || false + +let and_true (b : bool) : bool = b && true + +let and_false (b : bool) : bool = b && false + +let not_bool (b : bool) : bool = not b diff --git a/src/test/contracts/expected/bytes_arithmetic.mligo b/src/test/contracts/expected/bytes_arithmetic.mligo new file mode 100644 index 000000000..2d26e0d22 --- /dev/null +++ b/src/test/contracts/expected/bytes_arithmetic.mligo @@ -0,0 +1,5 @@ +let concat_op (s : bytes) : bytes = Bytes.concat s 0x7070 + +let slice_op (s : bytes) : bytes = Bytes.sub 1n 2n s + +let hasherman (s : bytes) : bytes = Crypto.sha256 s diff --git a/src/test/contracts/expected/bytes_unpack.mligo b/src/test/contracts/expected/bytes_unpack.mligo new file mode 100644 index 000000000..74bceb409 --- /dev/null +++ b/src/test/contracts/expected/bytes_unpack.mligo @@ -0,0 +1,11 @@ +let id_string (p : string) : string option = + let packed : bytes = Bytes.pack p + in (Bytes.unpack packed : string option) + +let id_int (p : int) : int option = + let packed : bytes = Bytes.pack p + in (Bytes.unpack packed : int option) + +let id_address (p : address) : address option = + let packed : bytes = Bytes.pack p + in (Bytes.unpack packed : address option) diff --git a/src/test/contracts/expected/check_signature.mligo b/src/test/contracts/expected/check_signature.mligo new file mode 100644 index 000000000..bef4276d4 --- /dev/null +++ b/src/test/contracts/expected/check_signature.mligo @@ -0,0 +1,11 @@ +let check_signature +(pk, signed, msg : key * signature * bytes) : bool = + Crypto.check pk signed msg + +let example : bool = + Crypto.check + ("edpktz4xg6csJnJ5vcmMb2H37sWXyBDcoAp3XrBvjRaTSQ1zmZTeRQ" + : key) + ("edsigtnzKd51CDomKVMFBoU8SzFZgNqRkYUaQH4DLUg8Lsimz98DFB82uiHAkdvx29DDqHxPf1noQ8noWpKMZoxTCsfprrbs4Xo" + : signature) + 0x05010000000568656c6c6f diff --git a/src/test/contracts/expected/closure.mligo b/src/test/contracts/expected/closure.mligo new file mode 100644 index 000000000..a0505ca8f --- /dev/null +++ b/src/test/contracts/expected/closure.mligo @@ -0,0 +1,5 @@ +let test (k : int) : int = + let j : int = k + 5 + in let close : int -> int = fun (i : int) -> i + j + in let j : int = 20 + in close 20 diff --git a/src/test/contracts/expected/comparable.mligo b/src/test/contracts/expected/comparable.mligo new file mode 100644 index 000000000..c5e4c00fd --- /dev/null +++ b/src/test/contracts/expected/comparable.mligo @@ -0,0 +1,28 @@ +let int_ (a : int) = a < a + +let nat_ (a : nat) = a < a + +let bool_ (a : bool) = a < a + +let mutez_ (a : tez) = a < a + +let string_ (a : string) = a < a + +let bytes_ (a : bytes) = a < a + +let address_ (a : address) = a < a + +let timestamp_ (a : timestamp) = a < a + +let key_hash_ (a : key_hash) = a < a + +type comp_pair = int * int + +let comp_pair (a : comp_pair) = a < a + +type inner_record = (int, "one", nat, "two") michelson_pair + +type comb_record = + (int, "three", inner_record, "four") michelson_pair + +let comb_record (a : comb_record) = a < a diff --git a/src/test/contracts/expected/condition-annot.mligo b/src/test/contracts/expected/condition-annot.mligo new file mode 100644 index 000000000..1eb1bf0f9 --- /dev/null +++ b/src/test/contracts/expected/condition-annot.mligo @@ -0,0 +1,4 @@ +type integer = int + +let main (i : int) = + if (i = 2 : bool) then (42 : int) else (0 : integer) diff --git a/src/test/contracts/expected/condition-shadowing.mligo b/src/test/contracts/expected/condition-shadowing.mligo new file mode 100644 index 000000000..b704abaef --- /dev/null +++ b/src/test/contracts/expected/condition-shadowing.mligo @@ -0,0 +1,9 @@ +let main (i : int) = + let result = 0 + in if i = 2 + then + let result = 42 + in result + else + let result = 0 + in result diff --git a/src/test/contracts/expected/condition.mligo b/src/test/contracts/expected/condition.mligo new file mode 100644 index 000000000..d14c7444c --- /dev/null +++ b/src/test/contracts/expected/condition.mligo @@ -0,0 +1 @@ +let main (i : int) = if i = 2 then 42 else 0 diff --git a/src/test/contracts/expected/counter.mligo b/src/test/contracts/expected/counter.mligo new file mode 100644 index 000000000..cf0ff35bb --- /dev/null +++ b/src/test/contracts/expected/counter.mligo @@ -0,0 +1,4 @@ +type storage = int + +let main (p, s : int * storage) = + ([] : operation list), p + s diff --git a/src/test/contracts/expected/create_contract.mligo b/src/test/contracts/expected/create_contract.mligo new file mode 100644 index 000000000..ea091b05c --- /dev/null +++ b/src/test/contracts/expected/create_contract.mligo @@ -0,0 +1,11 @@ +type return = operation list * string + +let main (action, store : string * string) : return = + let toto : operation * address = + Tezos.create_contract + (fun (p, s : nat * string) -> + (([] : operation list), "one")) + (None : key_hash option) + 300000000mutez + "un" + in ([toto.0], store) diff --git a/src/test/contracts/expected/crypto.mligo b/src/test/contracts/expected/crypto.mligo new file mode 100644 index 000000000..3dc8db6a1 --- /dev/null +++ b/src/test/contracts/expected/crypto.mligo @@ -0,0 +1,3 @@ +let hasherman512 (s : bytes) : bytes = Crypto.sha512 s + +let hasherman_blake (s : bytes) : bytes = Crypto.blake2b s diff --git a/src/test/contracts/expected/curry.mligo b/src/test/contracts/expected/curry.mligo new file mode 100644 index 000000000..ffcaafe15 --- /dev/null +++ b/src/test/contracts/expected/curry.mligo @@ -0,0 +1,9 @@ +let conv_test (j : int) (k : int) = j + k + +let main (i : int) : int = conv_test i 10 + +let partial (a : int) (b : int) : int = a + b + +let mk_partial (j : int) : int -> int = partial j + +let partial_apply (i : int) : int = mk_partial 10 i diff --git a/src/test/contracts/expected/double_michelson_or.mligo b/src/test/contracts/expected/double_michelson_or.mligo new file mode 100644 index 000000000..756e5acba --- /dev/null +++ b/src/test/contracts/expected/double_michelson_or.mligo @@ -0,0 +1,10 @@ +type storage = (int, "foo", string, "bar") michelson_or + +type foobar = (int, "baz", int, "fooo") michelson_or + +type return = operation list * storage + +let main (action, store : unit * storage) : return = + let foo = (M_right ("one") : storage) + in let bar = (M_right 1 : foobar) + in (([] : operation list), (foo : storage)) diff --git a/src/test/contracts/expected/empty_case.mligo b/src/test/contracts/expected/empty_case.mligo new file mode 100644 index 000000000..7b85070fc --- /dev/null +++ b/src/test/contracts/expected/empty_case.mligo @@ -0,0 +1,6 @@ +type foo = Bar of int | Baz + +let main (f : foo) : int = + match f with + Bar i -> i + | Baz -> -1 diff --git a/src/test/contracts/expected/eq_bool.mligo b/src/test/contracts/expected/eq_bool.mligo new file mode 100644 index 000000000..576d4f5c7 --- /dev/null +++ b/src/test/contracts/expected/eq_bool.mligo @@ -0,0 +1 @@ +let main (a, b : bool * bool) = if a = b then 999 else 1 diff --git a/src/test/contracts/expected/failwith.mligo b/src/test/contracts/expected/failwith.mligo new file mode 100644 index 000000000..fee3f0102 --- /dev/null +++ b/src/test/contracts/expected/failwith.mligo @@ -0,0 +1,6 @@ +type storage = unit + +let main (p, store : unit * storage) +: operation list * storage = + (failwith "This contract always fails" + : operation list * storage) diff --git a/src/test/contracts/expected/fibo.mligo b/src/test/contracts/expected/fibo.mligo new file mode 100644 index 000000000..221fe266a --- /dev/null +++ b/src/test/contracts/expected/fibo.mligo @@ -0,0 +1,13 @@ +type storage = unit + +let main (p, store : unit * storage) +: operation list * storage = + let n = + (fun (f : int * int -> int) + (x : int) + (y : int) -> + f (y, x)) + (fun (x : int) (y : int) -> x + y) + 0 + 1 + in ([] : operation list), store diff --git a/src/test/contracts/expected/fibo2.mligo b/src/test/contracts/expected/fibo2.mligo new file mode 100644 index 000000000..bfa744d14 --- /dev/null +++ b/src/test/contracts/expected/fibo2.mligo @@ -0,0 +1,10 @@ +type storage = unit + +let main (p, store : unit * storage) +: operation list * storage = + let n = + (fun (f : int -> int) (z : int) (y : int) -> f y) + (fun (x : int) -> x) + 0 + 1 + in ([] : operation list), store diff --git a/src/test/contracts/expected/fibo3.mligo b/src/test/contracts/expected/fibo3.mligo new file mode 100644 index 000000000..3f9cc0e83 --- /dev/null +++ b/src/test/contracts/expected/fibo3.mligo @@ -0,0 +1,12 @@ +type storage = unit + +let main (p, s : unit * storage) : operation list * storage = + let n = + (fun (f : int -> int -> int) + (x : int) + (y : int) -> + f y (x + y)) + (fun (x : int) (y : int) -> x + y) + 0 + 1 + in ([] : operation list), store diff --git a/src/test/contracts/expected/fibo4.mligo b/src/test/contracts/expected/fibo4.mligo new file mode 100644 index 000000000..9806eabee --- /dev/null +++ b/src/test/contracts/expected/fibo4.mligo @@ -0,0 +1,6 @@ +type storage = unit + +let main (p, s : unit * storage) = + (fun (f : int -> int) (x : int) -> f x) + (fun (x : int) -> x) + 1 diff --git a/src/test/contracts/expected/function-shared.mligo b/src/test/contracts/expected/function-shared.mligo new file mode 100644 index 000000000..fbdd17da5 --- /dev/null +++ b/src/test/contracts/expected/function-shared.mligo @@ -0,0 +1,5 @@ +let foo (i : int) : int = i + 20 + +let bar (i : int) : int = i + 50 + +let foobar (i : int) : int = foo i + bar i diff --git a/src/test/contracts/expected/guess_string.mligo b/src/test/contracts/expected/guess_string.mligo new file mode 100644 index 000000000..642fdb343 --- /dev/null +++ b/src/test/contracts/expected/guess_string.mligo @@ -0,0 +1,17 @@ +type storage = {challenge : string} + +type param = {new_challenge : string; attempt : string} + +type return = operation list * storage + +let attempt (p, store : param * storage) : return = + let contract : unit contract = + match (Tezos.get_contract_opt Tezos.sender + : unit contract option) + with + Some contract -> contract + | None -> (failwith "No contract" : unit contract) + in let transfer : operation = + Tezos.transaction (unit, contract, 10000000mutez) + in let store : storage = {challenge = p.new_challenge} + in ([] : operation list), store