diff --git a/src/libasr/ASR.asdl b/src/libasr/ASR.asdl index 5a9950a021..cc060aca9d 100644 --- a/src/libasr/ASR.asdl +++ b/src/libasr/ASR.asdl @@ -95,7 +95,7 @@ symbol symbol external, identifier module_name, identifier* scope_names, identifier original_name, access access) | StructType(symbol_table symtab, identifier name, identifier* dependencies, - identifier* members, abi abi, access access, bool is_packed, + identifier* members, abi abi, access access, bool is_packed, bool is_abstract, expr? alignment, symbol? parent) | EnumType(symbol_table symtab, identifier name, identifier* dependencies, identifier* members, abi abi, access access, enumtype enum_value_type, @@ -107,7 +107,7 @@ symbol abi abi, access access, presence presence, bool value_attr) | ClassType(symbol_table symtab, identifier name, abi abi, access access) | ClassProcedure(symbol_table parent_symtab, identifier name, identifier? self_argument, - identifier proc_name, symbol proc, abi abi) + identifier proc_name, symbol proc, abi abi, bool is_deferred) | AssociateBlock(symbol_table symtab, identifier name, stmt* body) | Block(symbol_table symtab, identifier name, stmt* body) @@ -161,15 +161,15 @@ stmt | Assign(int label, identifier variable) | Assignment(expr target, expr value, stmt? overloaded) | Associate(expr target, expr value) - | Cycle() + | Cycle(identifier? stmt_name) -- deallocates if allocated otherwise throws a runtime error | ExplicitDeallocate(expr* vars) -- deallocates if allocated otherwise does nothing - | ImplicitDeallocate(symbol* vars) + | ImplicitDeallocate(expr* vars) | DoConcurrentLoop(do_loop_head head, stmt* body) - | DoLoop(do_loop_head head, stmt* body) + | DoLoop(identifier? name, do_loop_head head, stmt* body) | ErrorStop(expr? code) - | Exit() + | Exit(identifier? stmt_name) | ForAllSingle(do_loop_head head, stmt assign_stmt) -- GoTo points to a GoToTarget with the corresponding target_id within -- the same procedure. We currently use `int` IDs to link GoTo with @@ -201,12 +201,12 @@ stmt | Assert(expr test, expr? msg) | SubroutineCall(symbol name, symbol? original_name, call_arg* args, expr? dt) | Where(expr test, stmt* body, stmt* orelse) - | WhileLoop(expr test, stmt* body) + | WhileLoop(identifier? name, expr test, stmt* body) | Nullify(symbol* vars) | Flush(int label, expr unit, expr? err, expr? iomsg, expr? iostat) | ListAppend(expr a, expr ele) | AssociateBlockCall(symbol m) - | SelectType(type_stmt* body, stmt* default) + | SelectType(expr selector, type_stmt* body, stmt* default) | CPtrToPointer(expr cptr, expr ptr, expr? shape) | BlockCall(int label, symbol m) | SetInsert(expr a, expr ele) @@ -420,7 +420,10 @@ do_loop_head = (expr? v, expr? start, expr? end, expr? increment) case_stmt = CaseStmt(expr* test, stmt* body) | CaseStmt_Range(expr? start, expr? end, stmt* body) -type_stmt = TypeStmtName(symbol sym, stmt* body) | TypeStmtType(ttype type, stmt* body) +type_stmt + = TypeStmtName(symbol sym, stmt* body) + | ClassStmt(symbol sym, stmt* body) + | TypeStmtType(ttype type, stmt* body) enumtype = IntegerConsecutiveFromZero | IntegerUnique | IntegerNotUnique | NonInteger diff --git a/src/libasr/asdl_cpp.py b/src/libasr/asdl_cpp.py index bfdd92d69c..572d9a6ebf 100644 --- a/src/libasr/asdl_cpp.py +++ b/src/libasr/asdl_cpp.py @@ -405,6 +405,111 @@ def visitField(self, field): self.emit( "this->visit_symbol(*a.second);", 3) self.emit("}", 2) +class ASRPassWalkVisitorVisitor(ASDLVisitor): + + def visitModule(self, mod): + self.emit("/" + "*"*78 + "/") + self.emit("// Walk Visitor base class") + self.emit("") + self.emit("template ") + self.emit("class ASRPassBaseWalkVisitor : public BaseVisitor") + self.emit("{") + self.emit("private:") + self.emit(" Struct& self() { return static_cast(*this); }") + self.emit("public:") + self.emit(" SymbolTable* current_scope;") + self.emit(" void transform_stmts(ASR::stmt_t **&m_body, size_t &n_body) {") + self.emit(" for (size_t i = 0; i < n_body; i++) {", 1) + self.emit(" self().visit_stmt(*m_body[i]);", 1) + self.emit(" }", 1) + self.emit("}", 1) + super(ASRPassWalkVisitorVisitor, self).visitModule(mod) + self.emit("};") + + def visitType(self, tp): + if not (isinstance(tp.value, asdl.Sum) and + is_simple_sum(tp.value)): + super(ASRPassWalkVisitorVisitor, self).visitType(tp, tp.name) + + def visitProduct(self, prod, name): + self.make_visitor(name, prod.fields) + + def visitConstructor(self, cons, _): + self.make_visitor(cons.name, cons.fields) + + def make_visitor(self, name, fields): + self.emit("void visit_%s(const %s_t &x) {" % (name, name), 1) + is_symtab_present = False + is_stmt_present = False + symtab_field_name = "" + for field in fields: + if field.type == "stmt": + is_stmt_present = True + if field.type == "symbol_table": + is_symtab_present = True + symtab_field_name = field.name + if is_stmt_present and is_symtab_present: + break + if is_stmt_present and name not in ("Assignment", "ForAllSingle"): + self.emit(" %s_t& xx = const_cast<%s_t&>(x);" % (name, name), 1) + self.used = False + + if is_symtab_present: + self.emit("SymbolTable* current_scope_copy = current_scope;", 2) + self.emit("current_scope = x.m_%s;" % symtab_field_name, 2) + + for field in fields: + self.visitField(field) + if not self.used: + # Note: a better solution would be to change `&x` to `& /* x */` + # above, but we would need to change emit to return a string. + self.emit("if ((bool&)x) { } // Suppress unused warning", 2) + + if is_symtab_present: + self.emit("current_scope = current_scope_copy;", 2) + + self.emit("}", 1) + + def visitField(self, field): + if (field.type not in asdl.builtin_types and + field.type not in self.data.simple_types): + level = 2 + if field.seq: + if field.type == "stmt": + self.emit("self().transform_stmts(xx.m_%s, xx.n_%s);" % (field.name, field.name), level) + return + self.used = True + self.emit("for (size_t i=0; iget_scope()) {" % field.name, 2) + self.emit( "this->visit_symbol(*a.second);", 3) + self.emit("}", 2) + class CallReplacerOnExpressionsVisitor(ASDLVisitor): def __init__(self, stream, data): @@ -477,10 +582,10 @@ def make_visitor(self, name, fields): self.emit("}", 1) def insert_call_replacer_code(self, name, level, index=""): - self.emit(" ASR::expr_t** current_expr_copy_%d = current_expr;" % (self.current_expr_copy_variable_count), level) - self.emit(" current_expr = const_cast(&(x.m_%s%s));" % (name, index), level) - self.emit(" self().call_replacer();", level) - self.emit(" current_expr = current_expr_copy_%d;" % (self.current_expr_copy_variable_count), level) + self.emit("ASR::expr_t** current_expr_copy_%d = current_expr;" % (self.current_expr_copy_variable_count), level) + self.emit("current_expr = const_cast(&(x.m_%s%s));" % (name, index), level) + self.emit("self().call_replacer();", level) + self.emit("current_expr = current_expr_copy_%d;" % (self.current_expr_copy_variable_count), level) self.current_expr_copy_variable_count += 1 def visitField(self, field): @@ -495,12 +600,14 @@ def visitField(self, field): self.emit("for (size_t i=0; i subs, + const ASR::expr_t *expr) { + ASR::ttype_t *ttype = ASRUtils::expr_type(expr); + if (ASR::is_a(*ttype)) { + ASR::TypeParameter_t *tparam = ASR::down_cast(ttype); + ttype = subs[tparam->m_param]; + } + return ttype; +} + static inline ASR::ttype_t* symbol_type(const ASR::symbol_t *f) { switch( f->type ) { @@ -280,6 +290,9 @@ static inline std::string type_to_str(const ASR::ttype_t *t) case ASR::ttypeType::Struct: { return ASRUtils::symbol_name(ASR::down_cast(t)->m_derived_type); } + case ASR::ttypeType::Class: { + return ASRUtils::symbol_name(ASR::down_cast(t)->m_class_type); + } case ASR::ttypeType::Union: { return "union"; } @@ -2614,7 +2627,7 @@ inline ASR::asr_t* make_Function_t_util(Allocator& al, const Location& loc, return ASR::make_Function_t( al, loc, m_symtab, m_name, func_type, m_dependencies, n_dependencies, a_args, n_args, m_body, n_body, m_return_var, m_access, m_deterministic, - m_side_effect_free); + m_side_effect_free); } class ExprStmtDuplicator: public ASR::BaseExprStmtDuplicator @@ -2674,6 +2687,12 @@ class SymbolDuplicator { new_symbol_name = function->m_name; break; } + case ASR::symbolType::Block: { + ASR::Block_t* block = ASR::down_cast(symbol); + new_symbol = duplicate_Block(block, destination_symtab); + new_symbol_name = block->m_name; + break; + } default: { throw LCompilersException("Duplicating ASR::symbolType::" + std::to_string(symbol->type) + " is not supported yet."); @@ -2768,6 +2787,14 @@ class SymbolDuplicator { for( size_t i = 0; i < function->n_args; i++ ) { node_duplicator.success = true; ASR::expr_t* new_arg = node_duplicator.duplicate_expr(function->m_args[i]); + if (ASR::is_a(*new_arg)) { + ASR::Var_t* var = ASR::down_cast(new_arg); + if (ASR::is_a(*(var->m_v))) { + ASR::Variable_t* variable = ASR::down_cast(var->m_v); + ASR::symbol_t* arg_symbol = function_symtab->get_symbol(variable->m_name); + new_arg = ASRUtils::EXPR(make_Var_t(al, var->base.base.loc, arg_symbol)); + } + } if( !node_duplicator.success ) { return nullptr; } @@ -2776,6 +2803,14 @@ class SymbolDuplicator { node_duplicator.success = true; ASR::expr_t* new_return_var = node_duplicator.duplicate_expr(function->m_return_var); + if (ASR::is_a(*new_return_var)) { + ASR::Var_t* var = ASR::down_cast(new_return_var); + if (ASR::is_a(*(var->m_v))) { + ASR::Variable_t* variable = ASR::down_cast(var->m_v); + ASR::symbol_t* arg_symbol = function_symtab->get_symbol(variable->m_name); + new_return_var = ASRUtils::EXPR(make_Var_t(al, var->base.base.loc, arg_symbol)); + } + } if( !node_duplicator.success ) { return nullptr; } @@ -2816,6 +2851,30 @@ class SymbolDuplicator { function->m_side_effect_free)); } + ASR::symbol_t* duplicate_Block(ASR::Block_t* block_t, + SymbolTable* destination_symtab) { + SymbolTable* block_symtab = al.make_new(destination_symtab); + duplicate_SymbolTable(block_t->m_symtab, block_symtab); + + Vec new_body; + new_body.reserve(al, block_t->n_body); + ASRUtils::ExprStmtDuplicator node_duplicator(al); + node_duplicator.allow_procedure_calls = true; + node_duplicator.allow_reshape = false; + for( size_t i = 0; i < block_t->n_body; i++ ) { + node_duplicator.success = true; + ASR::stmt_t* new_stmt = node_duplicator.duplicate_stmt(block_t->m_body[i]); + if( !node_duplicator.success ) { + return nullptr; + } + new_body.push_back(al, new_stmt); + } + + return ASR::down_cast(ASR::make_Block_t(al, + block_t->base.base.loc, block_symtab, block_t->m_name, + new_body.p, new_body.size())); + } + }; class ReplaceReturnWithGotoVisitor: public ASR::BaseStmtReplacer { @@ -3047,10 +3106,15 @@ static inline bool is_pass_array_by_data_possible(ASR::Function_t* x, std::vecto } int n_dims = ASRUtils::extract_dimensions_from_ttype(typei, dims); ASR::Variable_t* argi = ASRUtils::EXPR2VAR(x->m_args[i]); + if( ASR::is_a(*argi->m_type) ) { + return false; + } if( ASRUtils::is_dimension_empty(dims, n_dims) && (argi->m_intent == ASRUtils::intent_in || - argi->m_intent == ASRUtils::intent_out) && - argi->m_storage != ASR::storage_typeType::Allocatable) { + argi->m_intent == ASRUtils::intent_out || + argi->m_intent == ASRUtils::intent_inout) && + argi->m_storage != ASR::storage_typeType::Allocatable && + !ASR::is_a(*argi->m_type)) { v.push_back(i); } } @@ -3109,6 +3173,16 @@ static inline ASR::EnumType_t* get_EnumType_from_symbol(ASR::symbol_t* s) { return ASR::down_cast(enum_type_cand); } +static inline bool is_abstract_class_type(ASR::ttype_t* type) { + if( !ASR::is_a(*type) ) { + return false; + } + ASR::Class_t* class_t = ASR::down_cast(type); + return std::string( ASRUtils::symbol_name( + ASRUtils::symbol_get_past_external(class_t->m_class_type)) + ) == "~abstract_type"; +} + static inline void set_enum_value_type(ASR::enumtypeType &enum_value_type, SymbolTable *scope) { int8_t IntegerConsecutiveFromZero = 1; diff --git a/src/libasr/asr_verify.cpp b/src/libasr/asr_verify.cpp index ea944e87ca..dd0f5b0030 100644 --- a/src/libasr/asr_verify.cpp +++ b/src/libasr/asr_verify.cpp @@ -610,7 +610,8 @@ class VerifyVisitor : public BaseWalkVisitor + "') + scope_names not found in a module '" + asr_owner_name + "'"); require(s == x.m_external, - "ExternalSymbol::m_name + scope_names found but not equal to m_external"); + std::string("ExternalSymbol::m_name + scope_names found but not equal to m_external, ") + + "original_name " + std::string(x.m_original_name) + "."); } } @@ -631,6 +632,11 @@ class VerifyVisitor : public BaseWalkVisitor variable_dependencies.push_back(x_mv_name); } + void visit_ImplicitDeallocate(const ImplicitDeallocate_t &x) { + // TODO: check that every allocated variable is deallocated. + BaseWalkVisitor::visit_ImplicitDeallocate(x); + } + void check_var_external(const ASR::expr_t &x) { if (ASR::is_a(x)) { ASR::symbol_t *s = ((ASR::Var_t*)&x)->m_v; diff --git a/src/libasr/codegen/asr_to_c_cpp.h b/src/libasr/codegen/asr_to_c_cpp.h index aa3cbfbfb2..a50dcfacfb 100644 --- a/src/libasr/codegen/asr_to_c_cpp.h +++ b/src/libasr/codegen/asr_to_c_cpp.h @@ -1799,7 +1799,17 @@ R"(#include std::string indent(indentation_level*indentation_spaces, ' '); std::string out = indent + "// FIXME: implicit deallocate("; for (size_t i=0; i(*tmp_expr) ) { + const ASR::Var_t* tmp_var = ASR::down_cast(tmp_expr); + tmp_sym = tmp_var->m_v; + } else { + throw CodeGenError("Cannot deallocate variables in expression " + + std::to_string(tmp_expr->type), + tmp_expr->base.loc); + } + out += std::string(ASRUtils::symbol_name(tmp_sym)) + ", "; } out += ");\n"; src = out; diff --git a/src/libasr/codegen/asr_to_julia.cpp b/src/libasr/codegen/asr_to_julia.cpp index 6f468afff9..9eed27ec8a 100644 --- a/src/libasr/codegen/asr_to_julia.cpp +++ b/src/libasr/codegen/asr_to_julia.cpp @@ -1227,7 +1227,7 @@ class ASRToJuliaVisitor : public ASR::BaseVisitor void visit_DoConcurrentLoop(const ASR::DoConcurrentLoop_t& x) { - const ASR::DoLoop_t do_loop = ASR::DoLoop_t{ x.base, x.m_head, x.m_body, x.n_body }; + const ASR::DoLoop_t do_loop = ASR::DoLoop_t{ x.base, nullptr, x.m_head, x.m_body, x.n_body }; visit_DoLoop(do_loop, true); } diff --git a/src/libasr/codegen/asr_to_llvm.cpp b/src/libasr/codegen/asr_to_llvm.cpp index cd1d632490..0e12c89555 100644 --- a/src/libasr/codegen/asr_to_llvm.cpp +++ b/src/libasr/codegen/asr_to_llvm.cpp @@ -41,7 +41,6 @@ #include #include -#include #include #include #include @@ -165,7 +164,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor Allocator &al; llvm::Value *tmp; - llvm::BasicBlock *current_loophead, *current_loopend, *proc_return, *block_end_label; + llvm::BasicBlock *proc_return; std::string mangle_prefix; bool prototype_only; llvm::StructType *complex_type_4, *complex_type_8; @@ -193,6 +192,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor relationship between enclosing and nested functions */ std::vector nested_globals; /* For saving the hash of variables from a parent scope needed in a nested function */ + std::map nested_globals_value; /* For saving the + value of a variable from a parent scope needed in a nested function */ std::map> nested_func_types; /* For saving the hash of a parent function needing to give access to variables in a nested function, as well as the variable types */ @@ -220,6 +221,13 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor reload a local scope (and increment or decrement the stack pointer) */ const ASR::Function_t *parent_function = nullptr; + std::vector loop_head; /* For saving the head of a loop, + so that we can jump to the head of the loop when we reach a cycle */ + std::vector loop_head_names; + std::vector loop_or_block_end; /* For saving the end of a block, + so that we can jump to the end of the block when we reach an exit */ + std::vector loop_or_block_end_names; + std::unique_ptr llvm_utils; std::unique_ptr list_api; std::unique_ptr tuple_api; @@ -230,7 +238,6 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor int64_t ptr_loads; bool lookup_enum_value_for_nonints; bool is_assignment_target; - bool in_block = false; CompilerOptions &compiler_options; @@ -241,6 +248,16 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor std::map llvm_symtab_fn_discope; llvm::DIFile *debug_Unit; + std::map> type2vtab; + std::map>> class2vtab; + std::map type2vtabtype; + std::map type2vtabid; + std::map> vtabtype2procidx; + llvm::Type* current_select_type_block_type; + std::string current_select_type_block_der_type; + + SymbolTable* current_scope; + ASRToLLVMVisitor(Allocator &al, llvm::LLVMContext &context, std::string infile, CompilerOptions &compiler_options_, diag::Diagnostics &diagnostics) : diag{diagnostics}, @@ -261,7 +278,9 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor ptr_loads(2), lookup_enum_value_for_nonints(false), is_assignment_target(false), - compiler_options(compiler_options_) + compiler_options(compiler_options_), + current_select_type_block_type(nullptr), + current_scope(nullptr) { llvm_utils->tuple_api = tuple_api.get(); llvm_utils->list_api = list_api.get(); @@ -322,14 +341,29 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } template - void create_loop(Cond condition, Body loop_body) { + void create_loop(char *name, Cond condition, Body loop_body) { dict_api_lp->set_iterators(); dict_api_sc->set_iterators(); - llvm::BasicBlock *loophead = llvm::BasicBlock::Create(context, "loop.head"); - llvm::BasicBlock *loopbody = llvm::BasicBlock::Create(context, "loop.body"); - llvm::BasicBlock *loopend = llvm::BasicBlock::Create(context, "loop.end"); - this->current_loophead = loophead; - this->current_loopend = loopend; + + std::string loop_name; + if (name) { + loop_name = std::string(name); + } else { + loop_name = "loop"; + } + + std::string loophead_name = loop_name + ".head"; + std::string loopbody_name = loop_name + ".body"; + std::string loopend_name = loop_name + ".end"; + + llvm::BasicBlock *loophead = llvm::BasicBlock::Create(context, loophead_name); + llvm::BasicBlock *loopbody = llvm::BasicBlock::Create(context, loopbody_name); + llvm::BasicBlock *loopend = llvm::BasicBlock::Create(context, loopend_name); + + loop_head.push_back(loophead); + loop_head_names.push_back(loophead_name); + loop_or_block_end.push_back(loopend); + loop_or_block_end_names.push_back(loopend_name); // head start_new_block(loophead); { @@ -344,6 +378,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } // end + loop_or_block_end.pop_back(); + loop_or_block_end_names.pop_back(); start_new_block(loopend); dict_api_lp->reset_iterators(); dict_api_sc->reset_iterators(); @@ -491,6 +527,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor break; } default: + LCOMPILERS_ASSERT(false); break; } } else { @@ -519,7 +556,12 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor el_type = character_type; break; } + case ASR::ttypeType::Class: { + el_type = getClassType(m_type_); + break; + } default: + LCOMPILERS_ASSERT(false); break; } } @@ -758,16 +800,19 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } llvm::Type* getStructType(ASR::ttype_t* _type, bool is_pointer=false) { - ASR::Struct_t* der = (ASR::Struct_t*)(&(_type->base)); - ASR::symbol_t* der_sym; - if( der->m_derived_type->type == ASR::symbolType::ExternalSymbol ) { - ASR::ExternalSymbol_t* der_extr = (ASR::ExternalSymbol_t*)(&(der->m_derived_type->base)); - der_sym = der_extr->m_external; - } else { - der_sym = der->m_derived_type; - } - ASR::StructType_t* der_type = (ASR::StructType_t*)(&(der_sym->base)); - return getStructType(der_type, is_pointer); + if( ASR::is_a(*_type) ) { + ASR::Struct_t* der = ASR::down_cast(_type); + ASR::symbol_t* der_sym = ASRUtils::symbol_get_past_external(der->m_derived_type); + ASR::StructType_t* der_type = ASR::down_cast(der_sym); + return getStructType(der_type, is_pointer); + } else if( ASR::is_a(*_type) ) { + ASR::Class_t* der = ASR::down_cast(_type); + ASR::symbol_t* der_sym = ASRUtils::symbol_get_past_external(der->m_class_type); + ASR::StructType_t* der_type = ASR::down_cast(der_sym); + return getStructType(der_type, is_pointer); + } + LCOMPILERS_ASSERT(false); + return nullptr; } llvm::Type* getUnionType(ASR::UnionType_t* union_type, bool is_pointer=false) { @@ -805,67 +850,92 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor return getUnionType(union_type, is_pointer); } - llvm::Type* getClassType(ASR::ttype_t* _type, bool is_pointer=false) { - ASR::Class_t* der = (ASR::Class_t*)(&(_type->base)); - ASR::symbol_t* der_sym; - if( der->m_class_type->type == ASR::symbolType::ExternalSymbol ) { - ASR::ExternalSymbol_t* der_extr = (ASR::ExternalSymbol_t*)(&(der->m_class_type->base)); - der_sym = der_extr->m_external; - } else { - der_sym = der->m_class_type; + llvm::Type* getClassType(ASR::ClassType_t* der_type, bool is_pointer=false) { + const std::map& scope = der_type->m_symtab->get_scope(); + std::vector member_types; + int member_idx = 0; + for( auto itr = scope.begin(); itr != scope.end(); itr++ ) { + if (!ASR::is_a(*itr->second) && + !ASR::is_a(*itr->second) && + !ASR::is_a(*itr->second)) { + ASR::Variable_t* member = ASR::down_cast(itr->second); + llvm::Type* mem_type = nullptr; + switch( member->m_type->type ) { + case ASR::ttypeType::Integer: { + int a_kind = down_cast(member->m_type)->m_kind; + mem_type = getIntType(a_kind); + break; + } + case ASR::ttypeType::Real: { + int a_kind = down_cast(member->m_type)->m_kind; + mem_type = getFPType(a_kind); + break; + } + case ASR::ttypeType::Class: { + mem_type = getClassType(member->m_type); + break; + } + case ASR::ttypeType::Complex: { + int a_kind = down_cast(member->m_type)->m_kind; + mem_type = getComplexType(a_kind); + break; + } + default: + throw CodeGenError("Cannot identify the type of member, '" + + std::string(member->m_name) + + "' in derived type, '" + der_type_name + "'.", + member->base.base.loc); + } + member_types.push_back(mem_type); + name2memidx[der_type_name][std::string(member->m_name)] = member_idx; + member_idx++; + } } - ASR::ClassType_t* der_type = (ASR::ClassType_t*)(&(der_sym->base)); - std::string der_type_name = std::string(der_type->m_name); + llvm::StructType* der_type_llvm = llvm::StructType::create(context, member_types, der_type_name); + name2dertype[der_type_name] = der_type_llvm; + if( is_pointer ) { + return der_type_llvm->getPointerTo(); + } + return (llvm::Type*) der_type_llvm; + } + + llvm::Type* getClassType(ASR::StructType_t* der_type, bool is_pointer=false) { + std::string der_type_name = std::string(der_type->m_name) + std::string("_polymorphic"); + llvm::StructType* der_type_llvm = nullptr; + if( name2dertype.find(der_type_name) != name2dertype.end() ) { + der_type_llvm = name2dertype[der_type_name]; + } + LCOMPILERS_ASSERT(der_type_llvm != nullptr); + if( is_pointer ) { + return der_type_llvm->getPointerTo(); + } + return (llvm::Type*) der_type_llvm; + } + + llvm::Type* getClassType(ASR::ttype_t* _type, bool is_pointer=false) { + ASR::Class_t* der = ASR::down_cast(_type); + ASR::symbol_t* der_sym = ASRUtils::symbol_get_past_external(der->m_class_type); + std::string der_sym_name = ASRUtils::symbol_name(der_sym); + std::string der_type_name = der_sym_name + std::string("_polymorphic"); llvm::StructType* der_type_llvm; if( name2dertype.find(der_type_name) != name2dertype.end() ) { der_type_llvm = name2dertype[der_type_name]; } else { - const std::map& scope = der_type->m_symtab->get_scope(); std::vector member_types; - int member_idx = 0; - for( auto itr = scope.begin(); itr != scope.end(); itr++ ) { - if (!ASR::is_a(*itr->second) && - !ASR::is_a(*itr->second) && - !ASR::is_a(*itr->second)) { - ASR::Variable_t* member = ASR::down_cast(itr->second); - llvm::Type* mem_type = nullptr; - switch( member->m_type->type ) { - case ASR::ttypeType::Integer: { - int a_kind = down_cast(member->m_type)->m_kind; - mem_type = getIntType(a_kind); - break; - } - case ASR::ttypeType::Real: { - int a_kind = down_cast(member->m_type)->m_kind; - mem_type = getFPType(a_kind); - break; - } - case ASR::ttypeType::Class: { - mem_type = getClassType(member->m_type); - break; - } - case ASR::ttypeType::Complex: { - int a_kind = down_cast(member->m_type)->m_kind; - mem_type = getComplexType(a_kind); - break; - } - default: - throw CodeGenError("Cannot identify the type of member, '" + - std::string(member->m_name) + - "' in derived type, '" + der_type_name + "'.", - member->base.base.loc); - } - member_types.push_back(mem_type); - name2memidx[der_type_name][std::string(member->m_name)] = member_idx; - member_idx++; - } + member_types.push_back(getIntType(8)); + if( der_sym_name == "~abstract_type" ) { + member_types.push_back(llvm::Type::getVoidTy(context)->getPointerTo()); + } else if( ASR::is_a(*der_sym) ) { + ASR::ClassType_t* class_type_t = ASR::down_cast(der_sym); + member_types.push_back(getClassType(class_type_t, is_pointer)); + } else if( ASR::is_a(*der_sym) ) { + ASR::StructType_t* struct_type_t = ASR::down_cast(der_sym); + member_types.push_back(getStructType(struct_type_t, is_pointer)); } der_type_llvm = llvm::StructType::create(context, member_types, der_type_name); name2dertype[der_type_name] = der_type_llvm; } - if( is_pointer ) { - return der_type_llvm->getPointerTo(); - } + return (llvm::Type*) der_type_llvm; } @@ -1076,6 +1146,21 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor return builder->CreateCall(fn, {str, idx1}); } + llvm::Value* lfortran_str_copy(llvm::Value* str, llvm::Value* idx1, llvm::Value* idx2) + { + std::string runtime_func_name = "_lfortran_str_copy"; + llvm::Function *fn = module->getFunction(runtime_func_name); + if (!fn) { + llvm::FunctionType *function_type = llvm::FunctionType::get( + character_type, { + character_type, llvm::Type::getInt32Ty(context), llvm::Type::getInt32Ty(context) + }, false); + fn = llvm::Function::Create(function_type, + llvm::Function::ExternalLinkage, runtime_func_name, *module); + } + return builder->CreateCall(fn, {str, idx1, idx2}); + } + llvm::Value* lfortran_str_slice(llvm::Value* str, llvm::Value* idx1, llvm::Value* idx2, llvm::Value* step, llvm::Value* left_present, llvm::Value* right_present) { @@ -1094,6 +1179,20 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor return builder->CreateCall(fn, {str, idx1, idx2, step, left_present, right_present}); } + llvm::Value* lfortran_str_copy(llvm::Value* dest, llvm::Value *src) { + std::string runtime_func_name = "_lfortran_strcpy"; + llvm::Function *fn = module->getFunction(runtime_func_name); + if (!fn) { + llvm::FunctionType *function_type = llvm::FunctionType::get( + llvm::Type::getVoidTy(context), { + character_type->getPointerTo(), character_type + }, false); + fn = llvm::Function::Create(function_type, + llvm::Function::ExternalLinkage, runtime_func_name, *module); + } + return builder->CreateCall(fn, {dest, src}); + } + llvm::Value* lfortran_type_to_str(llvm::Value* arg, llvm::Type* value_type, std::string type, int value_kind) { std::string func_name = "_lfortran_" + type + "_to_str" + std::to_string(value_kind); llvm::Function *fn = module->getFunction(func_name); @@ -1310,6 +1409,18 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor ASR::ttype_t* curr_arg_m_a_type = ASRUtils::symbol_type(tmp_sym); ASR::ttype_t* asr_data_type = ASRUtils::duplicate_type_without_dims(al, curr_arg_m_a_type, curr_arg_m_a_type->base.loc); + if (ASRUtils::is_character(*curr_arg_m_a_type)) { + int dims = ASR::down_cast(curr_arg_m_a_type)->n_dims; + if (dims == 0) { + // TODO: Add ASR reference to capture the length of the string + // during initialization. + llvm::Value *len = llvm::ConstantInt::get(context, llvm::APInt(32, 16)); + std::vector args = {x_arr, len}; + llvm::Function *fn = _AllocateString(); + builder->CreateCall(fn, args); + continue;; + } + } llvm::Type* llvm_data_type = get_type_from_ttype_t_util(asr_data_type); fill_malloc_array_details(x_arr, llvm_data_type, curr_arg.m_dims, curr_arg.n_dims); } @@ -1362,13 +1473,50 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor return free_fn; } + inline void call_lfortran_free_string(llvm::Function* fn) { + std::vector args = {tmp}; + builder->CreateCall(fn, args); + } + + llvm::Function* _AllocateString() { + std::string func_name = "_lfortran_string_alloc"; + llvm::Function *alloc_fun = module->getFunction(func_name); + if (!alloc_fun) { + llvm::FunctionType *function_type = llvm::FunctionType::get( + llvm::Type::getVoidTy(context), { + character_type->getPointerTo(), + llvm::Type::getInt32Ty(context) + }, true); + alloc_fun = llvm::Function::Create(function_type, + llvm::Function::ExternalLinkage, func_name, *module); + } + return alloc_fun; + } + void visit_ImplicitDeallocate(const ASR::ImplicitDeallocate_t& x) { llvm::Function* free_fn = _Deallocate(); for( size_t i = 0; i < x.n_vars; i++ ) { - const ASR::symbol_t* curr_obj = x.m_vars[i]; + const ASR::expr_t* tmp_expr = x.m_vars[i]; + ASR::symbol_t* curr_obj = nullptr; + if( ASR::is_a(*tmp_expr) ) { + const ASR::Var_t* tmp_var = ASR::down_cast(tmp_expr); + curr_obj = tmp_var->m_v; + } else { + throw CodeGenError("Cannot deallocate variables in expression " + + std::to_string(tmp_expr->type), + tmp_expr->base.loc); + } ASR::Variable_t *v = ASR::down_cast( symbol_get_past_external(curr_obj)); + fetch_var(v); + if (ASRUtils::is_character(*v->m_type)) { + int dims = ASR::down_cast(v->m_type)->n_dims; + if (dims == 0) { + call_lfortran_free_string(free_fn); + continue; + } + } llvm::Value *cond = arr_descr->get_is_allocated_flag(tmp); create_if_else(cond, [=]() { call_lfortran_free(free_fn); @@ -1949,10 +2097,11 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } } LCOMPILERS_ASSERT(ASRUtils::extract_n_dims_from_ttype(x_mv_type) > 0); + bool is_polymorphic = current_select_type_block_type != nullptr; tmp = arr_descr->get_single_element(array, indices, x.n_args, is_data_only, ASRUtils::is_fixed_size_array(m_dims, n_dims) && is_bindc_array, - llvm_diminfo.p); + llvm_diminfo.p, is_polymorphic, current_select_type_block_type); } } @@ -2109,13 +2258,23 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor der_type_name = ""; ASR::ttype_t* x_m_v_type = ASRUtils::expr_type(x.m_v); int64_t ptr_loads_copy = ptr_loads; - if( ASR::is_a(*x.m_v) ) { + if( ASR::is_a(*x.m_v) || + ASR::is_a(*ASRUtils::type_get_past_pointer(x_m_v_type)) ) { ptr_loads = 0; } else { ptr_loads = 2 - ASR::is_a(*x_m_v_type); } this->visit_expr(*x.m_v); ptr_loads = ptr_loads_copy; + if( ASR::is_a(*ASRUtils::type_get_past_pointer(x_m_v_type)) ) { + tmp = CreateLoad(llvm_utils->create_gep(tmp, 1)); + if( current_select_type_block_type ) { + tmp = builder->CreateBitCast(tmp, current_select_type_block_type); + der_type_name = current_select_type_block_der_type; + } else { + // TODO: Select type by comparing with vtab + } + } ASR::Variable_t* member = down_cast(symbol_get_past_external(x.m_m)); std::string member_name = std::string(member->m_name); LCOMPILERS_ASSERT(der_type_name.size() != 0); @@ -2319,6 +2478,11 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } } + void visit_PointerNullConstant(const ASR::PointerNullConstant_t& x){ + llvm::Type* value_type = get_type_from_ttype_t_util(x.m_type); + tmp = llvm::ConstantPointerNull::get(static_cast(value_type)); + } + void visit_EnumType(const ASR::EnumType_t& x) { if( x.m_enum_value_type == ASR::enumtypeType::IntegerUnique && x.m_abi == ASR::abiType::BindC ) { @@ -2454,6 +2618,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } void visit_Module(const ASR::Module_t &x) { + SymbolTable* current_scope_copy = current_scope; + current_scope = x.m_symtab; mangle_prefix = "__module_" + std::string(x.m_name) + "_"; start_module_init_function_prototype(x); @@ -2479,9 +2645,26 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor visit_procedures(x); mangle_prefix = ""; + current_scope = current_scope_copy; + } + + void store_nested_globals_value() { + for (auto it: nested_globals_value) { + auto finder = std::find(nested_globals.begin(), + nested_globals.end(), it.first); + if (finder != nested_globals.end() && nested_globals_value.find(it.first) != nested_globals_value.end()) { + llvm::Value* ptr = module->getOrInsertGlobal(nested_desc_name, + nested_global_struct); + int idx = std::distance(nested_globals.begin(), finder); + builder->CreateStore(it.second, llvm_utils->create_gep(ptr, idx)); + } + } + nested_globals_value.clear(); } void visit_Program(const ASR::Program_t &x) { + SymbolTable* current_scope_copy = current_scope; + current_scope = x.m_symtab; bool is_dict_present_copy_lp = dict_api_lp->is_dict_present(); bool is_dict_present_copy_sc = dict_api_sc->is_dict_present(); dict_api_lp->set_is_dict_present(false); @@ -2542,8 +2725,13 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor declare_vars(x); for (size_t i=0; ivisit_stmt(*x.m_body[i]); + ASR::stmt_t* stmt = x.m_body[i]; + if (stmt->type == ASR::stmtType::SubroutineCall) { + store_nested_globals_value(); + } + this->visit_stmt(*stmt); } + store_nested_globals_value(); llvm::Value *ret_val2 = llvm::ConstantInt::get(context, llvm::APInt(32, 0)); builder->CreateRet(ret_val2); @@ -2552,6 +2740,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor // Finalize the debug info. if (compiler_options.emit_debug_info) DBuilder->finalize(); + current_scope = current_scope_copy; } /* @@ -2612,7 +2801,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor ASR::storage_typeType m_storage, bool& is_array_type, bool& is_malloc_array_type, bool& is_list, ASR::dimension_t*& m_dims, - int& n_dims, int& a_kind, ASR::abiType m_abi=ASR::abiType::Source) { + int& n_dims, int& a_kind, ASR::abiType m_abi=ASR::abiType::Source, + bool is_pointer=false) { llvm::Type* llvm_type = nullptr; switch (asr_type->type) { case (ASR::ttypeType::Integer) : { @@ -2759,6 +2949,24 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } break; } + case (ASR::ttypeType::Class) : { + ASR::Class_t* v_type = down_cast(asr_type); + m_dims = v_type->m_dims; + n_dims = v_type->n_dims; + if( n_dims > 0 ) { + is_array_type = true; + llvm::Type* el_type = get_el_type(asr_type); + if( m_storage == ASR::storage_typeType::Allocatable ) { + is_malloc_array_type = true; + llvm_type = arr_descr->get_malloc_array_type(asr_type, el_type); + } else { + llvm_type = arr_descr->get_array_type(asr_type, el_type); + } + } else { + llvm_type = getClassType(asr_type, is_pointer); + } + break; + } case (ASR::ttypeType::Union) : { ASR::Union_t* v_type = ASR::down_cast(asr_type); m_dims = v_type->m_dims; @@ -2779,10 +2987,16 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } case (ASR::ttypeType::Pointer) : { ASR::ttype_t *t2 = ASR::down_cast(asr_type)->m_type; + bool is_pointer_ = ASR::is_a(*t2); llvm_type = get_type_from_ttype_t(t2, m_storage, is_array_type, is_malloc_array_type, is_list, m_dims, - n_dims, a_kind, m_abi); - llvm_type = llvm_type->getPointerTo(); + n_dims, a_kind, m_abi, is_pointer_); + if( !is_pointer_ ) { + llvm_type = llvm_type->getPointerTo(); + } + if (n_dims == 0 && ASR::is_a(*t2)){ + llvm_type = character_type; + } break; } case (ASR::ttypeType::List) : { @@ -2920,11 +3134,103 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } } + void create_vtab_for_struct_type(ASR::symbol_t* struct_type_sym, SymbolTable* symtab) { + LCOMPILERS_ASSERT(ASR::is_a(*struct_type_sym)); + ASR::StructType_t* struct_type_t = ASR::down_cast(struct_type_sym); + if( type2vtab.find(struct_type_sym) != type2vtab.end() && + type2vtab[struct_type_sym].find(symtab) != type2vtab[struct_type_sym].end() ) { + return ; + } + if( type2vtabtype.find(struct_type_sym) == type2vtabtype.end() ) { + std::vector type_vec = {getIntType(8)}; + type2vtabtype[struct_type_sym] = llvm::StructType::create( + context, type_vec, + std::string("__vtab_") + + std::string(struct_type_t->m_name)); + } + llvm::Type* vtab_type = type2vtabtype[struct_type_sym]; + llvm::Value* vtab_obj = builder->CreateAlloca(vtab_type); + llvm::Value* struct_type_hash_ptr = llvm_utils->create_gep(vtab_obj, 0); + llvm::Value* struct_type_hash = llvm::ConstantInt::get(getIntType(8), + llvm::APInt(64, get_class_hash(struct_type_sym))); + builder->CreateStore(struct_type_hash, struct_type_hash_ptr); + type2vtab[struct_type_sym][symtab] = vtab_obj; + ASR::symbol_t* struct_type_ = struct_type_sym; + bool base_found = false; + while( !base_found ) { + if( ASR::is_a(*struct_type_) ) { + ASR::StructType_t* struct_type = ASR::down_cast(struct_type_); + if( struct_type->m_parent == nullptr ) { + base_found = true; + } else { + struct_type_ = ASRUtils::symbol_get_past_external(struct_type->m_parent); + } + } else { + LCOMPILERS_ASSERT(false); + } + } + class2vtab[struct_type_][symtab].push_back(vtab_obj); + } + + void collect_class_type_names_and_struct_types( + std::set& class_type_names, + std::vector& struct_types, + SymbolTable* x_symtab) { + if (x_symtab == nullptr) { + return ; + } + for (auto &item : x_symtab->get_scope()) { + ASR::symbol_t* var_sym = item.second; + if (ASR::is_a(*var_sym)) { + ASR::Variable_t *v = ASR:: down_cast(var_sym); + ASR::ttype_t* v_type = ASRUtils::type_get_past_pointer(v->m_type); + if( ASR::is_a(*v_type) ) { + ASR::Class_t* v_class_t = ASR::down_cast(v_type); + class_type_names.insert(ASRUtils::symbol_name(v_class_t->m_class_type)); + } + } else if (ASR::is_a( + *ASRUtils::symbol_get_past_external(var_sym))) { + struct_types.push_back(var_sym); + } + } + collect_class_type_names_and_struct_types(class_type_names, struct_types, x_symtab->parent); + } + template - void declare_vars(const T &x) { + void declare_vars(const T &x, bool create_vtabs=true) { llvm::Value *target_var; uint32_t debug_arg_count = 0; std::vector var_order = ASRUtils::determine_variable_declaration_order(x.m_symtab); + if( create_vtabs ) { + std::set class_type_names; + std::vector struct_types; + collect_class_type_names_and_struct_types(class_type_names, struct_types, x.m_symtab); + for( size_t i = 0; i < struct_types.size(); i++ ) { + ASR::symbol_t* struct_type = struct_types[i]; + bool create_vtab = false; + for( const std::string& class_name: class_type_names ) { + ASR::symbol_t* class_sym = x.m_symtab->resolve_symbol(class_name); + bool is_vtab_needed = false; + while( !is_vtab_needed && struct_type ) { + if( struct_type == class_sym ) { + is_vtab_needed = true; + } else { + struct_type = ASR::down_cast( + ASRUtils::symbol_get_past_external(struct_type))->m_parent; + } + } + if( is_vtab_needed ) { + create_vtab = true; + break; + } + } + if( create_vtab ) { + create_vtab_for_struct_type( + ASRUtils::symbol_get_past_external(struct_types[i]), + x.m_symtab); + } + } + } for (auto &item : var_order) { ASR::symbol_t* var_sym = x.m_symtab->get_symbol(item); if (is_a(*var_sym)) { @@ -3015,6 +3321,10 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } llvm_symtab[h] = ptr; + auto finder = std::find(nested_globals.begin(), nested_globals.end(), h); + if (finder != nested_globals.end() && !is_array_type && !is_malloc_array_type && !is_list) { + nested_globals_value[h] = ptr; + } fill_array_details_(ptr, m_dims, n_dims, is_malloc_array_type, is_array_type, is_list, v->m_type); @@ -3132,10 +3442,13 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } case (ASR::ttypeType::Pointer) : { ASR::ttype_t *t2 = ASRUtils::type_get_past_pointer(asr_type); + bool is_pointer_ = ASR::is_a(*t2); type = get_arg_type_from_ttype_t(t2, m_abi, arg_m_abi, m_storage, arg_m_value_attr, n_dims, a_kind, is_array_type, arg_intent, get_pointer); - type = type->getPointerTo(); + if( !is_pointer_ ) { + type = type->getPointerTo(); + } break; } case (ASR::ttypeType::Const) : { @@ -3284,7 +3597,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor type = arr_descr->get_array_type(asr_type, el_type, get_pointer); } } else { - type = getClassType(asr_type, true); + type = getClassType(asr_type, true)->getPointerTo(); } break; } @@ -3545,6 +3858,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } void visit_Function(const ASR::Function_t &x) { + SymbolTable* current_scope_copy = current_scope; + current_scope = x.m_symtab; bool is_dict_present_copy_lp = dict_api_lp->is_dict_present(); bool is_dict_present_copy_sc = dict_api_sc->is_dict_present(); dict_api_lp->set_is_dict_present(false); @@ -3564,6 +3879,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor // Finalize the debug info. if (compiler_options.emit_debug_info) DBuilder->finalize(); + current_scope = current_scope_copy; } void instantiate_function(const ASR::Function_t &x){ @@ -3582,6 +3898,14 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor F = llvm_symtab_fn[h]; } else { llvm::FunctionType* function_type = get_function_type(x); + if( ASRUtils::get_FunctionType(x)->m_deftype == ASR::deftypeType::Interface ) { + ASR::FunctionType_t* asr_function_type = ASRUtils::get_FunctionType(x); + for( size_t i = 0; i < asr_function_type->n_arg_types; i++ ) { + if( ASR::is_a(*asr_function_type->m_arg_types[i]) ) { + return ; + } + } + } std::string fn_name; if (ASRUtils::get_FunctionType(x)->m_abi == ASR::abiType::BindC) { if (ASRUtils::get_FunctionType(x)->m_bindc_name) { @@ -4116,12 +4440,157 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } } + void visit_PointerAssociated(const ASR::PointerAssociated_t& x) { + if (x.m_value) { + this->visit_expr_wrapper(x.m_value, true); + return; + } + ASR::Variable_t *p = EXPR2VAR(x.m_ptr); + uint32_t value_h = get_hash((ASR::asr_t*)p); + llvm::Value *ptr = llvm_symtab[value_h], *nptr; + ptr = CreateLoad(ptr); + ptr = builder->CreatePtrToInt(ptr, getIntType(8, false)); + if (x.m_tgt) { + ASR::Variable_t *t = EXPR2VAR(x.m_tgt); + uint32_t t_h = get_hash((ASR::asr_t*)t); + nptr = llvm_symtab[t_h]; + nptr = builder->CreatePtrToInt(nptr, getIntType(8, false)); + tmp = builder->CreateICmpEQ(ptr, nptr); + } else { + llvm::Type* value_type = get_type_from_ttype_t_util(p->m_type); + nptr = llvm::ConstantPointerNull::get(static_cast(value_type)); + nptr = builder->CreatePtrToInt(nptr, getIntType(8, false)); + tmp = builder->CreateICmpNE(ptr, nptr); + } + } + void visit_Associate(const ASR::Associate_t& x) { ASR::Variable_t *asr_target = EXPR2VAR(x.m_target); ASR::Variable_t *asr_value = EXPR2VAR(x.m_value); uint32_t value_h = get_hash((ASR::asr_t*)asr_value); uint32_t target_h = get_hash((ASR::asr_t*)asr_target); - builder->CreateStore(llvm_symtab[value_h], llvm_symtab[target_h]); + llvm::Value* llvm_target = llvm_symtab[target_h]; + llvm::Value* llvm_value = llvm_symtab[value_h]; + ASR::ttype_t *type = ASRUtils::get_contained_type(asr_target->m_type); + if (ASR::is_a(*type)) { + int dims = ASR::down_cast(type)->n_dims; + if (dims == 0) { + builder->CreateStore(CreateLoad(llvm_value), + llvm_target); + return; + } + } + bool is_target_class = ASR::is_a( + *ASRUtils::type_get_past_pointer(asr_target->m_type)); + bool is_value_class = ASR::is_a( + *ASRUtils::type_get_past_pointer(asr_value->m_type)); + if( is_target_class && !is_value_class ) { + llvm::Value* vtab_address_ptr = llvm_utils->create_gep(llvm_target, 0); + llvm_target = llvm_utils->create_gep(llvm_target, 1); + ASR::Struct_t* struct_t = ASR::down_cast( + ASRUtils::type_get_past_pointer(asr_value->m_type)); + ASR::symbol_t* struct_sym = ASRUtils::symbol_get_past_external(struct_t->m_derived_type); + if (type2vtab.find(struct_sym) == type2vtab.end() || + type2vtab[struct_sym].find(current_scope) == type2vtab[struct_sym].end()) { + create_vtab_for_struct_type(struct_sym, current_scope); + } + llvm::Value* vtab_obj = type2vtab[struct_sym][current_scope]; + llvm::Value* struct_type_hash = CreateLoad(llvm_utils->create_gep(vtab_obj, 0)); + builder->CreateStore(struct_type_hash, vtab_address_ptr); + + ASR::Class_t* class_t = ASR::down_cast( + ASRUtils::type_get_past_pointer(asr_target->m_type)); + ASR::StructType_t* struct_type_t = ASR::down_cast( + ASRUtils::symbol_get_past_external(class_t->m_class_type)); + llvm_value = builder->CreateBitCast(llvm_value, getStructType(struct_type_t, true)); + builder->CreateStore(llvm_value, llvm_target); + } else if( is_target_class && is_value_class ) { + ASR::Class_t* target_class_t = ASR::down_cast( + ASRUtils::type_get_past_pointer(asr_target->m_type)); + ASR::Class_t* value_class_t = ASR::down_cast( + ASRUtils::type_get_past_pointer(asr_target->m_type)); + LCOMPILERS_ASSERT(target_class_t->m_class_type == value_class_t->m_class_type); + llvm::Value* value_vtabid = CreateLoad(llvm_utils->create_gep(llvm_value, 0)); + llvm::Value* value_class = CreateLoad(llvm_utils->create_gep(llvm_value, 1)); + builder->CreateStore(value_vtabid, llvm_utils->create_gep(llvm_target, 0)); + builder->CreateStore(value_class, llvm_utils->create_gep(llvm_target, 1)); + } else { + builder->CreateStore(llvm_value, llvm_target); + } + + } + + void handle_StringSection_Assignment(ASR::expr_t *target, ASR::expr_t *value) { + // Handles the case when LHS of assignment is string. + std::string runtime_func_name = "_lfortran_str_slice_assign"; + llvm::Function *fn = module->getFunction(runtime_func_name); + if (!fn) { + llvm::FunctionType *function_type = llvm::FunctionType::get( + character_type, { + character_type, character_type, llvm::Type::getInt32Ty(context), + llvm::Type::getInt32Ty(context), llvm::Type::getInt32Ty(context), + llvm::Type::getInt1Ty(context), llvm::Type::getInt1Ty(context) + }, false); + fn = llvm::Function::Create(function_type, + llvm::Function::ExternalLinkage, runtime_func_name, *module); + } + ASR::StringSection_t *ss = ASR::down_cast(target); + llvm::Value *lp, *rp; + llvm::Value *str, *idx1, *idx2, *step, *str_val; + int ptr_load_copy = ptr_loads; + ptr_loads = 0; + this->visit_expr_wrapper(ss->m_arg, true); + str = tmp; + ptr_loads = ptr_load_copy; + this->visit_expr_wrapper(value, true); + str_val = tmp; + if (!ss->m_start && !ss->m_end) { + if (ASR::is_a(*ss->m_arg)) { + ASR::Variable_t *asr_target = EXPR2VAR(ss->m_arg); + if (asr_target->m_storage == ASR::storage_typeType::Allocatable) { + tmp = lfortran_str_copy(str, str_val); + return; + } + } + builder->CreateStore(str_val, str); + return; + } + if (ss->m_start) { + this->visit_expr_wrapper(ss->m_start, true); + idx1 = tmp; + lp = llvm::ConstantInt::get(context, + llvm::APInt(1, 1)); + } else { + lp = llvm::ConstantInt::get(context, + llvm::APInt(1, 0)); + idx1 = llvm::Constant::getNullValue(llvm::Type::getInt32Ty(context)); + } + if (ss->m_end) { + this->visit_expr_wrapper(ss->m_end, true); + idx2 = tmp; + rp = llvm::ConstantInt::get(context, + llvm::APInt(1, 1)); + } else { + rp = llvm::ConstantInt::get(context, + llvm::APInt(1, 0)); + idx2 = llvm::Constant::getNullValue(llvm::Type::getInt32Ty(context)); + } + if (ss->m_step) { + this->visit_expr_wrapper(ss->m_step, true); + step = tmp; + } else { + step = llvm::ConstantInt::get(context, + llvm::APInt(32, 0)); + } + tmp = builder->CreateCall(fn, {CreateLoad(str), str_val, idx1, idx2, step, lp, rp}); + if (ASR::is_a(*ss->m_arg)) { + ASR::Variable_t *asr_target = EXPR2VAR(ss->m_arg); + if (asr_target->m_storage == ASR::storage_typeType::Allocatable) { + tmp = lfortran_str_copy(str, tmp); + return; + } + } + builder->CreateStore(tmp, str); } void visit_Assignment(const ASR::Assignment_t &x) { @@ -4141,6 +4610,10 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor bool is_value_dict = ASR::is_a(*asr_value_type); bool is_target_struct = ASR::is_a(*asr_target_type); bool is_value_struct = ASR::is_a(*asr_value_type); + if (ASR::is_a(*x.m_target)) { + handle_StringSection_Assignment(x.m_target, x.m_value); + return; + } if( is_target_list && is_value_list ) { int64_t ptr_loads_copy = ptr_loads; ptr_loads = 0; @@ -4323,7 +4796,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } if( arr_descr->is_array(ASRUtils::get_contained_type(asr_target_type)) ) { if( asr_target->m_type->type == - ASR::ttypeType::Character ) { + ASR::ttypeType::Character) { target = CreateLoad(arr_descr->get_pointer_to_data(target)); } } @@ -4345,6 +4818,13 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor if (lhs_is_string_arrayref) { value = CreateLoad(value); } + if (ASR::is_a(*x.m_target)) { + ASR::Variable_t *asr_target = EXPR2VAR(x.m_target); + if (asr_target->m_storage == ASR::storage_typeType::Allocatable) { + tmp = lfortran_str_copy(target, value); + return; + } + } } } if( ASRUtils::is_array(target_type) && @@ -4420,6 +4900,8 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor nested_global_struct); int idx = std::distance(nested_globals.begin(), finder); builder->CreateStore(target, llvm_utils->create_gep(ptr, idx)); + // remove from nested_globals_value + nested_globals_value.erase(h); } if (is_a(*x.m_target)) { ASR::ArrayItem_t *asr_target0 = ASR::down_cast(x.m_target); @@ -4477,15 +4959,6 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } void visit_BlockCall(const ASR::BlockCall_t& x) { - /* The current `in_block` implementation has the following limitations: - * - Does not work for nested blocks. To fix it there, we should change - * it to an integer and keep incrementing it for each block. - * - Combining blocks and loops. - * - The label in `exit` is currently ignored, so we only jump to the - * inner most label. Instead we need to jump to the actual label - * provided. - */ - in_block = true; if( x.m_label != -1 ) { if( llvm_goto_targets.find(x.m_label) == llvm_goto_targets.end() ) { llvm::BasicBlock *new_target = llvm::BasicBlock::Create(context, "goto_target"); @@ -4496,40 +4969,188 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor LCOMPILERS_ASSERT(ASR::is_a(*x.m_m)); ASR::Block_t* block = ASR::down_cast(x.m_m); declare_vars(*block); - std::string block_name = std::string(block->m_name); - std::string block_end_name = "block_"+block_name+"_end"; - llvm::BasicBlock *block_start = llvm::BasicBlock::Create(context, "block_"+block_name+"_start"); - start_new_block(block_start); - llvm::BasicBlock *block_end = llvm::BasicBlock::Create(context, "block_"+block_name+"_end"); - llvm::Function *fn = block_start->getParent(); - fn->getBasicBlockList().push_back(block_end); - builder->SetInsertPoint(block_start); - block_end_label = block_end; + std::string block_name; + if (block->m_name) { + block_name = std::string(block->m_name); + } else { + block_name = "block"; + } + std::string blockstart_name = block_name + ".start"; + std::string blockend_name = block_name + ".end"; + llvm::BasicBlock *blockstart = llvm::BasicBlock::Create(context, blockstart_name); + start_new_block(blockstart); + llvm::BasicBlock *blockend = llvm::BasicBlock::Create(context, blockend_name); + llvm::Function *fn = blockstart->getParent(); + fn->getBasicBlockList().push_back(blockend); + builder->SetInsertPoint(blockstart); + loop_or_block_end.push_back(blockend); + loop_or_block_end_names.push_back(blockend_name); for (size_t i = 0; i < block->n_body; i++) { this->visit_stmt(*(block->m_body[i])); } + loop_or_block_end.pop_back(); + loop_or_block_end_names.pop_back(); llvm::BasicBlock *last_bb = builder->GetInsertBlock(); llvm::Instruction *block_terminator = last_bb->getTerminator(); if (block_terminator == nullptr) { // The previous block is not terminated --- terminate it by jumping - // to block_end - builder->CreateBr(block_end); + // to blockend + builder->CreateBr(blockend); } - builder->SetInsertPoint(block_end); - in_block=false; + builder->SetInsertPoint(blockend); } - inline void visit_expr_wrapper(const ASR::expr_t* x, bool load_ref=false) { + inline void visit_expr_wrapper(ASR::expr_t* x, bool load_ref=false) { this->visit_expr(*x); if( x->type == ASR::exprType::ArrayItem || x->type == ASR::exprType::ArraySection || x->type == ASR::exprType::StructInstanceMember ) { - if( load_ref ) { + if( load_ref && + !ASRUtils::is_value_constant(ASRUtils::expr_value(x)) ) { tmp = CreateLoad(tmp); } } } + void fill_type_stmt(const ASR::SelectType_t& x, + std::vector& type_stmt_order, + ASR::type_stmtType type_stmt_type) { + for( size_t i = 0; i < x.n_body; i++ ) { + if( x.m_body[i]->type == type_stmt_type ) { + type_stmt_order.push_back(x.m_body[i]); + } + } + } + + void visit_SelectType(const ASR::SelectType_t& x) { + LCOMPILERS_ASSERT(ASR::is_a(*x.m_selector)); + // Process TypeStmtName first, then ClassStmt + std::vector select_type_stmts; + fill_type_stmt(x, select_type_stmts, ASR::type_stmtType::TypeStmtName); + fill_type_stmt(x, select_type_stmts, ASR::type_stmtType::TypeStmtType); + fill_type_stmt(x, select_type_stmts, ASR::type_stmtType::ClassStmt); + LCOMPILERS_ASSERT(x.n_body == select_type_stmts.size()); + ASR::Var_t* selector_var = ASR::down_cast(x.m_selector); + uint64_t ptr_loads_copy = ptr_loads; + ptr_loads = 0; + visit_Var(*selector_var); + ptr_loads = ptr_loads_copy; + llvm::Value* llvm_selector = tmp; + llvm::BasicBlock *mergeBB = llvm::BasicBlock::Create(context, "ifcont"); + for( size_t i = 0; i < select_type_stmts.size(); i++ ) { + llvm::Function *fn = builder->GetInsertBlock()->getParent(); + + llvm::BasicBlock *thenBB = llvm::BasicBlock::Create(context, "then", fn); + llvm::BasicBlock *elseBB = llvm::BasicBlock::Create(context, "else"); + + llvm::Value* cond = nullptr; + ASR::stmt_t** type_block = nullptr; + size_t n_type_block = 0; + switch( select_type_stmts[i]->type ) { + case ASR::type_stmtType::TypeStmtName: { + llvm::Value* vptr_int_hash = CreateLoad(llvm_utils->create_gep(llvm_selector, 0)); + ASR::ttype_t* selector_var_type = ASRUtils::expr_type(x.m_selector); + if( ASRUtils::is_array(selector_var_type) ) { + vptr_int_hash = CreateLoad(llvm_utils->create_gep(vptr_int_hash, 0)); + } + ASR::TypeStmtName_t* type_stmt_name = ASR::down_cast(select_type_stmts[i]); + ASR::symbol_t* type_sym = ASRUtils::symbol_get_past_external(type_stmt_name->m_sym); + if( ASR::is_a(*type_sym) ) { + current_select_type_block_type = getStructType( + ASR::down_cast(type_sym), true); + current_select_type_block_der_type = ASR::down_cast(type_sym)->m_name; + } else { + LCOMPILERS_ASSERT(false); + } + if (type2vtab.find(type_sym) == type2vtab.end() && + type2vtab[type_sym].find(current_scope) == type2vtab[type_sym].end()) { + create_vtab_for_struct_type(type_sym, current_scope); + } + llvm::Value* type_sym_vtab = type2vtab[type_sym][current_scope]; + cond = builder->CreateICmpEQ( + vptr_int_hash, + CreateLoad( llvm_utils->create_gep(type_sym_vtab, 0) ) ); + type_block = type_stmt_name->m_body; + n_type_block = type_stmt_name->n_body; + break ; + } + case ASR::type_stmtType::ClassStmt: { + llvm::Value* vptr_int_hash = CreateLoad(llvm_utils->create_gep(llvm_selector, 0)); + ASR::ClassStmt_t* class_stmt = ASR::down_cast(select_type_stmts[i]); + ASR::symbol_t* class_sym = ASRUtils::symbol_get_past_external(class_stmt->m_sym); + if( ASR::is_a(*class_sym) ) { + current_select_type_block_type = getStructType( + ASR::down_cast(class_sym), true); + current_select_type_block_der_type = ASR::down_cast(class_sym)->m_name; + } else { + LCOMPILERS_ASSERT(false); + } + + std::vector& class_sym_vtabs = class2vtab[class_sym][current_scope]; + std::vector conds; + conds.reserve(class_sym_vtabs.size()); + for( size_t i = 0; i < class_sym_vtabs.size(); i++ ) { + conds.push_back(builder->CreateICmpEQ( + vptr_int_hash, + CreateLoad(llvm_utils->create_gep(class_sym_vtabs[i], 0)) )); + } + cond = builder->CreateOr(conds); + type_block = class_stmt->m_body; + n_type_block = class_stmt->n_body; + break ; + } + case ASR::type_stmtType::TypeStmtType: { + ASR::ttype_t* selector_var_type = ASRUtils::expr_type(x.m_selector); + ASR::TypeStmtType_t* type_stmt_type_t = ASR::down_cast(select_type_stmts[i]); + ASR::ttype_t* type_stmt_type = type_stmt_type_t->m_type; + current_select_type_block_type = get_type_from_ttype_t_util(type_stmt_type)->getPointerTo(); + llvm::Value* intrinsic_type_id = llvm::ConstantInt::get(getIntType(8), + llvm::APInt(64, -((int) type_stmt_type->type) - + ASRUtils::extract_kind_from_ttype_t(type_stmt_type), true)); + llvm::Value* _type_id = nullptr; + if( ASRUtils::is_array(selector_var_type) ) { + llvm::Value* data_ptr = CreateLoad(arr_descr->get_pointer_to_data(llvm_selector)); + _type_id = CreateLoad(llvm_utils->create_gep(data_ptr, 0)); + } else { + _type_id = CreateLoad(llvm_utils->create_gep(llvm_selector, 0)); + } + cond = builder->CreateICmpEQ(_type_id, intrinsic_type_id); + type_block = type_stmt_type_t->m_body; + n_type_block = type_stmt_type_t->n_body; + break; + } + default: { + throw CodeGenError("ASR::type_stmtType, " + + std::to_string(x.m_body[i]->type) + + " is not yet supported."); + } + } + builder->CreateCondBr(cond, thenBB, elseBB); + builder->SetInsertPoint(thenBB); + { + if( n_type_block == 1 && ASR::is_a(*type_block[0]) ) { + ASR::BlockCall_t* block_call = ASR::down_cast(type_block[0]); + ASR::Block_t* block_t = ASR::down_cast(block_call->m_m); + declare_vars(*block_t, false); + for( size_t j = 0; j < block_t->n_body; j++ ) { + this->visit_stmt(*block_t->m_body[j]); + } + } + } + builder->CreateBr(mergeBB); + + start_new_block(elseBB); + current_select_type_block_type = nullptr; + current_select_type_block_der_type.clear(); + } + if( x.n_default > 0 ) { + for( size_t i = 0; i < x.n_default; i++ ) { + this->visit_stmt(*x.m_default[i]); + } + } + start_new_block(mergeBB); + } + void visit_IntegerCompare(const ASR::IntegerCompare_t &x) { if (x.m_value) { this->visit_expr_wrapper(x.m_value, true); @@ -4765,8 +5386,12 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor tmp = builder->CreateSelect(cond, then_val, else_val); } + // TODO: Implement visit_DooLoop + //void visit_DoLoop(const ASR::DoLoop_t &x) { + //} + void visit_WhileLoop(const ASR::WhileLoop_t &x) { - create_loop([=]() { + create_loop(x.m_name, [=]() { this->visit_expr_wrapper(x.m_test, true); return tmp; }, [=]() { @@ -4776,22 +5401,60 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor }); } - void visit_Exit(const ASR::Exit_t & /* x */) { - if ( in_block ) { - // If we are in a block, we need to exit the block. - // This is done by jumping to the end of the block. - builder->CreateBr(block_end_label); - llvm::BasicBlock *bb = llvm::BasicBlock::Create(context, "unreachable_after_exit_block"); - start_new_block(bb); + bool case_insensitive_string_compare(const std::string& str1, const std::string& str2) { + if (str1.size() != str2.size()) { + return false; + } + for (std::string::const_iterator c1 = str1.begin(), c2 = str2.begin(); c1 != str1.end(); ++c1, ++c2) { + if (tolower(static_cast(*c1)) != tolower(static_cast(*c2))) { + return false; + } + } + return true; + } + + void visit_Exit(const ASR::Exit_t &x) { + if (x.m_stmt_name) { + std::string stmt_name = std::string(x.m_stmt_name) + ".end"; + int nested_block_depth = loop_or_block_end_names.size(); + int i = nested_block_depth - 1; + for (; i >= 0; i--) { + if (case_insensitive_string_compare(loop_or_block_end_names[i], stmt_name)) { + break; + } + } + if (i >= 0) { + builder->CreateBr(loop_or_block_end[i]); + } else { + throw CodeGenError("Could not find block or loop named " + std::string(x.m_stmt_name) + " in parent scope to exit from.", + x.base.base.loc); + } } else { - builder->CreateBr(current_loopend); - llvm::BasicBlock *bb = llvm::BasicBlock::Create(context, "unreachable_after_exit"); - start_new_block(bb); + builder->CreateBr(loop_or_block_end.back()); } + llvm::BasicBlock *bb = llvm::BasicBlock::Create(context, "unreachable_after_exit"); + start_new_block(bb); } - void visit_Cycle(const ASR::Cycle_t & /* x */) { - builder->CreateBr(current_loophead); + void visit_Cycle(const ASR::Cycle_t &x) { + if (x.m_stmt_name) { + std::string stmt_name = std::string(x.m_stmt_name) + ".head"; + int nested_block_depth = loop_head_names.size(); + int i = nested_block_depth - 1; + for (; i >= 0; i--) { + if (case_insensitive_string_compare(loop_head_names[i], stmt_name)) { + break; + } + } + if (i >= 0) { + builder->CreateBr(loop_head[i]); + } else { + throw CodeGenError("Could not find loop named " + std::string(x.m_stmt_name) + " in parent scope to cycle to.", + x.base.base.loc); + } + } else { + builder->CreateBr(loop_head.back()); + } llvm::BasicBlock *bb = llvm::BasicBlock::Create(context, "unreachable_after_cycle"); start_new_block(bb); } @@ -5439,7 +6102,34 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor this->visit_expr_wrapper(x.m_value, true); return; } - throw CodeGenError("ComplexConstructor with runtime arguments not implemented yet."); + this->visit_expr_wrapper(x.m_re, true); + llvm::Value *re_val = tmp; + + this->visit_expr_wrapper(x.m_im, true); + llvm::Value *im_val = tmp; + + int a_kind = ASRUtils::extract_kind_from_ttype_t(x.m_type); + + llvm::Value *re2, *im2; + llvm::Type *type; + switch( a_kind ) { + case 4: { + re2 = builder->CreateFPTrunc(re_val, llvm::Type::getFloatTy(context)); + im2 = builder->CreateFPTrunc(im_val, llvm::Type::getFloatTy(context)); + type = complex_type_4; + break; + } + case 8: { + re2 = builder->CreateFPExt(re_val, llvm::Type::getDoubleTy(context)); + im2 = builder->CreateFPExt(im_val, llvm::Type::getDoubleTy(context)); + type = complex_type_8; + break; + } + default: { + throw CodeGenError("kind type is not supported"); + } + } + tmp = complex_from_floats(re2, im2, type); } void visit_ComplexConstant(const ASR::ComplexConstant_t &x) { @@ -5554,10 +6244,14 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor case ASR::ttypeType::Integer: case ASR::ttypeType::Real: case ASR::ttypeType::Complex: - case ASR::ttypeType::Struct: { + case ASR::ttypeType::Struct: + case ASR::ttypeType::Class: { if( t2->type == ASR::ttypeType::Struct ) { ASR::Struct_t* d = ASR::down_cast(t2); der_type_name = ASRUtils::symbol_name(d->m_derived_type); + } else if( t2->type == ASR::ttypeType::Class ) { + ASR::Class_t* d = ASR::down_cast(t2); + der_type_name = ASRUtils::symbol_name(d->m_class_type); } fetch_ptr(x); break; @@ -5595,9 +6289,14 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } case ASR::ttypeType::Class: { ASR::Class_t* der = ASR::down_cast(x->m_type); - ASR::ClassType_t* der_type = ASR::down_cast( - ASRUtils::symbol_get_past_external(der->m_class_type)); - der_type_name = std::string(der_type->m_name); + ASR::symbol_t* der_sym = ASRUtils::symbol_get_past_external(der->m_class_type); + if( ASR::is_a(*der_sym) ) { + ASR::ClassType_t* der_type = ASR::down_cast(der_sym); + der_type_name = std::string(der_type->m_name); + } else if( ASR::is_a(*der_sym) ) { + ASR::StructType_t* der_type = ASR::down_cast(der_sym); + der_type_name = std::string(der_type->m_name); + } uint32_t h = get_hash((ASR::asr_t*)x); if( llvm_symtab.find(h) != llvm_symtab.end() ) { tmp = llvm_symtab[h]; @@ -5992,19 +6691,96 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } } + llvm::Function* get_read_function(ASR::ttype_t *type) { + if (ASR::is_a(*type)) { + std::string runtime_func_name = "_lfortran_read_int32"; + llvm::Function *fn = module->getFunction(runtime_func_name); + if (!fn) { + llvm::FunctionType *function_type = llvm::FunctionType::get( + llvm::Type::getVoidTy(context), { + llvm::Type::getInt32Ty(context)->getPointerTo(), + llvm::Type::getInt32Ty(context) + }, false); + fn = llvm::Function::Create(function_type, + llvm::Function::ExternalLinkage, runtime_func_name, *module); + } + return fn; + } else { + throw CodeGenError("Read function not implemented"); + } + } + void visit_FileRead(const ASR::FileRead_t &x) { if (x.m_fmt != nullptr) { diag.codegen_warning_label("format string in read() is not implemented yet and it is currently treated as '*'", {x.m_fmt->base.loc}, "treated as '*'"); } - if (x.m_unit != nullptr) { - diag.codegen_error_label("unit in read() is not implemented yet", - {x.m_unit->base.loc}, "not implemented"); - throw CodeGenAbort(); + llvm::Value *unit_val; + if (x.m_unit == nullptr) { + // Read from stdin + unit_val = llvm::ConstantInt::get( + llvm::Type::getInt32Ty(context), llvm::APInt(32, -1)); + } else { + this->visit_expr_wrapper(x.m_unit, true); + unit_val = tmp; + } + for (size_t i=0; ivisit_expr(*x.m_values[i]); + ptr_loads = ptr_copy; + llvm::Function *fn = get_read_function( + ASRUtils::expr_type(x.m_values[i])); + builder->CreateCall(fn, {tmp, unit_val}); + } + } + + void visit_FileOpen(const ASR::FileOpen_t &x) { + llvm::Value *unit_val = nullptr, *f_name = nullptr; + llvm::Value *status = nullptr; + this->visit_expr_wrapper(x.m_newunit, true); + unit_val = tmp; + if (x.m_filename) { + this->visit_expr_wrapper(x.m_filename, true); + f_name = tmp; + } else { + f_name = llvm::Constant::getNullValue(character_type); } - diag.codegen_error_label("The intrinsic function read() is not implemented yet in the LLVM backend", - {x.base.base.loc}, "not implemented"); - throw CodeGenAbort(); + if (x.m_status) { + this->visit_expr_wrapper(x.m_status, true); + status = tmp; + } else { + status = llvm::Constant::getNullValue(character_type); + } + std::string runtime_func_name = "_lfortran_open"; + llvm::Function *fn = module->getFunction(runtime_func_name); + if (!fn) { + llvm::FunctionType *function_type = llvm::FunctionType::get( + llvm::Type::getInt64Ty(context), { + llvm::Type::getInt32Ty(context), + character_type, character_type + }, false); + fn = llvm::Function::Create(function_type, + llvm::Function::ExternalLinkage, runtime_func_name, *module); + } + tmp = builder->CreateCall(fn, {unit_val, f_name, status}); + } + + void visit_FileClose(const ASR::FileClose_t &x) { + llvm::Value *unit_val = nullptr; + this->visit_expr_wrapper(x.m_unit, true); + unit_val = tmp; + std::string runtime_func_name = "_lfortran_close"; + llvm::Function *fn = module->getFunction(runtime_func_name); + if (!fn) { + llvm::FunctionType *function_type = llvm::FunctionType::get( + llvm::Type::getVoidTy(context), { + llvm::Type::getInt32Ty(context), + }, false); + fn = llvm::Function::Create(function_type, + llvm::Function::ExternalLinkage, runtime_func_name, *module); + } + tmp = builder->CreateCall(fn, {unit_val}); } void visit_Print(const ASR::Print_t &x) { @@ -6262,7 +7038,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor template - std::vector convert_call_args(const T &x) { + std::vector convert_call_args(const T &x, bool is_method) { std::vector args; const ASR::symbol_t* func_subrout = symbol_get_past_external(x.m_name); ASR::abiType x_abi = ASR::abiType::Source; @@ -6280,12 +7056,12 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor std::string orig_arg_name = ""; if( func_subrout->type == ASR::symbolType::Function ) { ASR::Function_t* func = down_cast(func_subrout); - set_func_subrout_params(func, x_abi, m_h, orig_arg, orig_arg_name, orig_arg_intent, i); + set_func_subrout_params(func, x_abi, m_h, orig_arg, orig_arg_name, orig_arg_intent, i + is_method); } else if( func_subrout->type == ASR::symbolType::ClassProcedure ) { ASR::ClassProcedure_t* clss_proc = ASR::down_cast(func_subrout); if( clss_proc->m_proc->type == ASR::symbolType::Function ) { ASR::Function_t* func = down_cast(clss_proc->m_proc); - set_func_subrout_params(func, x_abi, m_h, orig_arg, orig_arg_name, orig_arg_intent, i); + set_func_subrout_params(func, x_abi, m_h, orig_arg, orig_arg_name, orig_arg_intent, i + is_method); } } else { LCOMPILERS_ASSERT(false) @@ -6319,8 +7095,10 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor ASR::dimension_t* dims; size_t n; n = ASRUtils::extract_dimensions_from_ttype(orig_arg->m_type, dims); - tmp = arr_descr->convert_to_argument(tmp, arg->m_type, new_arr_type, - (!ASRUtils::is_dimension_empty(dims, n))); + if( !ASRUtils::is_abstract_class_type( ASRUtils::type_get_past_pointer(orig_arg->m_type) ) ) { + tmp = arr_descr->convert_to_argument(tmp, arg->m_type, new_arr_type, + (!ASRUtils::is_dimension_empty(dims, n))); + } } else if (x_abi == ASR::abiType::Source && ASR::is_a(*arg->m_type)) { if (arg->m_intent == intent_local) { // Local variable of type @@ -6453,6 +7231,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor x.m_args[i].m_value)->m_v)); uint32_t h = get_hash((ASR::asr_t*)fn); if (ASRUtils::get_FunctionType(fn)->m_deftype == ASR::deftypeType::Implementation) { + LCOMPILERS_ASSERT(llvm_symtab_fn.find(h) != llvm_symtab_fn.end()); tmp = llvm_symtab_fn[h]; } else { // Must be an argument/chained procedure pass @@ -6604,6 +7383,14 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } } } + // To avoid segmentation faults when original argument + // is not a ASR::Variable_t like callbacks. + if( orig_arg && !ASR::is_a( + *ASRUtils::type_get_past_pointer(ASRUtils::expr_type(x.m_args[i].m_value))) ) { + tmp = convert_to_polymorphic_arg(tmp, + ASRUtils::type_get_past_pointer(orig_arg->m_type), + ASRUtils::type_get_past_pointer(ASRUtils::expr_type(x.m_args[i].m_value))); + } args.push_back(tmp); } return args; @@ -6672,6 +7459,76 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor return false; } + int get_class_hash(ASR::symbol_t* class_sym) { + if( type2vtabid.find(class_sym) == type2vtabid.end() ) { + type2vtabid[class_sym] = type2vtabid.size(); + } + return type2vtabid[class_sym]; + } + + llvm::Value* convert_to_polymorphic_arg(llvm::Value* dt, + ASR::ttype_t* s_m_args0_type, ASR::ttype_t* arg_type) { + if( !ASR::is_a(*s_m_args0_type) ) { + return dt; + } + + if( ASRUtils::is_abstract_class_type(s_m_args0_type) ) { + if( ASRUtils::is_array(s_m_args0_type) ) { + llvm::Type* array_type = get_type_from_ttype_t_util(s_m_args0_type); + llvm::Value* abstract_array = builder->CreateAlloca(array_type); + llvm::Type* array_data_type = get_el_type(s_m_args0_type); + llvm::Value* array_data = builder->CreateAlloca(array_data_type); + builder->CreateStore(array_data, + arr_descr->get_pointer_to_data(abstract_array)); + arr_descr->fill_array_details(dt, abstract_array, s_m_args0_type, true); + llvm::Value* polymorphic_data = CreateLoad( + arr_descr->get_pointer_to_data(abstract_array)); + llvm::Value* polymorphic_data_addr = llvm_utils->create_gep(polymorphic_data, 1); + llvm::Value* dt_data = CreateLoad(arr_descr->get_pointer_to_data(dt)); + builder->CreateStore( + builder->CreateBitCast(dt_data, llvm::Type::getVoidTy(context)->getPointerTo()), + polymorphic_data_addr); + llvm::Value* type_id_addr = llvm_utils->create_gep(polymorphic_data, 0); + builder->CreateStore( + llvm::ConstantInt::get(getIntType(8), + llvm::APInt(64, -((int) arg_type->type) - + ASRUtils::extract_kind_from_ttype_t(arg_type), true)), + type_id_addr); + return abstract_array; + } else { + llvm::Type* _type = get_type_from_ttype_t_util(s_m_args0_type); + llvm::Value* abstract_ = builder->CreateAlloca(_type); + llvm::Value* polymorphic_addr = llvm_utils->create_gep(abstract_, 1); + builder->CreateStore( + builder->CreateBitCast(dt, llvm::Type::getVoidTy(context)->getPointerTo()), + polymorphic_addr); + llvm::Value* type_id_addr = llvm_utils->create_gep(abstract_, 0); + ASR::Struct_t* struct_t = ASR::down_cast(arg_type); + ASR::symbol_t* struct_sym = ASRUtils::symbol_get_past_external(struct_t->m_derived_type); + llvm::Value* hash = llvm::ConstantInt::get(getIntType(8), + llvm::APInt(64, get_class_hash(struct_sym))); + builder->CreateStore(hash, type_id_addr); + return abstract_; + } + } else if( ASR::is_a(*arg_type) ) { + ASR::Struct_t* struct_t = ASR::down_cast(arg_type); + ASR::symbol_t* struct_sym = ASRUtils::symbol_get_past_external(struct_t->m_derived_type); + if( type2vtab.find(struct_sym) == type2vtab.end() && + type2vtab[struct_sym].find(current_scope) == type2vtab[struct_sym].end() ) { + create_vtab_for_struct_type(struct_sym, current_scope); + } + llvm::Value* dt_polymorphic = builder->CreateAlloca( + getClassType(s_m_args0_type, true)); + llvm::Value* hash_ptr = llvm_utils->create_gep(dt_polymorphic, 0); + llvm::Value* hash = llvm::ConstantInt::get(getIntType(8), llvm::APInt(64, get_class_hash(struct_sym))); + builder->CreateStore(hash, hash_ptr); + llvm::Value* class_ptr = llvm_utils->create_gep(dt_polymorphic, 1); + builder->CreateStore(builder->CreateBitCast(dt, getStructType(s_m_args0_type, true)), class_ptr); + return dt_polymorphic; + } + return dt; + } + void visit_SubroutineCall(const ASR::SubroutineCall_t &x) { if (compiler_options.emit_debug_info) debug_emit_loc(x); if( ASRUtils::is_intrinsic_optimization(x.m_name) ) { @@ -6684,11 +7541,6 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor ASR::Function_t *s; std::vector args; const ASR::symbol_t *proc_sym = symbol_get_past_external(x.m_name); - if (x.m_dt){ - ASR::Variable_t *caller = EXPR2VAR(x.m_dt); - std::uint32_t h = get_hash((ASR::asr_t*)caller); - args.push_back(llvm_symtab[h]); - } if (ASR::is_a(*proc_sym)) { s = ASR::down_cast(proc_sym); } else { @@ -6696,9 +7548,22 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor ASR::ClassProcedure_t>(proc_sym); s = ASR::down_cast(clss_proc->m_proc); } + bool is_method = false; + if (x.m_dt) { + is_method = true; + ASR::Variable_t *caller = EXPR2VAR(x.m_dt); + std::uint32_t h = get_hash((ASR::asr_t*)caller); + llvm::Value* dt = llvm_symtab[h]; + ASR::ttype_t* s_m_args0_type = ASRUtils::type_get_past_pointer( + ASRUtils::expr_type(s->m_args[0])); + ASR::ttype_t* dt_type = ASRUtils::type_get_past_pointer(caller->m_type); + dt = convert_to_polymorphic_arg(dt, s_m_args0_type, dt_type); + args.push_back(dt); + } if (parent_function){ push_nested_stack(parent_function); } + std::string sub_name = s->m_name; uint32_t h; ASR::FunctionType_t* s_func_type = ASR::down_cast(s->m_function_signature); if (s_func_type->m_abi == ASR::abiType::LFortranModule) { @@ -6710,16 +7575,64 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } else if (s_func_type->m_abi == ASR::abiType::BindC) { h = get_hash((ASR::asr_t*)s); } else if (s_func_type->m_abi == ASR::abiType::Intrinsic) { + if (sub_name == "get_command_argument") { + llvm::Function *fn = module->getFunction("_lpython_get_argv"); + if (!fn) { + llvm::FunctionType *function_type = llvm::FunctionType::get( + character_type, { + llvm::Type::getInt32Ty(context) + }, false); + fn = llvm::Function::Create(function_type, + llvm::Function::ExternalLinkage, "_lpython_get_argv", *module); + } + args = convert_call_args(x, is_method); + LCOMPILERS_ASSERT(args.size() > 0); + tmp = builder->CreateCall(fn, {CreateLoad(args[0])}); + if (args.size() > 1) + builder->CreateStore(tmp, args[1]); + return; + } else if (sub_name == "get_environment_variable") { + llvm::Function *fn = module->getFunction("_lfortran_get_env_variable"); + if (!fn) { + llvm::FunctionType *function_type = llvm::FunctionType::get( + character_type, { + character_type + }, false); + fn = llvm::Function::Create(function_type, + llvm::Function::ExternalLinkage, "_lfortran_get_env_variable", *module); + } + args = convert_call_args(x, is_method); + LCOMPILERS_ASSERT(args.size() > 0); + tmp = builder->CreateCall(fn, {CreateLoad(args[0])}); + if (args.size() > 1) + builder->CreateStore(tmp, args[1]); + return; + } else if (sub_name == "execute_command_line") { + llvm::Function *fn = module->getFunction("_lfortran_exec_command"); + if (!fn) { + llvm::FunctionType *function_type = llvm::FunctionType::get( + llvm::Type::getInt32Ty(context), { + character_type + }, false); + fn = llvm::Function::Create(function_type, + llvm::Function::ExternalLinkage, "_lfortran_exec_command", *module); + } + args = convert_call_args(x, is_method); + LCOMPILERS_ASSERT(args.size() > 0); + tmp = builder->CreateCall(fn, {CreateLoad(args[0])}); + return; + } h = get_hash((ASR::asr_t*)s); } else { throw CodeGenError("ABI type not implemented yet in SubroutineCall."); } + if (llvm_symtab_fn_arg.find(h) != llvm_symtab_fn_arg.end()) { // Check if this is a callback function llvm::Value* fn = llvm_symtab_fn_arg[h]; llvm::FunctionType* fntype = llvm_symtab_fn[h]->getFunctionType(); std::string m_name = ASR::down_cast(x.m_name)->m_name; - args = convert_call_args(x); + args = convert_call_args(x, is_method); tmp = builder->CreateCall(fntype, fn, args); } else if (llvm_symtab_fn.find(h) == llvm_symtab_fn.end()) { throw CodeGenError("Subroutine code not generated for '" @@ -6727,7 +7640,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } else { llvm::Function *fn = llvm_symtab_fn[h]; std::string m_name = ASRUtils::symbol_name(x.m_name); - std::vector args2 = convert_call_args(x); + std::vector args2 = convert_call_args(x, is_method); args.insert(args.end(), args2.begin(), args2.end()); builder->CreateCall(fn, args); } @@ -6791,6 +7704,99 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor return CreateCallUtil(fn->getFunctionType(), fn, args, asr_return_type); } + void visit_RuntimePolymorphicFunctionCall(const ASR::FunctionCall_t& x, std::string proc_sym_name) { + std::vector> vtabs; + ASR::Var_t* dt_Var = ASR::down_cast(x.m_dt); + ASR::symbol_t* dt_sym = ASRUtils::symbol_get_past_external(dt_Var->m_v); + ASR::StructType_t* dt_sym_type = nullptr; + ASR::ttype_t* dt_ttype_t = ASRUtils::type_get_past_pointer( + ASRUtils::symbol_type(dt_sym)); + if( ASR::is_a(*dt_ttype_t) ) { + ASR::Struct_t* struct_t = ASR::down_cast(dt_ttype_t); + dt_sym_type = ASR::down_cast( + ASRUtils::symbol_get_past_external(struct_t->m_derived_type)); + } else if( ASR::is_a(*dt_ttype_t) ) { + ASR::Class_t* class_t = ASR::down_cast(dt_ttype_t); + dt_sym_type = ASR::down_cast( + ASRUtils::symbol_get_past_external(class_t->m_class_type)); + } + LCOMPILERS_ASSERT(dt_sym_type != nullptr); + for( auto& item: type2vtab ) { + ASR::StructType_t* a_dt = ASR::down_cast(item.first); + if( !a_dt->m_is_abstract && + (a_dt == dt_sym_type || + ASRUtils::is_parent(a_dt, dt_sym_type) || + ASRUtils::is_parent(dt_sym_type, a_dt)) ) { + for( auto& item2: item.second ) { + if( item2.first == current_scope ) { + vtabs.push_back(std::make_pair(item2.second, item.first)); + } + } + } + } + + uint64_t ptr_loads_copy = ptr_loads; + ptr_loads = 0; + visit_Var(*dt_Var); + ptr_loads = ptr_loads_copy; + llvm::Value* llvm_dt = tmp; + tmp = builder->CreateAlloca(get_type_from_ttype_t_util(x.m_type)); + llvm::BasicBlock *mergeBB = llvm::BasicBlock::Create(context, "ifcont"); + for( size_t i = 0; i < vtabs.size(); i++ ) { + llvm::Function *fn = builder->GetInsertBlock()->getParent(); + + llvm::BasicBlock *thenBB = llvm::BasicBlock::Create(context, "then", fn); + llvm::BasicBlock *elseBB = llvm::BasicBlock::Create(context, "else"); + + llvm::Value* vptr_int_hash = CreateLoad(llvm_utils->create_gep(llvm_dt, 0)); + llvm::Value* dt_data = CreateLoad(llvm_utils->create_gep(llvm_dt, 1)); + ASR::ttype_t* selector_var_type = ASRUtils::expr_type(x.m_dt); + if( ASRUtils::is_array(selector_var_type) ) { + vptr_int_hash = CreateLoad(llvm_utils->create_gep(vptr_int_hash, 0)); + } + ASR::symbol_t* type_sym = ASRUtils::symbol_get_past_external(vtabs[i].second); + llvm::Value* type_sym_vtab = vtabs[i].first; + llvm::Value* cond = builder->CreateICmpEQ( + vptr_int_hash, + CreateLoad( + llvm_utils->create_gep(type_sym_vtab, 0) ) ); + + builder->CreateCondBr(cond, thenBB, elseBB); + builder->SetInsertPoint(thenBB); + { + std::vector args; + ASR::StructType_t* struct_type_t = ASR::down_cast(type_sym); + llvm::Type* target_dt_type = getStructType(struct_type_t, true); + llvm::Type* target_class_dt_type = getClassType(struct_type_t); + llvm::Value* target_dt = builder->CreateAlloca(target_class_dt_type); + llvm::Value* target_dt_hash_ptr = llvm_utils->create_gep(target_dt, 0); + builder->CreateStore(vptr_int_hash, target_dt_hash_ptr); + llvm::Value* target_dt_data_ptr = llvm_utils->create_gep(target_dt, 1); + builder->CreateStore(builder->CreateBitCast(dt_data, target_dt_type), + target_dt_data_ptr); + args.push_back(target_dt); + ASR::symbol_t* s_class_proc = struct_type_t->m_symtab->resolve_symbol(proc_sym_name); + ASR::symbol_t* s_proc = ASRUtils::symbol_get_past_external( + ASR::down_cast(s_class_proc)->m_proc); + uint32_t h = get_hash((ASR::asr_t*) s_proc); + llvm::Function* fn = llvm_symtab_fn[h]; + ASR::Function_t* s = ASR::down_cast(s_proc); + LCOMPILERS_ASSERT(s != nullptr); + std::vector args2 = convert_call_args(x, true); + args.insert(args.end(), args2.begin(), args2.end()); + ASR::ttype_t *return_var_type0 = EXPR2VAR(s->m_return_var)->m_type; + builder->CreateStore(CreateCallUtil(fn, args, return_var_type0), tmp); + } + builder->CreateBr(mergeBB); + + start_new_block(elseBB); + current_select_type_block_type = nullptr; + current_select_type_block_der_type.clear(); + } + start_new_block(mergeBB); + tmp = CreateLoad(tmp); + } + void visit_FunctionCall(const ASR::FunctionCall_t &x) { if( ASRUtils::is_intrinsic_optimization(x.m_name) ) { ASR::Function_t* routine = ASR::down_cast( @@ -6801,16 +7807,25 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } if (x.m_value) { this->visit_expr_wrapper(x.m_value, true); - return; + return ; } - ASR::Function_t *s = nullptr; - std::vector args; + const ASR::symbol_t *proc_sym = symbol_get_past_external(x.m_name); - if (x.m_dt){ - ASR::Variable_t *caller = EXPR2VAR(x.m_dt); - std::uint32_t h = get_hash((ASR::asr_t*)caller); - args.push_back(llvm_symtab[h]); + std::string proc_sym_name = ""; + bool is_deferred = false; + if( ASR::is_a(*proc_sym) ) { + ASR::ClassProcedure_t* class_proc = + ASR::down_cast(proc_sym); + is_deferred = class_proc->m_is_deferred; + proc_sym_name = class_proc->m_name; + } + if( is_deferred ) { + visit_RuntimePolymorphicFunctionCall(x, proc_sym_name); + return ; } + + ASR::Function_t *s = nullptr; + std::vector args; if (ASR::is_a(*proc_sym)) { s = ASR::down_cast(proc_sym); } else { @@ -6821,6 +7836,18 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor if( s == nullptr ) { s = ASR::down_cast(symbol_get_past_external(x.m_name)); } + bool is_method = false; + if (x.m_dt) { + is_method = true; + ASR::Variable_t *caller = EXPR2VAR(x.m_dt); + std::uint32_t h = get_hash((ASR::asr_t*)caller); + llvm::Value* dt = llvm_symtab[h]; + ASR::ttype_t* s_m_args0_type = ASRUtils::type_get_past_pointer( + ASRUtils::expr_type(s->m_args[0])); + ASR::ttype_t* dt_type = ASRUtils::type_get_past_pointer(caller->m_type); + dt = convert_to_polymorphic_arg(dt, s_m_args0_type, dt_type); + args.push_back(dt); + } if( ASRUtils::is_intrinsic_function2(s) ) { std::string symbol_name = ASRUtils::symbol_name(x.m_name); if( startswith(symbol_name, "_bitwise_xor") ) { @@ -6836,7 +7863,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor return ; } } - if (parent_function){ + if (parent_function) { push_nested_stack(parent_function); } bool intrinsic_function = ASRUtils::is_intrinsic_function2(s); @@ -6856,10 +7883,26 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor h = get_hash((ASR::asr_t*)s); } else { if (func_name == "len") { - args = convert_call_args(x); + args = convert_call_args(x, is_method); LCOMPILERS_ASSERT(args.size() == 3) tmp = lfortran_str_len(args[0]); return; + } else if (func_name == "command_argument_count") { + llvm::Function *fn = module->getFunction("_lpython_get_argc"); + if(!fn) { + llvm::FunctionType *function_type = llvm::FunctionType::get( + llvm::Type::getVoidTy(context), { + llvm::Type::getInt32Ty(context)->getPointerTo() + }, false); + fn = llvm::Function::Create(function_type, + llvm::Function::ExternalLinkage, "_lpython_get_argc", *module); + } + llvm::AllocaInst *result = builder->CreateAlloca( + llvm::Type::getInt32Ty(context), nullptr); + std::vector args = {result}; + builder->CreateCall(fn, args); + tmp = CreateLoad(result); + return; } if( ASRUtils::get_FunctionType(s)->m_deftype == ASR::deftypeType::Interface ) { throw CodeGenError("Intrinsic '" + func_name + "' not implemented yet and compile time value is not available."); @@ -6875,7 +7918,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor llvm::Value* fn = llvm_symtab_fn_arg[h]; llvm::FunctionType* fntype = llvm_symtab_fn[h]->getFunctionType(); std::string m_name = std::string(((ASR::Function_t*)(&(x.m_name->base)))->m_name); - args = convert_call_args(x); + args = convert_call_args(x, is_method); tmp = builder->CreateCall(fntype, fn, args); } else if (llvm_symtab_fn.find(h) == llvm_symtab_fn.end()) { throw CodeGenError("Function code not generated for '" @@ -6883,7 +7926,7 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor } else { llvm::Function *fn = llvm_symtab_fn[h]; std::string m_name = std::string(((ASR::Function_t*)(&(x.m_name->base)))->m_name); - std::vector args2 = convert_call_args(x); + std::vector args2 = convert_call_args(x, is_method); args.insert(args.end(), args2.begin(), args2.end()); ASR::ttype_t *return_var_type0 = EXPR2VAR(s->m_return_var)->m_type; if (ASRUtils::get_FunctionType(s)->m_abi == ASR::abiType::BindC) { @@ -7030,6 +8073,7 @@ Result> asr_to_llvm(ASR::TranslationUnit_t &asr, pass_options.include_dirs = co.include_dirs; pass_options.run_fun = run_fn; pass_options.always_run = false; + pass_options.verbose = co.verbose; pass_manager.rtlib = co.rtlib; pass_manager.apply_passes(al, &asr, pass_options, diagnostics); diff --git a/src/libasr/codegen/asr_to_wasm.cpp b/src/libasr/codegen/asr_to_wasm.cpp index 8962508831..be632c335b 100644 --- a/src/libasr/codegen/asr_to_wasm.cpp +++ b/src/libasr/codegen/asr_to_wasm.cpp @@ -19,6 +19,11 @@ #include #include +#define INCLUDE_RUNTIME_FUNC(fn) \ + if (m_rt_func_used_idx[fn] == -1) { \ + m_rt_func_used_idx[fn] = no_of_types++; \ + } \ + // #define SHOW_ASR #ifdef SHOW_ASR @@ -1712,42 +1717,30 @@ class ASRToWASMVisitor : public ASR::BaseVisitor { switch (x.m_op) { case ASR::binopType::Add: { if (a_kind == 4) { - if (m_rt_func_used_idx[add_c32] == -1) { - m_rt_func_used_idx[add_c32] = no_of_types++; - } + INCLUDE_RUNTIME_FUNC(add_c32); wia.emit_call(m_rt_func_used_idx[add_c32]); } else { - if (m_rt_func_used_idx[add_c64] == -1) { - m_rt_func_used_idx[add_c64] = no_of_types++; - } + INCLUDE_RUNTIME_FUNC(add_c64); wia.emit_call(m_rt_func_used_idx[add_c64]); } break; }; case ASR::binopType::Sub: { if (a_kind == 4) { - if (m_rt_func_used_idx[sub_c32] == -1) { - m_rt_func_used_idx[sub_c32] = no_of_types++; - } + INCLUDE_RUNTIME_FUNC(sub_c32); wia.emit_call(m_rt_func_used_idx[sub_c32]); } else { - if (m_rt_func_used_idx[sub_c64] == -1) { - m_rt_func_used_idx[sub_c64] = no_of_types++; - } + INCLUDE_RUNTIME_FUNC(sub_c64); wia.emit_call(m_rt_func_used_idx[sub_c64]); } break; }; case ASR::binopType::Mul: { if (a_kind == 4) { - if (m_rt_func_used_idx[mul_c32] == -1) { - m_rt_func_used_idx[mul_c32] = no_of_types++; - } + INCLUDE_RUNTIME_FUNC(mul_c32); wia.emit_call(m_rt_func_used_idx[mul_c32]); } else { - if (m_rt_func_used_idx[mul_c64] == -1) { - m_rt_func_used_idx[mul_c64] = no_of_types++; - } + INCLUDE_RUNTIME_FUNC(mul_c64); wia.emit_call(m_rt_func_used_idx[mul_c64]); } break; @@ -2685,16 +2678,12 @@ class ASRToWASMVisitor : public ASR::BaseVisitor { int arg_kind = -1, dest_kind = -1; extract_kinds(x, arg_kind, dest_kind); if (arg_kind == 4) { - if (m_rt_func_used_idx[abs_c32] == -1) { - m_rt_func_used_idx[abs_c32] = no_of_types++; - } + INCLUDE_RUNTIME_FUNC(abs_c32); wia.emit_call(m_rt_func_used_idx[abs_c32]); wia.emit_f32_const(0.0); wia.emit_f32_gt(); } else if (arg_kind == 8) { - if (m_rt_func_used_idx[abs_c64] == -1) { - m_rt_func_used_idx[abs_c64] = no_of_types++; - } + INCLUDE_RUNTIME_FUNC(abs_c64); wia.emit_call(m_rt_func_used_idx[abs_c64]); wia.emit_f64_const(0.0); wia.emit_f64_gt(); @@ -2874,9 +2863,7 @@ class ASRToWASMVisitor : public ASR::BaseVisitor { int a_kind = ASRUtils::extract_kind_from_ttype_t(t); if (ASRUtils::is_integer(*t) || ASRUtils::is_logical(*t)) { - if (m_rt_func_used_idx[print_i64] == -1) { - m_rt_func_used_idx[print_i64] = no_of_types++; - } + INCLUDE_RUNTIME_FUNC(print_i64); this->visit_expr(*x.m_values[i]); switch (a_kind) { case 4: { @@ -2895,12 +2882,8 @@ class ASRToWASMVisitor : public ASR::BaseVisitor { } } } else if (ASRUtils::is_real(*t)) { - if (m_rt_func_used_idx[print_i64] == -1) { - m_rt_func_used_idx[print_i64] = no_of_types++; - } - if (m_rt_func_used_idx[print_f64] == -1) { - m_rt_func_used_idx[print_f64] = no_of_types++; - } + INCLUDE_RUNTIME_FUNC(print_i64); + INCLUDE_RUNTIME_FUNC(print_f64); this->visit_expr(*x.m_values[i]); switch (a_kind) { case 4: { @@ -2928,12 +2911,8 @@ class ASRToWASMVisitor : public ASR::BaseVisitor { wia.emit_call(m_import_func_idx_map[fd_write]); wia.emit_drop(); } else if (t->type == ASR::ttypeType::Complex) { - if (m_rt_func_used_idx[print_i64] == -1) { - m_rt_func_used_idx[print_i64] = no_of_types++; - } - if (m_rt_func_used_idx[print_f64] == -1) { - m_rt_func_used_idx[print_f64] = no_of_types++; - } + INCLUDE_RUNTIME_FUNC(print_i64); + INCLUDE_RUNTIME_FUNC(print_f64); emit_call_fd_write(1, "(", 1, 0); this->visit_expr(*x.m_values[i]); if (a_kind == 4) { diff --git a/src/libasr/codegen/llvm_array_utils.cpp b/src/libasr/codegen/llvm_array_utils.cpp index 2d52e81444..af3599a131 100644 --- a/src/libasr/codegen/llvm_array_utils.cpp +++ b/src/libasr/codegen/llvm_array_utils.cpp @@ -312,6 +312,30 @@ namespace LCompilers { builder->CreateStore(arr_first, first_ptr); } + void SimpleCMODescriptor::fill_array_details( + llvm::Value* source, llvm::Value* destination, + ASR::ttype_t* /*asr_shape_type*/, bool ignore_data) { + if( !ignore_data ) { + // TODO: Implement data filling to destination array + LCOMPILERS_ASSERT(false); + } + + llvm::Value* source_offset_val = LLVM::CreateLoad(*builder, llvm_utils->create_gep(source, 1)); + llvm::Value* dest_offset = llvm_utils->create_gep(destination, 1); + builder->CreateStore(source_offset_val, dest_offset); + + llvm::Value* source_dim_des_val = LLVM::CreateLoad(*builder, llvm_utils->create_gep(source, 2)); + llvm::Value* dest_dim_des_ptr = llvm_utils->create_gep(destination, 2); + builder->CreateStore(source_dim_des_val, dest_dim_des_ptr); + + llvm::Value* source_allocated_flag = this->get_is_allocated_flag(source); + llvm::Value* destination_allocated_flag_ptr = llvm_utils->create_gep(destination, 3); + builder->CreateStore(source_allocated_flag, destination_allocated_flag_ptr); + + llvm::Value* source_rank = this->get_rank(source, false); + this->set_rank(destination, source_rank); + }; + void SimpleCMODescriptor::fill_malloc_array_details( llvm::Value* arr, llvm::Type* llvm_data_type, int n_dims, std::vector>& llvm_dims, @@ -436,7 +460,8 @@ namespace LCompilers { llvm::Value* SimpleCMODescriptor::get_single_element(llvm::Value* array, std::vector& m_args, int n_args, bool data_only, - bool is_fixed_size, llvm::Value** llvm_diminfo) { + bool is_fixed_size, llvm::Value** llvm_diminfo, bool polymorphic, + llvm::Type* polymorphic_type) { llvm::Value* tmp = nullptr; // TODO: Uncomment later // bool check_for_bounds = is_explicit_shape(v); @@ -453,7 +478,13 @@ namespace LCompilers { } else { idx = cmo_convertor_single_element(array, m_args, n_args, check_for_bounds); llvm::Value* full_array = get_pointer_to_data(array); - tmp = llvm_utils->create_ptr_gep(LLVM::CreateLoad(*builder, full_array), idx); + if( polymorphic ) { + full_array = llvm_utils->create_gep(LLVM::CreateLoad(*builder, full_array), 1); + full_array = builder->CreateBitCast(LLVM::CreateLoad(*builder, full_array), polymorphic_type); + tmp = llvm_utils->create_ptr_gep(full_array, idx); + } else { + tmp = llvm_utils->create_ptr_gep(LLVM::CreateLoad(*builder, full_array), idx); + } } return tmp; } diff --git a/src/libasr/codegen/llvm_array_utils.h b/src/libasr/codegen/llvm_array_utils.h index f9216824c9..7be522a802 100644 --- a/src/libasr/codegen/llvm_array_utils.h +++ b/src/libasr/codegen/llvm_array_utils.h @@ -143,6 +143,11 @@ namespace LCompilers { llvm::Value* arr, llvm::Type* llvm_data_type, int n_dims, std::vector>& llvm_dims) = 0; + virtual + void fill_array_details( + llvm::Value* source, llvm::Value* destination, + ASR::ttype_t* asr_shape_type, bool ignore_data) = 0; + /* * Fills the elements of the input array descriptor * for allocatable arrays. @@ -245,7 +250,8 @@ namespace LCompilers { llvm::Value* get_single_element(llvm::Value* array, std::vector& m_args, int n_args, bool data_only=false, bool is_fixed_size=false, - llvm::Value** llvm_diminfo=nullptr) = 0; + llvm::Value** llvm_diminfo=nullptr, + bool polymorphic=false, llvm::Type* polymorphic_type=nullptr) = 0; virtual llvm::Value* get_is_allocated_flag(llvm::Value* array) = 0; @@ -336,6 +342,11 @@ namespace LCompilers { llvm::Value* arr, llvm::Type* llvm_data_type, int n_dims, std::vector>& llvm_dims); + virtual + void fill_array_details( + llvm::Value* source, llvm::Value* destination, + ASR::ttype_t* asr_shape_type, bool ignore_data); + virtual void fill_malloc_array_details( llvm::Value* arr, llvm::Type* llvm_data_type, int n_dims, @@ -385,7 +396,8 @@ namespace LCompilers { llvm::Value* get_single_element(llvm::Value* array, std::vector& m_args, int n_args, bool data_only=false, bool is_fixed_size=false, - llvm::Value** llvm_diminfo=nullptr); + llvm::Value** llvm_diminfo=nullptr, + bool polymorphic=false, llvm::Type* polymorphic_type=nullptr); virtual llvm::Value* get_is_allocated_flag(llvm::Value* array); diff --git a/src/libasr/codegen/wasm_assembler.h b/src/libasr/codegen/wasm_assembler.h index 1d18c66412..8d949f8f86 100644 --- a/src/libasr/codegen/wasm_assembler.h +++ b/src/libasr/codegen/wasm_assembler.h @@ -1,5 +1,4 @@ -#include - +#include #include namespace LCompilers { @@ -53,7 +52,7 @@ void emit_u32_b32_idx(Vec &code, Allocator &al, uint32_t idx, num.reserve(al, 4); encode_leb128_u32(num, al, section_size); std::vector num_4b = {0x80, 0x80, 0x80, 0x00}; - assert(num.size() <= 4); + LCOMPILERS_ASSERT(num.size() <= 4); for (uint32_t i = 0; i < num.size(); i++) { num_4b[i] |= num[i]; } diff --git a/src/libasr/pass/arr_slice.cpp b/src/libasr/pass/arr_slice.cpp index 96c92a490c..c6aae147fa 100644 --- a/src/libasr/pass/arr_slice.cpp +++ b/src/libasr/pass/arr_slice.cpp @@ -154,7 +154,7 @@ class ReplaceArraySection: public ASR::BaseExprReplacer { const_1, int_type, nullptr)); ASR::stmt_t* assign_stmt = ASRUtils::STMT(ASR::make_Assignment_t(al, x->base.base.loc, idx_vars_target[i], inc_expr, nullptr)); doloop_body.push_back(al, assign_stmt); - doloop = ASRUtils::STMT(ASR::make_DoLoop_t(al, x->base.base.loc, head, doloop_body.p, doloop_body.size())); + doloop = ASRUtils::STMT(ASR::make_DoLoop_t(al, x->base.base.loc, nullptr, head, doloop_body.p, doloop_body.size())); } int a_kind = ASRUtils::extract_kind_from_ttype_t(ASRUtils::expr_type(idx_vars_target[0])); ASR::ttype_t* int_type = ASRUtils::TYPE(ASR::make_Integer_t(al, x->base.base.loc, a_kind, nullptr, 0)); diff --git a/src/libasr/pass/array_op.cpp b/src/libasr/pass/array_op.cpp index cc98a52959..51e7690176 100644 --- a/src/libasr/pass/array_op.cpp +++ b/src/libasr/pass/array_op.cpp @@ -67,6 +67,8 @@ class ReplaceArrayOp: public ASR::BaseExprReplacer { Vec& pass_result; size_t result_counter; bool& use_custom_loop_params; + bool& apply_again; + bool& remove_original_statement; Vec& result_lbound; Vec& result_ubound; Vec& result_inc; @@ -79,11 +81,13 @@ class ReplaceArrayOp: public ASR::BaseExprReplacer { ReplaceArrayOp(Allocator& al_, Vec& pass_result_, bool& use_custom_loop_params_, + bool& apply_again_, bool& remove_original_statement_, Vec& result_lbound_, Vec& result_ubound_, Vec& result_inc_) : al(al_), pass_result(pass_result_), result_counter(0), use_custom_loop_params(use_custom_loop_params_), + apply_again(apply_again_), remove_original_statement(remove_original_statement_), result_lbound(result_lbound_), result_ubound(result_ubound_), result_inc(result_inc_), current_scope(nullptr), result_var(nullptr), result_type(nullptr) {} @@ -106,54 +110,79 @@ class ReplaceArrayOp: public ASR::BaseExprReplacer { } ASR::stmt_t* doloop = nullptr; LCOMPILERS_ASSERT(result_rank >= var_rank); - LCOMPILERS_ASSERT(var_rank == (int) loop_vars.size()); + // LCOMPILERS_ASSERT(var_rank == (int) loop_vars.size()); ASR::ttype_t* int32_type = ASRUtils::TYPE(ASR::make_Integer_t(al, loc, 4, nullptr, 0)); ASR::expr_t* const_1 = ASRUtils::EXPR(ASR::make_IntegerConstant_t(al, loc, 1, int32_type)); - for( int i = var_rank - 1; i >= 0; i-- ) { - // TODO: Add an If debug node to check if the lower and upper bounds of both the arrays are same. + if (var_rank == (int) loop_vars.size()) { + for( int i = var_rank - 1; i >= 0; i-- ) { + // TODO: Add an If debug node to check if the lower and upper bounds of both the arrays are same. + ASR::do_loop_head_t head; + head.m_v = loop_vars[i]; + if( use_custom_loop_params ) { + int j = loop_var_indices[i]; + head.m_start = result_lbound[j]; + head.m_end = result_ubound[j]; + head.m_increment = result_inc[j]; + } else { + head.m_start = PassUtils::get_bound(result_var, i + 1, "lbound", al); + head.m_end = PassUtils::get_bound(result_var, i + 1, "ubound", al); + head.m_increment = nullptr; + } + head.loc = head.m_v->base.loc; + doloop_body.reserve(al, 1); + if( doloop == nullptr ) { + loop_body(); + } else { + if( var_rank > 0 ) { + ASR::expr_t* idx_lb = PassUtils::get_bound(op_expr, i + op_expr_dim_offset, "lbound", al); + ASR::stmt_t* set_to_one = ASRUtils::STMT(ASR::make_Assignment_t( + al, loc, idx_vars_value[i+1], idx_lb, nullptr)); + doloop_body.push_back(al, set_to_one); + } + doloop_body.push_back(al, doloop); + } + if( var_rank > 0 ) { + ASR::expr_t* inc_expr = ASRUtils::EXPR(ASR::make_IntegerBinOp_t( + al, loc, idx_vars_value[i], ASR::binopType::Add, const_1, int32_type, nullptr)); + ASR::stmt_t* assign_stmt = ASRUtils::STMT(ASR::make_Assignment_t( + al, loc, idx_vars_value[i], inc_expr, nullptr)); + doloop_body.push_back(al, assign_stmt); + } + doloop = ASRUtils::STMT(ASR::make_DoLoop_t(al, loc, nullptr, head, doloop_body.p, doloop_body.size())); + } + if( var_rank > 0 ) { + ASR::expr_t* idx_lb = PassUtils::get_bound(op_expr, 1, "lbound", al); + ASR::stmt_t* set_to_one = ASRUtils::STMT(ASR::make_Assignment_t(al, loc, idx_vars_value[0], idx_lb, nullptr)); + pass_result.push_back(al, set_to_one); + } + pass_result.push_back(al, doloop); + } else if (var_rank == 0) { ASR::do_loop_head_t head; - head.m_v = loop_vars[i]; + head.m_v = loop_vars[0]; if( use_custom_loop_params ) { - int j = loop_var_indices[i]; + int j = loop_var_indices[0]; head.m_start = result_lbound[j]; head.m_end = result_ubound[j]; head.m_increment = result_inc[j]; } else { - head.m_start = PassUtils::get_bound(result_var, i + 1, "lbound", al); - head.m_end = PassUtils::get_bound(result_var, i + 1, "ubound", al); + head.m_start = PassUtils::get_bound(result_var, 1, "lbound", al); + head.m_end = PassUtils::get_bound(result_var, 1, "ubound", al); head.m_increment = nullptr; } - head.loc = head.m_v->base.loc; doloop_body.reserve(al, 1); if( doloop == nullptr ) { loop_body(); } else { - if( var_rank > 0 ) { - ASR::expr_t* idx_lb = PassUtils::get_bound(op_expr, i + op_expr_dim_offset, "lbound", al); - ASR::stmt_t* set_to_one = ASRUtils::STMT(ASR::make_Assignment_t( - al, loc, idx_vars_value[i+1], idx_lb, nullptr)); - doloop_body.push_back(al, set_to_one); - } doloop_body.push_back(al, doloop); } - if( var_rank > 0 ) { - ASR::expr_t* inc_expr = ASRUtils::EXPR(ASR::make_IntegerBinOp_t( - al, loc, idx_vars_value[i], ASR::binopType::Add, const_1, int32_type, nullptr)); - ASR::stmt_t* assign_stmt = ASRUtils::STMT(ASR::make_Assignment_t( - al, loc, idx_vars_value[i], inc_expr, nullptr)); - doloop_body.push_back(al, assign_stmt); - } - doloop = ASRUtils::STMT(ASR::make_DoLoop_t(al, loc, head, doloop_body.p, doloop_body.size())); + doloop = ASRUtils::STMT(ASR::make_DoLoop_t(al, loc, nullptr, head, doloop_body.p, doloop_body.size())); + pass_result.push_back(al, doloop); } - if( var_rank > 0 ) { - ASR::expr_t* idx_lb = PassUtils::get_bound(op_expr, 1, "lbound", al); - ASR::stmt_t* set_to_one = ASRUtils::STMT(ASR::make_Assignment_t(al, loc, idx_vars_value[0], idx_lb, nullptr)); - pass_result.push_back(al, set_to_one); - } - pass_result.push_back(al, doloop); + } - void replace_Var(ASR::Var_t* x) { + template + void replace_vars_helper(T* x) { if( !(result_var != nullptr && PassUtils::is_array(result_var)) ) { return ; } @@ -182,6 +211,14 @@ class ReplaceArrayOp: public ASR::BaseExprReplacer { use_custom_loop_params = false; } + void replace_StructInstanceMember(ASR::StructInstanceMember_t* x) { + replace_vars_helper(x); + } + + void replace_Var(ASR::Var_t* x) { + replace_vars_helper(x); + } + template void create_do_loop(const Location& loc, int result_rank, Vec& idx_vars, Vec& loop_vars, @@ -218,7 +255,7 @@ class ReplaceArrayOp: public ASR::BaseExprReplacer { } else { doloop_body.push_back(al, doloop); } - doloop = ASRUtils::STMT(ASR::make_DoLoop_t(al, loc, head, doloop_body.p, doloop_body.size())); + doloop = ASRUtils::STMT(ASR::make_DoLoop_t(al, loc, nullptr, head, doloop_body.p, doloop_body.size())); } pass_result.push_back(al, doloop); } @@ -315,9 +352,6 @@ class ReplaceArrayOp: public ASR::BaseExprReplacer { const Location& loc = x->base.base.loc; bool current_status = use_custom_loop_params; use_custom_loop_params = false; - if( result_var ) { - result_type = ASRUtils::expr_type(result_var); - } ASR::expr_t* result_var_copy = result_var; ASR::expr_t** current_expr_copy_35 = current_expr; @@ -336,7 +370,6 @@ class ReplaceArrayOp: public ASR::BaseExprReplacer { use_custom_loop_params = current_status; result_var = result_var_copy; - result_type = nullptr; // TODO: Replace with ASRUtils::extract_dimensions_from_ttype int rank_left = PassUtils::get_rank(left); @@ -497,6 +530,25 @@ class ReplaceArrayOp: public ASR::BaseExprReplacer { ASR::expr_t* operand = x->m_arg; int rank_operand = PassUtils::get_rank(operand); if( rank_operand == 0 ) { + const Location& loc = x->base.base.loc; + if (result_var) { + int n_dims = PassUtils::get_rank(result_var); + if (n_dims != 0) { + Vec idx_vars, loop_vars; + std::vector loop_var_indices; + Vec doloop_body; + create_do_loop(loc, n_dims, idx_vars, + loop_vars, loop_var_indices, doloop_body, + [=, &idx_vars, &doloop_body] () { + ASR::expr_t* ref = ASRUtils::EXPR((ASR::asr_t*)x); + ASR::expr_t* res = PassUtils::create_array_ref(result_var, idx_vars, al); + ASR::stmt_t* assign = ASRUtils::STMT(ASR::make_Assignment_t(al, loc, res, ref, nullptr)); + doloop_body.push_back(al, assign); + }); + result_var = nullptr; + use_custom_loop_params = false; + } + } return ; } @@ -699,14 +751,28 @@ class ReplaceArrayOp: public ASR::BaseExprReplacer { ASR::symbol_t *sub = current_scope->resolve_symbol(x_name); if (sub && ASR::is_a(*sub) && ASR::down_cast(sub)->m_return_var == nullptr) { - if( result_var == nullptr ) { - ASR::ttype_t* result_var_type = x->m_type; - if( result_type ) { - result_var_type = result_type; + bool is_dimension_empty = false; + ASR::ttype_t* result_var_type = x->m_type; + ASR::dimension_t* m_dims = nullptr; + size_t n_dims = ASRUtils::extract_dimensions_from_ttype(result_var_type, m_dims); + for( size_t i = 0; i < n_dims; i++ ) { + if( m_dims[i].m_length == nullptr ) { + is_dimension_empty = true; + break; } - result_var = PassUtils::create_var(result_counter, "_func_call_res", - loc, result_var_type, al, current_scope); - result_counter += 1; + } + if( result_type && is_dimension_empty ) { + result_var_type = result_type; + } + // TODO: Remove allocatable attribute from temporary variable + ASR::expr_t* result_var_ = PassUtils::create_var(result_counter, "_func_call_res", + loc, result_var_type, al, current_scope); + result_counter += 1; + if( result_var == nullptr ) { + result_var = result_var_; + *current_expr = result_var; + } else { + *current_expr = result_var_; } Vec s_args; s_args.reserve(al, x->n_args + 1); @@ -715,12 +781,13 @@ class ReplaceArrayOp: public ASR::BaseExprReplacer { } ASR::call_arg_t result_arg; result_arg.loc = result_var->base.loc; - result_arg.m_value = result_var; + result_arg.m_value = *current_expr; s_args.push_back(al, result_arg); - *current_expr = result_var; ASR::stmt_t* subrout_call = ASRUtils::STMT(ASR::make_SubroutineCall_t(al, loc, sub, nullptr, s_args.p, s_args.size(), nullptr)); pass_result.push_back(al, subrout_call); + apply_again = true; + remove_original_statement = false; } else if( PassUtils::is_elemental(x->m_name) ) { std::vector array_mask(x->n_args, false); bool at_least_one_array = false; @@ -816,19 +883,23 @@ class ArrayOpVisitor : public ASR::CallReplacerOnExpressionsVisitor pass_result; Vec result_lbound, result_ubound, result_inc; - bool remove_original_statement; Vec* parent_body; public: + bool apply_again; + ArrayOpVisitor(Allocator& al_) : al(al_), use_custom_loop_params(false), + remove_original_statement(false), replacer(al_, pass_result, use_custom_loop_params, + apply_again, remove_original_statement, result_lbound, result_ubound, result_inc), - remove_original_statement(false), parent_body(nullptr) { + parent_body(nullptr), apply_again(false) { pass_result.n = 0; result_lbound.n = 0; result_ubound.n = 0; @@ -867,6 +938,7 @@ class ArrayOpVisitor : public ASR::CallReplacerOnExpressionsVisitoradd_symbol(item.first, item.second); + xx.m_global_scope->overwrite_symbol(item.first, item.second); } // Now visit everything else @@ -965,7 +1037,7 @@ class ArrayOpVisitor : public ASR::CallReplacerOnExpressionsVisitorm_return_var) ) { ASR::symbol_t* s_sub = create_subroutine_from_function(s); // Update the symtab with this function changes - xx.m_symtab->add_symbol(item.first, s_sub); + xx.m_symtab->overwrite_symbol(item.first, s_sub); } } } @@ -1037,7 +1109,7 @@ class ArrayOpVisitor : public ASR::CallReplacerOnExpressionsVisitortype == ASR::symbolType::Function ) { ASR::Function_t* func = ASR::down_cast(sym); ASR::symbol_t* s_func = create_subroutine_from_function(ASR::down_cast(sym)); - subrout_func->m_symtab->add_symbol(func->m_name, s_func); + subrout_func->m_symtab->overwrite_symbol(func->m_name, s_func); subrout_func->m_args[arg_index] = ASR::down_cast(ASR::make_Var_t(al, var->base.base.loc, s_func)); } } @@ -1055,7 +1127,7 @@ class ArrayOpVisitor : public ASR::CallReplacerOnExpressionsVisitoradd_symbol(item.first, item.second); + current_scope->overwrite_symbol(item.first, item.second); } for (auto &item : x.m_symtab->get_scope()) { @@ -1087,7 +1159,10 @@ class ArrayOpVisitor : public ASR::CallReplacerOnExpressionsVisitor(*ASRUtils::expr_type(x.m_target)) && ASR::is_a(*x.m_value)) || - (ASR::is_a(*x.m_value)) ) { + (ASR::is_a(*x.m_value)) || + (ASR::is_a(*x.m_target) && + ASRUtils::is_array(ASRUtils::expr_type(x.m_value)) && + ASRUtils::is_array(ASRUtils::expr_type(x.m_target))) ) { // TODO: fix for StructInstanceMember targets return ; } @@ -1098,6 +1173,7 @@ class ArrayOpVisitor : public ASR::CallReplacerOnExpressionsVisitor(*x.m_target) ) { ASR::ArraySection_t* array_ref = ASR::down_cast(x.m_target); @@ -1140,7 +1216,10 @@ class ArrayOpVisitor : public ASR::CallReplacerOnExpressionsVisitorm_type); - return ASR::make_ArrayItem_t(al, x->base.base.loc, m_v, args.p, x->n_args, type, ASR::arraystorageType::RowMajor, m_value); + return ASR::make_ArrayItem_t(al, x->base.base.loc, m_v, args.p, x->n_args, type, x->m_storage_format, m_value); } ASR::asr_t* duplicate_ListItem(ASR::ListItem_t *x) { @@ -217,7 +217,7 @@ class FunctionInstantiator : public ASR::BaseExprStmtDuplicatorm_head.m_end); head.m_increment = duplicate_expr(x->m_head.m_increment); head.loc = x->m_head.m_v->base.loc; - return ASR::make_DoLoop_t(al, x->base.base.loc, head, m_body.p, x->n_body); + return ASR::make_DoLoop_t(al, x->base.base.loc, x->m_name, head, m_body.p, x->n_body); } ASR::asr_t* duplicate_Cast(ASR::Cast_t *x) { @@ -230,8 +230,8 @@ class FunctionInstantiator : public ASR::BaseExprStmtDuplicatorm_name); - ASR::symbol_t *name = func_scope->get_symbol(sym_name); + std::string call_name = ASRUtils::symbol_name(x->m_name); + ASR::symbol_t *name = func_scope->get_symbol(call_name); Vec args; args.reserve(al, x->n_args); for (size_t i=0; in_args; i++) { @@ -243,11 +243,10 @@ class FunctionInstantiator : public ASR::BaseExprStmtDuplicatorm_type); ASR::expr_t* value = duplicate_expr(x->m_value); ASR::expr_t* dt = duplicate_expr(x->m_dt); - std::string call_name = ASRUtils::symbol_name(x->m_name); if (ASRUtils::is_restriction_function(name)) { name = rt_subs[call_name]; } else if (ASRUtils::is_generic_function(name)) { - std::string nested_func_name = "__asr_generic_" + sym_name; + std::string nested_func_name = current_scope->get_unique_name("__asr_generic_" + call_name); ASR::symbol_t* name2 = ASRUtils::symbol_get_past_external(name); ASR::Function_t* func = ASR::down_cast(name2); FunctionInstantiator nested_tf(al, subs, rt_subs, func_scope, nested_func_name); @@ -259,6 +258,34 @@ class FunctionInstantiator : public ASR::BaseExprStmtDuplicatorm_name); + ASR::symbol_t *name = func_scope->get_symbol(call_name); + Vec args; + args.reserve(al, x->n_args); + for (size_t i=0; in_args; i++) { + ASR::call_arg_t new_arg; + new_arg.loc = x->m_args[i].loc; + new_arg.m_value = duplicate_expr(x->m_args[i].m_value); + args.push_back(al, new_arg); + } + ASR::expr_t* dt = duplicate_expr(x->m_dt); + if (ASRUtils::is_restriction_function(name)) { + name = rt_subs[call_name]; + } else { + std::string nested_func_name = current_scope->get_unique_name("__asr_generic_" + call_name); + ASR::symbol_t* name2 = ASRUtils::symbol_get_past_external(name); + ASR::Function_t* func = ASR::down_cast(name2); + FunctionInstantiator nested_tf(al, subs, rt_subs, func_scope, nested_func_name); + ASR::asr_t* nested_generic_func = nested_tf.instantiate_Function(func); + name = ASR::down_cast(nested_generic_func); + } + dependencies.insert(std::string(ASRUtils::symbol_name(name))); + return ASR::make_SubroutineCall_t(al, x->base.base.loc, name /* change this */, + x->m_original_name, args.p, args.size(), dt); + } + + ASR::ttype_t* substitute_type(ASR::ttype_t *param_type) { if (ASR::is_a(*param_type)) { ASR::List_t *tlist = ASR::down_cast(param_type); diff --git a/src/libasr/pass/loop_unroll.cpp b/src/libasr/pass/loop_unroll.cpp index 2e9e1c4678..69684ec964 100644 --- a/src/libasr/pass/loop_unroll.cpp +++ b/src/libasr/pass/loop_unroll.cpp @@ -94,7 +94,7 @@ class LoopUnrollVisitor : public PassUtils::PassVisitor pass_result.push_back(al, init_stmt); ASR::stmt_t* unrolled_whileloop = ASRUtils::STMT(ASR::make_WhileLoop_t(al, x.base.base.loc, - whileloop->m_test, unrolled_loop.p, unrolled_loop.size())); + whileloop->m_name, whileloop->m_test, unrolled_loop.p, unrolled_loop.size())); pass_result.push_back(al, unrolled_whileloop); for( int64_t i = 0; i < remaining_part; i++ ) { for( size_t i = 0; i < whileloop->n_body; i++ ) { diff --git a/src/libasr/pass/loop_vectorise.cpp b/src/libasr/pass/loop_vectorise.cpp index d6e4533488..795ec090ce 100644 --- a/src/libasr/pass/loop_vectorise.cpp +++ b/src/libasr/pass/loop_vectorise.cpp @@ -167,7 +167,7 @@ class LoopVectoriseVisitor : public PassUtils::SkipOptimizationFunctionVisitor(x); + ASR::symbol_t* x_sym = xx.m_m; + SymbolTable* x_sym_symtab = ASRUtils::symbol_parent_symtab(x_sym); + if( x_sym_symtab->get_counter() != current_proc_scope->get_counter() && + !ASRUtils::is_parent(x_sym_symtab, current_proc_scope) ) { + // xx.m_v points to the function/procedure present inside + // original function's symtab. Make it point to the symbol in + // new function's symtab. + std::string x_sym_name = std::string(ASRUtils::symbol_name(x_sym)); + xx.m_m = current_proc_scope->resolve_symbol(x_sym_name); + LCOMPILERS_ASSERT(xx.m_m != nullptr); + } + } + void visit_Call(ASR::symbol_t*& m_name) { if( !is_editing_procedure ) { return ; @@ -119,8 +137,16 @@ class PassArrayByDataProcedureVisitor : public PassUtils::PassVisitorn_args + 1; i++ ) { ASR::Variable_t* arg = nullptr; + ASR::Function_t* arg_func = nullptr; if( i < x->n_args ) { - arg = ASRUtils::EXPR2VAR(x->m_args[i]); + if (ASR::is_a(*(x->m_args[i]))) { + ASR::Var_t* x_arg = ASR::down_cast(x->m_args[i]); + if (ASR::is_a(*(x_arg->m_v))) { + arg_func = ASR::down_cast(x_arg->m_v); + } else { + arg = ASRUtils::EXPR2VAR(x->m_args[i]); + } + } } else if( x->m_return_var ) { arg = ASRUtils::EXPR2VAR(x->m_return_var); } else { @@ -128,11 +154,22 @@ class PassArrayByDataProcedureVisitor : public PassUtils::PassVisitorm_name); + if( arg_func ) { + suffix += "_" + std::string(arg_func->m_name); + } else { + suffix += "_" + std::string(arg->m_name); + } } - ASR::expr_t* new_arg = ASRUtils::EXPR(ASR::make_Var_t(al, + ASR::expr_t* new_arg; + if (arg_func) { + new_arg = ASRUtils::EXPR(ASR::make_Var_t(al, + arg_func->base.base.loc, new_symtab->get_symbol( + std::string(arg_func->m_name)))); + } else { + new_arg = ASRUtils::EXPR(ASR::make_Var_t(al, arg->base.base.loc, new_symtab->get_symbol( std::string(arg->m_name)))); + } if( i < x->n_args ) { new_args.push_back(al, new_arg); } else { @@ -161,6 +198,18 @@ class PassArrayByDataProcedureVisitor : public PassUtils::PassVisitorget_scope() ) { + visit_symbol(*itr.second); + } + for( size_t i = 0; i < x.n_body; i++ ) { + visit_stmt(*x.m_body[i]); + } + current_proc_scope = current_proc_scope_copy; + } + void edit_new_procedure(ASR::Function_t* x, std::vector& indices) { Vec new_args; new_args.reserve(al, x->n_args); @@ -201,7 +250,8 @@ class PassArrayByDataProcedureVisitor : public PassUtils::PassVisitorm_symtab->get_scope() ) { if( ASR::is_a(*itr.second) ) { PassVisitor::visit_ttype(*ASR::down_cast(itr.second)->m_type); - } else if( ASR::is_a(*itr.second) ) { + } else if( ASR::is_a(*itr.second) || + ASR::is_a(*itr.second) ) { SymbolTable* current_proc_scope_copy = current_proc_scope; current_proc_scope = ASRUtils::symbol_symtab(itr.second); visit_symbol(*itr.second); diff --git a/src/libasr/pass/pass_compare.cpp b/src/libasr/pass/pass_compare.cpp index c5f252a477..ed6706bdcb 100644 --- a/src/libasr/pass/pass_compare.cpp +++ b/src/libasr/pass/pass_compare.cpp @@ -319,7 +319,7 @@ class CompareExprReplacer : public ASR::BaseExprReplacer loop_body.push_back(al, _tmp); _tmp = ASRUtils::STMT(ASR::make_WhileLoop_t( - al, loc, loop_test, loop_body.p, loop_body.n)); + al, loc, nullptr, loop_test, loop_body.p, loop_body.n)); body.push_back(al, _tmp); } diff --git a/src/libasr/pass/pass_list_expr.cpp b/src/libasr/pass/pass_list_expr.cpp index a0cf68740c..c9612fef38 100644 --- a/src/libasr/pass/pass_list_expr.cpp +++ b/src/libasr/pass/pass_list_expr.cpp @@ -94,7 +94,7 @@ class ListExprReplacer : public ASR::BaseExprReplacer loop_body.push_back(al, loop_stmt); loop_stmt = ASRUtils::STMT(ASR::make_WhileLoop_t( - al, loc, loop_test, loop_body.p, loop_body.n)); + al, loc, nullptr, loop_test, loop_body.p, loop_body.n)); body.push_back(al, loop_stmt); } diff --git a/src/libasr/pass/pass_manager.h b/src/libasr/pass/pass_manager.h index 6339fa8167..6e7bc47024 100644 --- a/src/libasr/pass/pass_manager.h +++ b/src/libasr/pass/pass_manager.h @@ -16,6 +16,7 @@ #include #include +#include #include #include #include @@ -97,18 +98,47 @@ namespace LCompilers { void _apply_passes(Allocator& al, ASR::TranslationUnit_t* asr, std::vector& passes, PassOptions &pass_options, diag::Diagnostics &diagnostics) { + if (pass_options.pass_cumulative) { + int _pass_max_idx = -1, _opt_max_idx = -1; + for (std::string ¤t_pass: passes) { + auto it1 = std::find(_passes.begin(), _passes.end(), current_pass); + if (it1 != _passes.end()) { + _pass_max_idx = std::max(_pass_max_idx, + (int)(it1 - _passes.begin())); + } + auto it2 = std::find(_with_optimization_passes.begin(), + _with_optimization_passes.end(), current_pass); + if (it2 != _with_optimization_passes.end()) { + _opt_max_idx = std::max(_opt_max_idx, + (int)(it2 - _with_optimization_passes.begin())); + } + } + passes.clear(); + if (_pass_max_idx != -1) { + for (int i=0; i<=_pass_max_idx; i++) + passes.push_back(_passes[i]); + } + if (_opt_max_idx != -1) { + for (int i=0; i<=_opt_max_idx; i++) + passes.push_back(_with_optimization_passes[i]); + } + } for (size_t i = 0; i < passes.size(); i++) { // TODO: rework the whole pass manager: construct the passes // ahead of time (not at the last minute), and remove this much // earlier // Note: this is not enough for rtlib, we also need to include // it + if (rtlib && passes[i] == "unused_functions") continue; if( std::find(_skip_passes.begin(), _skip_passes.end(), passes[i]) != _skip_passes.end()) continue; if (c_skip_pass && std::find(_c_skip_passes.begin(), _c_skip_passes.end(), passes[i]) != _c_skip_passes.end()) continue; + if (pass_options.verbose) { + std::cerr << "ASR Pass starts: '" << passes[i] << "'\n"; + } _passes_db[passes[i]](al, *asr, pass_options); #if defined(WITH_LFORTRAN_ASSERT) if (!asr_verify(*asr, true, diagnostics)) { @@ -116,6 +146,9 @@ namespace LCompilers { throw LCompilersException("Verify failed"); }; #endif + if (pass_options.verbose) { + std::cerr << "ASR Pass ends: '" << passes[i] << "'\n"; + } } } diff --git a/src/libasr/pass/pass_utils.cpp b/src/libasr/pass/pass_utils.cpp index 9a08b71ee0..ff005605e2 100644 --- a/src/libasr/pass/pass_utils.cpp +++ b/src/libasr/pass/pass_utils.cpp @@ -147,6 +147,10 @@ namespace LCompilers { ASR::dimension_t* m_dims; get_dim_rank(x_type, m_dims, n_dims); } + } else if (ASR::is_a(*x)) { + ASR::ttype_t *x_type = ASR::down_cast(x)->m_type; + ASR::dimension_t* m_dims; + get_dim_rank(x_type, m_dims, n_dims); } return n_dims; } @@ -226,43 +230,43 @@ namespace LCompilers { new_m_dims.push_back(al, new_m_dim); } return PassUtils::set_dim_rank(sibling_type, new_m_dims.p, ndims, true, &al); - } + } - ASR::expr_t* create_var(int counter, std::string suffix, const Location& loc, - ASR::ttype_t* var_type, Allocator& al, SymbolTable*& current_scope) { - ASR::expr_t* idx_var = nullptr; - std::string str_name = "__libasr__created__var__" + std::to_string(counter) + suffix; - char* idx_var_name = s2c(al, str_name); - - if( current_scope->get_symbol(std::string(idx_var_name)) == nullptr ) { - ASR::asr_t* idx_sym = ASR::make_Variable_t(al, loc, current_scope, idx_var_name, nullptr, 0, - ASR::intentType::Local, nullptr, nullptr, ASR::storage_typeType::Default, - var_type, ASR::abiType::Source, ASR::accessType::Public, ASR::presenceType::Required, - false); - current_scope->add_symbol(std::string(idx_var_name), ASR::down_cast(idx_sym)); - idx_var = ASRUtils::EXPR(ASR::make_Var_t(al, loc, ASR::down_cast(idx_sym))); - } else { - ASR::symbol_t* idx_sym = current_scope->get_symbol(std::string(idx_var_name)); - idx_var = ASRUtils::EXPR(ASR::make_Var_t(al, loc, idx_sym)); - } + ASR::expr_t* create_var(int counter, std::string suffix, const Location& loc, + ASR::ttype_t* var_type, Allocator& al, SymbolTable*& current_scope) { + ASR::expr_t* idx_var = nullptr; + std::string str_name = "__libasr__created__var__" + std::to_string(counter) + suffix; + char* idx_var_name = s2c(al, str_name); - return idx_var; + if( current_scope->get_symbol(std::string(idx_var_name)) == nullptr ) { + ASR::asr_t* idx_sym = ASR::make_Variable_t(al, loc, current_scope, idx_var_name, nullptr, 0, + ASR::intentType::Local, nullptr, nullptr, ASR::storage_typeType::Default, + var_type, ASR::abiType::Source, ASR::accessType::Public, ASR::presenceType::Required, + false); + current_scope->add_symbol(std::string(idx_var_name), ASR::down_cast(idx_sym)); + idx_var = ASRUtils::EXPR(ASR::make_Var_t(al, loc, ASR::down_cast(idx_sym))); + } else { + ASR::symbol_t* idx_sym = current_scope->get_symbol(std::string(idx_var_name)); + idx_var = ASRUtils::EXPR(ASR::make_Var_t(al, loc, idx_sym)); } - ASR::expr_t* create_var(int counter, std::string suffix, const Location& loc, - ASR::expr_t* sibling, Allocator& al, SymbolTable*& current_scope) { - ASR::ttype_t* var_type = get_matching_type(sibling, al); - return create_var(counter, suffix, loc, var_type, al, current_scope); - } + return idx_var; + } - void fix_dimension(ASR::Cast_t* x, ASR::expr_t* arg_expr) { - ASR::ttype_t* x_type = const_cast(x->m_type); - ASR::ttype_t* arg_type = ASRUtils::expr_type(arg_expr); - ASR::dimension_t* m_dims; - int ndims; - PassUtils::get_dim_rank(arg_type, m_dims, ndims); - PassUtils::set_dim_rank(x_type, m_dims, ndims); - } + ASR::expr_t* create_var(int counter, std::string suffix, const Location& loc, + ASR::expr_t* sibling, Allocator& al, SymbolTable*& current_scope) { + ASR::ttype_t* var_type = get_matching_type(sibling, al); + return create_var(counter, suffix, loc, var_type, al, current_scope); + } + + void fix_dimension(ASR::Cast_t* x, ASR::expr_t* arg_expr) { + ASR::ttype_t* x_type = const_cast(x->m_type); + ASR::ttype_t* arg_type = ASRUtils::expr_type(arg_expr); + ASR::dimension_t* m_dims; + int ndims; + PassUtils::get_dim_rank(arg_type, m_dims, ndims); + PassUtils::set_dim_rank(x_type, m_dims, ndims); + } void create_vars(Vec& vars, int n_vars, const Location& loc, Allocator& al, SymbolTable*& current_scope, std::string suffix, @@ -423,7 +427,7 @@ namespace LCompilers { s2c(al, sym), t, s2c(al, module_name), nullptr, 0, s2c(al, remote_sym), ASR::accessType::Private); - current_scope->add_symbol(sym, ASR::down_cast(fn)); + current_scope->add_or_overwrite_symbol(sym, ASR::down_cast(fn)); v = ASR::down_cast(fn); current_scope = current_scope_copy; return v; @@ -503,17 +507,18 @@ namespace LCompilers { ASR::expr_t* create_compare_helper(Allocator &al, const Location &loc, ASR::expr_t* left, ASR::expr_t* right, ASR::cmpopType op) { ASR::ttype_t* type = ASRUtils::expr_type(left); + ASR::ttype_t* cmp_type = ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4, nullptr, 0)); // TODO: compute `value`: if (ASRUtils::is_integer(*type)) { - return ASRUtils::EXPR(ASR::make_IntegerCompare_t(al, loc, left, op, right, type, nullptr)); + return ASRUtils::EXPR(ASR::make_IntegerCompare_t(al, loc, left, op, right, cmp_type, nullptr)); } else if (ASRUtils::is_real(*type)) { - return ASRUtils::EXPR(ASR::make_RealCompare_t(al, loc, left, op, right, type, nullptr)); + return ASRUtils::EXPR(ASR::make_RealCompare_t(al, loc, left, op, right, cmp_type, nullptr)); } else if (ASRUtils::is_complex(*type)) { - return ASRUtils::EXPR(ASR::make_ComplexCompare_t(al, loc, left, op, right, type, nullptr)); + return ASRUtils::EXPR(ASR::make_ComplexCompare_t(al, loc, left, op, right, cmp_type, nullptr)); } else if (ASRUtils::is_logical(*type)) { - return ASRUtils::EXPR(ASR::make_LogicalCompare_t(al, loc, left, op, right, type, nullptr)); + return ASRUtils::EXPR(ASR::make_LogicalCompare_t(al, loc, left, op, right, cmp_type, nullptr)); } else if (ASRUtils::is_character(*type)) { - return ASRUtils::EXPR(ASR::make_StringCompare_t(al, loc, left, op, right, type, nullptr)); + return ASRUtils::EXPR(ASR::make_StringCompare_t(al, loc, left, op, right, cmp_type, nullptr)); } else { throw LCompilersException("Type not supported"); } @@ -688,7 +693,7 @@ namespace LCompilers { target, value, nullptr)); loop_body.push_back(al, copy_stmt); ASR::stmt_t* fallback_loop = ASRUtils::STMT(ASR::make_DoLoop_t(al, do_loop_head.loc, - do_loop_head, loop_body.p, loop_body.size())); + nullptr, do_loop_head, loop_body.p, loop_body.size())); Vec fallback_while_loop = replace_doloop(al, *ASR::down_cast(fallback_loop), (int) ASR::cmpopType::Lt); for( size_t i = 0; i < fallback_while_loop.size(); i++ ) { @@ -879,8 +884,8 @@ namespace LCompilers { for (size_t i=0; i result; result.reserve(al, 2); if( stmt1 ) { diff --git a/src/libasr/pass/pass_utils.h b/src/libasr/pass/pass_utils.h index e228498404..4604b4c80a 100644 --- a/src/libasr/pass/pass_utils.h +++ b/src/libasr/pass/pass_utils.h @@ -108,7 +108,7 @@ namespace LCompilers { } template - class PassVisitor: public ASR::BaseWalkVisitor { + class PassVisitor: public ASR::ASRPassBaseWalkVisitor { private: @@ -119,10 +119,10 @@ namespace LCompilers { bool asr_changed, retain_original_stmt, remove_original_stmt; Allocator& al; Vec pass_result; - SymbolTable* current_scope; - PassVisitor(Allocator& al_, SymbolTable* current_scope_): al{al_}, - current_scope{current_scope_} { + PassVisitor(Allocator& al_, SymbolTable* current_scope_): al{al_} + { + this->current_scope = current_scope_; pass_result.n = 0; } @@ -165,7 +165,8 @@ namespace LCompilers { // FIXME: this is a hack, we need to pass in a non-const `x`, // which requires to generate a TransformVisitor. ASR::Program_t &xx = const_cast(x); - current_scope = xx.m_symtab; + SymbolTable* current_scope_copy = this->current_scope; + this->current_scope = xx.m_symtab; transform_stmts(xx.m_body, xx.n_body); // Transform nested functions and subroutines @@ -183,13 +184,15 @@ namespace LCompilers { self().visit_Block(*s); } } + this->current_scope = current_scope_copy; } void visit_Function(const ASR::Function_t &x) { // FIXME: this is a hack, we need to pass in a non-const `x`, // which requires to generate a TransformVisitor. ASR::Function_t &xx = const_cast(x); - current_scope = xx.m_symtab; + SymbolTable* current_scope_copy = this->current_scope; + this->current_scope = xx.m_symtab; transform_stmts(xx.m_body, xx.n_body); for (auto &item : x.m_symtab->get_scope()) { @@ -201,68 +204,12 @@ namespace LCompilers { ASR::Block_t *s = ASR::down_cast(item.second); self().visit_Block(*s); } + if (ASR::is_a(*item.second)) { + ASR::AssociateBlock_t *s = ASR::down_cast(item.second); + self().visit_AssociateBlock(*s); + } } - } - - void visit_AssociateBlock(const ASR::AssociateBlock_t& x) { - ASR::AssociateBlock_t &xx = const_cast(x); - current_scope = xx.m_symtab; - transform_stmts(xx.m_body, xx.n_body); - } - - void visit_Block(const ASR::Block_t& x) { - ASR::Block_t &xx = const_cast(x); - current_scope = xx.m_symtab; - transform_stmts(xx.m_body, xx.n_body); - - for (auto &item : x.m_symtab->get_scope()) { - self().visit_symbol(*item.second); - } - } - - void visit_DoLoop(const ASR::DoLoop_t& x) { - self().visit_do_loop_head(x.m_head); - ASR::DoLoop_t& xx = const_cast(x); - transform_stmts(xx.m_body, xx.n_body); - } - - void visit_WhileLoop(const ASR::WhileLoop_t& x) { - ASR::WhileLoop_t& xx = const_cast(x); - self().visit_expr(*xx.m_test); - transform_stmts(xx.m_body, xx.n_body); - } - - void visit_If(const ASR::If_t& x) { - ASR::If_t &xx = const_cast(x); - self().visit_expr(*xx.m_test); - transform_stmts(xx.m_body, xx.n_body); - transform_stmts(xx.m_orelse, xx.n_orelse); - } - - void visit_CaseStmt(const ASR::CaseStmt_t& x) { - ASR::CaseStmt_t &xx = const_cast(x); - for (size_t i=0; i(x); - if (xx.m_start) - self().visit_expr(*xx.m_start); - if (xx.m_end) - self().visit_expr(*xx.m_end); - transform_stmts(xx.m_body, xx.n_body); - } - - void visit_Select(const ASR::Select_t& x) { - ASR::Select_t &xx = const_cast(x); - self().visit_expr(*xx.m_test); - for (size_t i=0; icurrent_scope = current_scope_copy; } }; @@ -544,7 +491,7 @@ namespace LCompilers { } } ASR::stmt_t* doloop = ASRUtils::STMT(ASR::make_DoLoop_t(replacer->al, arr_var->base.base.loc, - head, doloop_body.p, doloop_body.size())); + nullptr, head, doloop_body.p, doloop_body.size())); result_vec->push_back(replacer->al, doloop); } diff --git a/src/libasr/pass/print_arr.cpp b/src/libasr/pass/print_arr.cpp index 4776abc09b..d88d9e0eab 100644 --- a/src/libasr/pass/print_arr.cpp +++ b/src/libasr/pass/print_arr.cpp @@ -85,7 +85,7 @@ class PrintArrVisitor : public PassUtils::PassVisitor doloop_body.push_back(al, doloop); doloop_body.push_back(al, empty_print_endl); } - doloop = ASRUtils::STMT(ASR::make_DoLoop_t(al, loc, head, doloop_body.p, doloop_body.size())); + doloop = ASRUtils::STMT(ASR::make_DoLoop_t(al, loc, nullptr, head, doloop_body.p, doloop_body.size())); } return doloop; } @@ -169,6 +169,86 @@ class PrintArrVisitor : public PassUtils::PassVisitor } } + ASR::stmt_t* write_array_using_doloop(ASR::expr_t *arr_expr, const Location &loc) { + int n_dims = PassUtils::get_rank(arr_expr); + Vec idx_vars; + PassUtils::create_idx_vars(idx_vars, n_dims, loc, al, current_scope); + ASR::stmt_t* doloop = nullptr; + ASR::stmt_t* empty_file_write_endl = ASRUtils::STMT(ASR::make_FileWrite_t(al, loc, + 0, nullptr, nullptr, nullptr, nullptr, nullptr,nullptr, 0, nullptr, nullptr)); + for( int i = n_dims - 1; i >= 0; i-- ) { + ASR::do_loop_head_t head; + head.m_v = idx_vars[i]; + head.m_start = PassUtils::get_bound(arr_expr, i + 1, "lbound", al); + head.m_end = PassUtils::get_bound(arr_expr, i + 1, "ubound", al); + head.m_increment = nullptr; + head.loc = head.m_v->base.loc; + Vec doloop_body; + doloop_body.reserve(al, 1); + if( doloop == nullptr ) { + ASR::expr_t* ref = PassUtils::create_array_ref(arr_expr, idx_vars, al); + Vec print_args; + print_args.reserve(al, 1); + print_args.push_back(al, ref); + ASR::stmt_t* write_stmt = ASRUtils::STMT(ASR::make_FileWrite_t( + al, loc, i, nullptr, nullptr, nullptr, nullptr, nullptr, print_args.p, print_args.size(), nullptr, nullptr)); + doloop_body.push_back(al, write_stmt); + } else { + doloop_body.push_back(al, doloop); + doloop_body.push_back(al, empty_file_write_endl); + } + doloop = ASRUtils::STMT(ASR::make_DoLoop_t(al, loc, nullptr, head, doloop_body.p, doloop_body.size())); + } + return doloop; + } + + void visit_FileWrite(const ASR::FileWrite_t& x) { + std::vector write_body; + ASR::stmt_t* empty_file_write_endl = ASRUtils::STMT(ASR::make_FileWrite_t(al, x.base.base.loc, + x.m_label, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, 0, nullptr, nullptr)); + ASR::stmt_t* write_stmt; + for (size_t i=0; i(*ASRUtils::expr_type(x.m_values[i])) && + PassUtils::is_array(x.m_values[i])) { + if (write_body.size() > 0) { + Vec body; + body.reserve(al, write_body.size()); + for (size_t j=0; j 0) { + Vec body; + body.reserve(al, write_body.size()); + for (size_t j=0; jn_test == 2 ) { ASR::expr_t* left = PassUtils::create_compare_helper(al, loc, a_test, Case_Stmt->m_test[0], ASR::cmpopType::Eq); ASR::expr_t* right = PassUtils::create_compare_helper(al, loc, a_test, Case_Stmt->m_test[1], ASR::cmpopType::Eq); - test_expr = PassUtils::create_binop_helper(al, loc, left, right, ASR::binopType::Add); + test_expr = ASRUtils::EXPR(ASR::make_LogicalBinOp_t(al, loc, left, + ASR::logicalbinopType::Or, right, ASRUtils::expr_type(left), nullptr)); } else { ASR::expr_t* left = PassUtils::create_compare_helper(al, loc, a_test, Case_Stmt->m_test[0], ASR::cmpopType::Eq); ASR::expr_t* right = PassUtils::create_compare_helper(al, loc, a_test, Case_Stmt->m_test[1], ASR::cmpopType::Eq); - test_expr = PassUtils::create_binop_helper(al, loc, left, right, ASR::binopType::Add); + test_expr = ASRUtils::EXPR(ASR::make_LogicalBinOp_t(al, loc, left, + ASR::logicalbinopType::Or, right, ASRUtils::expr_type(left), nullptr)); for( std::uint32_t j = 2; j < Case_Stmt->n_test; j++ ) { ASR::expr_t* newExpr = PassUtils::create_compare_helper(al, loc, a_test, Case_Stmt->m_test[j], ASR::cmpopType::Eq); - test_expr = PassUtils::create_binop_helper(al, loc, test_expr, newExpr, ASR::binopType::Add); + test_expr = ASRUtils::EXPR(ASR::make_LogicalBinOp_t(al, loc, test_expr, + ASR::logicalbinopType::Or, newExpr, ASRUtils::expr_type(test_expr), nullptr)); } } return test_expr; @@ -77,7 +80,8 @@ inline ASR::expr_t* gen_test_expr_CaseStmt_Range(Allocator& al, const Location& } else if( Case_Stmt->m_start != nullptr && Case_Stmt->m_end != nullptr ) { ASR::expr_t* left = PassUtils::create_compare_helper(al, loc, Case_Stmt->m_start, a_test, ASR::cmpopType::LtE); ASR::expr_t* right = PassUtils::create_compare_helper(al, loc, a_test, Case_Stmt->m_end, ASR::cmpopType::LtE); - test_expr = PassUtils::create_binop_helper(al, loc, left, right, ASR::binopType::Mul); + test_expr = ASRUtils::EXPR(ASR::make_LogicalBinOp_t(al, loc, left, + ASR::logicalbinopType::And, right, ASRUtils::expr_type(left), nullptr)); } return test_expr; } diff --git a/src/libasr/pass/subroutine_from_function.cpp b/src/libasr/pass/subroutine_from_function.cpp index 33d0f94414..63a7c75473 100644 --- a/src/libasr/pass/subroutine_from_function.cpp +++ b/src/libasr/pass/subroutine_from_function.cpp @@ -19,8 +19,11 @@ class CreateFunctionFromSubroutine: public PassUtils::PassVisitor& function2subroutine; + + CreateFunctionFromSubroutine(Allocator &al_, + std::map& function2subroutine_) : + PassVisitor(al_, nullptr), function2subroutine(function2subroutine_) { pass_result.reserve(al, 1); } @@ -73,6 +76,7 @@ class CreateFunctionFromSubroutine: public PassUtils::PassVisitorm_return_var) ) { ASR::symbol_t* s_sub = create_subroutine_from_function(s); + function2subroutine[item.second] = s_sub; replace_vec.push_back(std::make_pair(item.first, s_sub)); } } @@ -86,7 +90,7 @@ class CreateFunctionFromSubroutine: public PassUtils::PassVisitoradd_symbol(item.first, item.second); + xx.m_global_scope->overwrite_symbol(item.first, item.second); } // Now visit everything else @@ -96,6 +100,7 @@ class CreateFunctionFromSubroutine: public PassUtils::PassVisitor > replace_vec; // FIXME: this is a hack, we need to pass in a non-const `x`, // which requires to generate a TransformVisitor. ASR::Module_t &xx = const_cast(x); @@ -112,13 +117,21 @@ class CreateFunctionFromSubroutine: public PassUtils::PassVisitorm_return_var) ) { ASR::symbol_t* s_sub = create_subroutine_from_function(s); + function2subroutine[item.second] = s_sub; // Update the symtab with this function changes - xx.m_symtab->add_symbol(item.first, s_sub); + replace_vec.push_back(std::make_pair(item.first, s_sub)); } } } } + // Updating the symbol table so that now the name + // of the function (which returned array) now points + // to the newly created subroutine. + for( auto& item: replace_vec ) { + current_scope->overwrite_symbol(item.first, item.second); + } + // Now visit everything else for (auto &item : x.m_symtab->get_scope()) { this->visit_symbol(*item.second); @@ -154,7 +167,7 @@ class CreateFunctionFromSubroutine: public PassUtils::PassVisitoradd_symbol(item.first, item.second); + current_scope->overwrite_symbol(item.first, item.second); } for (auto &item : x.m_symtab->get_scope()) { @@ -183,12 +196,39 @@ class ReplaceFunctionCallWithSubroutineCall: public PassUtils::PassVisitor& function2subroutine; + + ReplaceFunctionCallWithSubroutineCall(Allocator& al_, + std::map& function2subroutine_): + PassVisitor(al_, nullptr), result_var(nullptr), + function2subroutine(function2subroutine_) { pass_result.reserve(al, 1); } + void visit_ExternalSymbol(const ASR::ExternalSymbol_t& x) { + ASR::ExternalSymbol_t& xx = const_cast(x); + if( function2subroutine.find(xx.m_external) != function2subroutine.end() ) { + xx.m_external = function2subroutine[xx.m_external]; + } + } + + #define visit_ExternalSymbols(Node) PassVisitor::visit_##Node(x); \ + for (auto &item : x.m_symtab->get_scope()) { \ + if( is_a(*item.second) ) { \ + ASR::ExternalSymbol_t* s = ASR::down_cast(item.second); \ + visit_ExternalSymbol(*s); \ + } \ + } \ + + void visit_Program(const ASR::Program_t &x) { + visit_ExternalSymbols(Program) + } + + void visit_Module(const ASR::Module_t &x) { + visit_ExternalSymbols(Module) + } + void visit_Assignment(const ASR::Assignment_t& x) { if( PassUtils::is_aggregate_type(x.m_target) ) { result_var = x.m_target; @@ -239,9 +279,10 @@ class ReplaceFunctionCallWithSubroutineCall: public PassUtils::PassVisitor function2subroutine; + CreateFunctionFromSubroutine v(al, function2subroutine); v.visit_TranslationUnit(unit); - ReplaceFunctionCallWithSubroutineCall u(al); + ReplaceFunctionCallWithSubroutineCall u(al, function2subroutine); u.visit_TranslationUnit(unit); } diff --git a/src/libasr/runtime/lfortran_intrinsics.c b/src/libasr/runtime/lfortran_intrinsics.c index 114716d06d..7bb78c537f 100644 --- a/src/libasr/runtime/lfortran_intrinsics.c +++ b/src/libasr/runtime/lfortran_intrinsics.c @@ -876,6 +876,29 @@ LFORTRAN_API char* _lfortran_str_item(char* s, int32_t idx) { return res; } +// idx1 and idx2 both start from 1 +LFORTRAN_API char* _lfortran_str_copy(char* s, int32_t idx1, int32_t idx2) { + + int s_len = strlen(s); + if(idx1 > s_len || idx1 <= (-1*s_len)){ + printf("String index out of Bounds\n"); + exit(1); + } + if(idx1 <= 0) { + idx1 = s_len + idx1; + } + if(idx2 <= 0) { + idx2 = s_len + idx2; + } + char* dest_char = (char*)malloc(idx2-idx1+2); + for (int i=idx1; i <= idx2; i++) + { + dest_char[i-idx1] = s[i-1]; + } + dest_char[idx2-idx1+1] = '\0'; + return dest_char; +} + LFORTRAN_API char* _lfortran_str_slice(char* s, int32_t idx1, int32_t idx2, int32_t step, bool idx1_present, bool idx2_present) { int s_len = strlen(s); @@ -923,7 +946,47 @@ LFORTRAN_API char* _lfortran_str_slice(char* s, int32_t idx1, int32_t idx2, int3 return dest_char; } -LFORTRAN_API int _lfortran_str_len(char** s) +LFORTRAN_API char* _lfortran_str_slice_assign(char* s, char *r, int32_t idx1, int32_t idx2, int32_t step, + bool idx1_present, bool idx2_present) { + int s_len = strlen(s); + int r_len = strlen(r); + if (step == 0) { + printf("slice step cannot be zero\n"); + exit(1); + } + s_len = (s_len < r_len) ? r_len : s_len; + idx1 = idx1 < 0 ? idx1 + s_len : idx1; + idx2 = idx2 < 0 ? idx2 + s_len : idx2; + if (!idx1_present) { + if (step > 0) { + idx1 = 0; + } else { + idx1 = s_len - 1; + } + } + if (!idx2_present) { + if (step > 0) { + idx2 = s_len; + } else { + idx2 = -1; + } + } + if (idx1 == idx2 || + (step > 0 && (idx1 > idx2 || idx1 >= s_len)) || + (step < 0 && (idx1 < idx2 || idx2 >= s_len-1))) + return ""; + char* dest_char = (char*)malloc(s_len); + strcpy(dest_char, s); + int s_i = idx1, d_i = 0; + while((step > 0 && s_i >= idx1 && s_i < idx2) || + (step < 0 && s_i <= idx1 && s_i > idx2)) { + dest_char[s_i] = r[d_i++]; + s_i += step; + } + return dest_char; +} + +LFORTRAN_API int32_t _lfortran_str_len(char** s) { return strlen(*s); } @@ -972,6 +1035,10 @@ LFORTRAN_API void _lfortran_free(char* ptr) { free((void*)ptr); } +LFORTRAN_API void _lfortran_string_alloc(char** ptr, int32_t len) { + *ptr = (char *) malloc(sizeof(char)*len); +} + // size_plus_one is the size of the string including the null character LFORTRAN_API void _lfortran_string_init(int size_plus_one, char *s) { int size = size_plus_one-1; @@ -1210,6 +1277,49 @@ LFORTRAN_API int64_t _lpython_open(char *path, char *flags) return (int64_t)fd; } +FILE* unit_to_file[100]; +bool is_unit_to_file_init = false; + +LFORTRAN_API int64_t _lfortran_open(int32_t unit_num, char *f_name, char *status) +{ + if (!is_unit_to_file_init) { + for (int32_t i=0; i<100; i++) unit_to_file[i] = NULL; + is_unit_to_file_init = true; + } + if (f_name == NULL) { + f_name = "_lfortran_generated_file.txt"; + } + + // Presently we just consider write append mode. + status = "r+"; + FILE *fd; + fd = fopen(f_name, status); + if (!fd) + { + printf("Error in opening the file!\n"); + perror(f_name); + exit(1); + } + unit_to_file[unit_num] = fd; + return (int64_t)fd; +} + +LFORTRAN_API void _lfortran_read_int32(int32_t *p, int32_t unit_num) +{ + if (unit_num == -1) { + // Read from stdin + FILE *fp = fdopen(0, "r+"); + fread(p, sizeof(int32_t), 1, fp); + fclose(fp); + return; + } + if (!unit_to_file[unit_num]) { + printf("No file found with given unit\n"); + exit(1); + } + fread(p, sizeof(int32_t), 1, unit_to_file[unit_num]); +} + LFORTRAN_API char* _lpython_read(int64_t fd, int64_t n) { char *c = (char *) calloc(n, sizeof(char)); @@ -1232,6 +1342,19 @@ LFORTRAN_API void _lpython_close(int64_t fd) } } +LFORTRAN_API void _lfortran_close(int32_t unit_num) +{ + if (!unit_to_file[unit_num]) { + printf("No file found with given unit\n"); + exit(1); + } + if (fclose(unit_to_file[unit_num]) != 0) + { + printf("Error in closing the file!\n"); + exit(1); + } +} + LFORTRAN_API int32_t _lfortran_ichar(char *c) { return (int32_t) c[0]; } @@ -1569,3 +1692,11 @@ LFORTRAN_API void print_stacktrace_addresses(char *filename, bool use_colors) { } // << Runtime Stacktrace << ---------------------------------------------------- + +LFORTRAN_API char *_lfortran_get_env_variable(char *name) { + return getenv(name); +} + +LFORTRAN_API int _lfortran_exec_command(char *cmd) { + return system(cmd); +} diff --git a/src/libasr/runtime/lfortran_intrinsics.h b/src/libasr/runtime/lfortran_intrinsics.h index ae01305df2..a648255c15 100644 --- a/src/libasr/runtime/lfortran_intrinsics.h +++ b/src/libasr/runtime/lfortran_intrinsics.h @@ -159,7 +159,7 @@ LFORTRAN_API void _lfortran_strrepeat(char** s, int32_t n, char** dest); LFORTRAN_API char* _lfortran_strrepeat_c(char* s, int32_t n); LFORTRAN_API void _lfortran_strcat(char** s1, char** s2, char** dest); LFORTRAN_API void _lfortran_strcpy(char** x, char *y); -LFORTRAN_API int _lfortran_str_len(char** s); +LFORTRAN_API int32_t _lfortran_str_len(char** s); LFORTRAN_API int _lfortran_str_ord(char** s); LFORTRAN_API int _lfortran_str_ord_c(char* s); LFORTRAN_API char* _lfortran_str_chr(int c); @@ -169,10 +169,13 @@ LFORTRAN_API void _lfortran_memset(void* s, int32_t c, int32_t size); LFORTRAN_API int8_t* _lfortran_realloc(int8_t* ptr, int32_t size); LFORTRAN_API int8_t* _lfortran_calloc(int32_t count, int32_t size); LFORTRAN_API void _lfortran_free(char* ptr); +LFORTRAN_API void _lfortran_string_alloc(char** ptr, int32_t len); LFORTRAN_API void _lfortran_string_init(int size_plus_one, char *s); LFORTRAN_API char* _lfortran_str_item(char* s, int32_t idx); LFORTRAN_API char* _lfortran_str_slice(char* s, int32_t idx1, int32_t idx2, int32_t step, bool idx1_present, bool idx2_present); +LFORTRAN_API char* _lfortran_str_slice_assign(char* s, char *r, int32_t idx1, int32_t idx2, int32_t step, + bool idx1_present, bool idx2_present); LFORTRAN_API int32_t _lfortran_iand32(int32_t x, int32_t y); LFORTRAN_API int64_t _lfortran_iand64(int64_t x, int64_t y); LFORTRAN_API int32_t _lfortran_not32(int32_t x); @@ -211,8 +214,11 @@ LFORTRAN_API void _lfortran_i64sys_clock( LFORTRAN_API void _lfortran_sp_rand_num(float *x); LFORTRAN_API void _lfortran_dp_rand_num(double *x); LFORTRAN_API int64_t _lpython_open(char *path, char *flags); +LFORTRAN_API int64_t _lfortran_open(int32_t unit_num, char *f_name, char *status); LFORTRAN_API char* _lpython_read(int64_t fd, int64_t n); +LFORTRAN_API void _lfortran_read_int32(int32_t *p, int32_t unit_num); LFORTRAN_API void _lpython_close(int64_t fd); +LFORTRAN_API void _lfortran_close(int32_t unit_num); LFORTRAN_API int32_t _lfortran_ichar(char *c); LFORTRAN_API int32_t _lfortran_iachar(char *c); LFORTRAN_API int32_t _lfortran_all(bool *mask, int32_t n); @@ -220,6 +226,8 @@ LFORTRAN_API void _lpython_set_argv(int32_t argc_1, char *argv_1[]); LFORTRAN_API int32_t _lpython_get_argc(); LFORTRAN_API char *_lpython_get_argv(int32_t index); LFORTRAN_API void print_stacktrace_addresses(char *filename, bool use_colors); +LFORTRAN_API char *_lfortran_get_env_variable(char *name); +LFORTRAN_API int _lfortran_exec_command(char *cmd); #ifdef __cplusplus } diff --git a/src/libasr/stacktrace.h b/src/libasr/stacktrace.h index b90edfe70f..5a3e653943 100644 --- a/src/libasr/stacktrace.h +++ b/src/libasr/stacktrace.h @@ -1,6 +1,7 @@ #ifndef LFORTRAN_STACKTRACE_H #define LFORTRAN_STACKTRACE_H +#include #include #include diff --git a/src/libasr/utils.h b/src/libasr/utils.h index 3cad362ee7..908eed9659 100644 --- a/src/libasr/utils.h +++ b/src/libasr/utils.h @@ -52,6 +52,8 @@ struct CompilerOptions { std::string arg_o = ""; bool emit_debug_info = false; bool emit_debug_line_column = false; + bool verbose = false; + bool pass_cumulative = false; std::string import_path = ""; Platform platform; @@ -78,6 +80,8 @@ namespace LCompilers { bool inline_external_symbol_calls = true; // for inline_function_calls pass int64_t unroll_factor = 32; // for loop_unroll pass bool fast = false; // is fast flag enabled. + bool verbose = false; // For developer debugging + bool pass_cumulative = false; // Apply passes cumulatively }; } diff --git a/src/lpython/semantics/python_ast_to_asr.cpp b/src/lpython/semantics/python_ast_to_asr.cpp index ddcc6e26f7..11517c58ce 100644 --- a/src/lpython/semantics/python_ast_to_asr.cpp +++ b/src/lpython/semantics/python_ast_to_asr.cpp @@ -606,18 +606,22 @@ class CommonVisitor : public AST::BaseVisitor { loc); } char *fn_name = ASRUtils::symbol_name(t); - ASR::asr_t *fn = ASR::make_ExternalSymbol_t( - al, t->base.loc, - /* a_symtab */ current_scope, - /* a_name */ fn_name, - t, - m->m_name, nullptr, 0, fn_name, - ASR::accessType::Private - ); std::string sym = fn_name; - - current_scope->add_symbol(sym, ASR::down_cast(fn)); - ASR::symbol_t *v = ASR::down_cast(fn); + ASR::symbol_t *v = nullptr; + if( current_scope->get_symbol(sym) == nullptr ) { + ASR::asr_t *fn = ASR::make_ExternalSymbol_t( + al, t->base.loc, + /* a_symtab */ current_scope, + /* a_name */ fn_name, + t, + m->m_name, nullptr, 0, fn_name, + ASR::accessType::Private + ); + current_scope->add_symbol(sym, ASR::down_cast(fn)); + v = ASR::down_cast(fn); + } else { + v = current_scope->get_symbol(sym); + } // Now we need to add the module `m` with the intrinsic function // into the current module dependencies @@ -2272,7 +2276,8 @@ class CommonVisitor : public AST::BaseVisitor { current_body ) { throw SemanticError("Initialisation of " + var_name + " must reduce to a compile time constant.", loc); } - current_scope->add_symbol(var_name, v_sym); + + current_scope->add_or_overwrite_symbol(var_name, v_sym); } ASR::asr_t* create_CPtrToPointerFromArgs(AST::expr_t* ast_cptr, AST::expr_t* ast_pptr, @@ -2586,7 +2591,7 @@ class CommonVisitor : public AST::BaseVisitor { struct_dependencies.p, struct_dependencies.size(), member_names.p, member_names.size(), class_abi, ASR::accessType::Public, - is_packed, algined_expr, + is_packed, false, algined_expr, nullptr)); current_scope = parent_scope; current_scope->add_symbol(std::string(x.m_name), class_type); @@ -4687,7 +4692,7 @@ class BodyVisitor : public CommonVisitor { tmp = ASR::make_DoConcurrentLoop_t(al, x.base.base.loc, head, body.p, body.size()); } else { - tmp = ASR::make_DoLoop_t(al, x.base.base.loc, head, + tmp = ASR::make_DoLoop_t(al, x.base.base.loc, nullptr, head, body.p, body.size()); } @@ -5204,7 +5209,7 @@ class BodyVisitor : public CommonVisitor { Vec body; body.reserve(al, x.n_body); transform_stmts(body, x.n_body, x.m_body); - tmp = ASR::make_WhileLoop_t(al, x.base.base.loc, test, body.p, + tmp = ASR::make_WhileLoop_t(al, x.base.base.loc, nullptr, test, body.p, body.size()); } @@ -5525,11 +5530,11 @@ class BodyVisitor : public CommonVisitor { } void visit_Continue(const AST::Continue_t &x) { - tmp = ASR::make_Cycle_t(al, x.base.base.loc); + tmp = ASR::make_Cycle_t(al, x.base.base.loc, nullptr); } void visit_Break(const AST::Break_t &x) { - tmp = ASR::make_Exit_t(al, x.base.base.loc); + tmp = ASR::make_Exit_t(al, x.base.base.loc, nullptr); } void visit_Raise(const AST::Raise_t &x) { diff --git a/tests/reference/asr-elemental_01-b58df26.json b/tests/reference/asr-elemental_01-b58df26.json index fe8bd36530..e7b13c7564 100644 --- a/tests/reference/asr-elemental_01-b58df26.json +++ b/tests/reference/asr-elemental_01-b58df26.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-elemental_01-b58df26.stdout", - "stdout_hash": "f43c40aa18f9a100a7945547d39e21e943e8176f5c744e1778123a50", + "stdout_hash": "8f1954704c9ed29be2cbbe96c1d8bc830bbcadccb00a605570d3862b", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-elemental_01-b58df26.stdout b/tests/reference/asr-elemental_01-b58df26.stdout index 3d4af6d8f8..77489cc372 100644 --- a/tests/reference/asr-elemental_01-b58df26.stdout +++ b/tests/reference/asr-elemental_01-b58df26.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 218 {_lpython_main_program: (Function (SymbolTable 217 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [elemental_sin elemental_cos elemental_trig_identity elemental_sum elemental_mul] [] [(SubroutineCall 218 elemental_sin () [] ()) (SubroutineCall 218 elemental_cos () [] ()) (SubroutineCall 218 elemental_trig_identity () [] ()) (SubroutineCall 218 elemental_sum () [] ()) (SubroutineCall 218 elemental_mul () [] ())] () Public .false. .false.), cos: (ExternalSymbol 218 cos 3 cos numpy [] cos Public), elemental_cos: (Function (SymbolTable 191 {array2d: (Variable 191 array2d [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 [])))]) Source Public Required .false.), cos2d: (Variable 191 cos2d [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 [])))]) Source Public Required .false.), cos@__lpython_overloaded_0__cos: (ExternalSymbol 191 cos@__lpython_overloaded_0__cos 3 __lpython_overloaded_0__cos numpy [] __lpython_overloaded_0__cos Public), i: (Variable 191 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 191 j [] Local () () Default (Integer 4 []) Source Public Required .false.)}) elemental_cos (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [cos@__lpython_overloaded_0__cos verify2d] [] [(DoLoop ((Var 191 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 256 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 255 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 191 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 64 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 63 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 191 array2d) [(() (Var 191 i) ()) (() (Var 191 j) ())] (Real 8 []) RowMajor ()) (Cast (IntegerBinOp (Var 191 i) Add (Var 191 j) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) ())])]) (= (Var 191 cos2d) (RealBinOp (FunctionCall 191 cos@__lpython_overloaded_0__cos 218 cos [((Var 191 array2d))] (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 [])))]) () ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 [])))]) ()) ()) (SubroutineCall 218 verify2d () [((Var 191 array2d)) ((Var 191 cos2d)) ((IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 64 (Integer 4 [])))] ())] () Public .false. .false.), elemental_mul: (Function (SymbolTable 189 {array_a: (Variable 189 array_a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), array_b: (Variable 189 array_b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), array_c: (Variable 189 array_c [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 189 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 189 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 189 k [] Local () () Default (Integer 4 []) Source Public Required .false.)}) elemental_mul (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [verify1d_mul] [] [(DoLoop ((Var 189 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 100 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 99 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 189 array_a) [(() (Var 189 i) ())] (Real 8 []) RowMajor ()) (Cast (Var 189 i) IntegerToReal (Real 8 []) ()) ())]) (DoLoop ((Var 189 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 100 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 99 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 189 array_b) [(() (Var 189 j) ())] (Real 8 []) RowMajor ()) (Cast (IntegerBinOp (Var 189 j) Add (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) ())]) (= (Var 189 array_c) (RealBinOp (RealBinOp (RealBinOp (Var 189 array_a) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) Mul (RealConstant 5.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) Mul (RealBinOp (Var 189 array_b) Pow (RealConstant 3.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) ()) (SubroutineCall 218 verify1d_mul () [((Var 189 array_a)) ((Var 189 array_b)) ((Var 189 array_c)) ((IntegerConstant 100 (Integer 4 [])))] ())] () Public .false. .false.), elemental_sin: (Function (SymbolTable 190 {array1d: (Variable 190 array1d [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) Source Public Required .false.), arraynd: (Variable 190 arraynd [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 190 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 190 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 190 k [] Local () () Default (Integer 4 []) Source Public Required .false.), sin1d: (Variable 190 sin1d [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) Source Public Required .false.), sin@__lpython_overloaded_0__sin: (ExternalSymbol 190 sin@__lpython_overloaded_0__sin 3 __lpython_overloaded_0__sin numpy [] __lpython_overloaded_0__sin Public), sin@__lpython_overloaded_1__sin: (ExternalSymbol 190 sin@__lpython_overloaded_1__sin 3 __lpython_overloaded_1__sin numpy [] __lpython_overloaded_1__sin Public), sinnd: (Variable 190 sinnd [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.)}) elemental_sin (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [sin@__lpython_overloaded_1__sin sin@__lpython_overloaded_1__sin verify1d sin@__lpython_overloaded_0__sin verifynd] [] [(DoLoop ((Var 190 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 256 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 255 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 190 array1d) [(() (Var 190 i) ())] (Real 4 []) RowMajor ()) (Cast (Var 190 i) IntegerToReal (Real 4 []) ()) ())]) (= (Var 190 sin1d) (FunctionCall 190 sin@__lpython_overloaded_1__sin 218 sin [((FunctionCall 190 sin@__lpython_overloaded_1__sin 218 sin [((Var 190 array1d))] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) () ()))] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) () ()) ()) (SubroutineCall 218 verify1d () [((Var 190 array1d)) ((Var 190 sin1d)) ((IntegerConstant 256 (Integer 4 [])))] ()) (DoLoop ((Var 190 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 256 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 255 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 190 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 64 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 63 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 190 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 190 arraynd) [(() (Var 190 i) ()) (() (Var 190 j) ()) (() (Var 190 k) ())] (Real 8 []) RowMajor ()) (Cast (IntegerBinOp (IntegerBinOp (Var 190 i) Add (Var 190 j) (Integer 4 []) ()) Add (Var 190 k) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) ())])])]) (= (Var 190 sinnd) (RealBinOp (FunctionCall 190 sin@__lpython_overloaded_0__sin 218 sin [((Var 190 arraynd))] (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) () ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) ()) ()) (SubroutineCall 218 verifynd () [((Var 190 arraynd)) ((Var 190 sinnd)) ((IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 16 (Integer 4 [])))] ())] () Public .false. .false.), elemental_sum: (Function (SymbolTable 188 {array_a: (Variable 188 array_a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), array_b: (Variable 188 array_b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), array_c: (Variable 188 array_c [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 188 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 188 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 188 k [] Local () () Default (Integer 4 []) Source Public Required .false.)}) elemental_sum (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [verify1d_sum] [] [(DoLoop ((Var 188 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 100 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 99 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 188 array_a) [(() (Var 188 i) ())] (Real 8 []) RowMajor ()) (Cast (Var 188 i) IntegerToReal (Real 8 []) ()) ())]) (DoLoop ((Var 188 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 100 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 99 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 188 array_b) [(() (Var 188 j) ())] (Real 8 []) RowMajor ()) (Cast (IntegerBinOp (Var 188 j) Add (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) ())]) (= (Var 188 array_c) (RealBinOp (RealBinOp (Var 188 array_a) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) Add (RealBinOp (RealConstant 5.000000 (Real 8 [])) Mul (RealBinOp (Var 188 array_b) Pow (RealConstant 3.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) ()) (SubroutineCall 218 verify1d_sum () [((Var 188 array_a)) ((Var 188 array_b)) ((Var 188 array_c)) ((IntegerConstant 100 (Integer 4 [])))] ())] () Public .false. .false.), elemental_trig_identity: (Function (SymbolTable 192 {arraynd: (Variable 192 arraynd [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) Source Public Required .false.), cos@__lpython_overloaded_1__cos: (ExternalSymbol 192 cos@__lpython_overloaded_1__cos 3 __lpython_overloaded_1__cos numpy [] __lpython_overloaded_1__cos Public), eps: (Variable 192 eps [] Local () () Default (Real 4 []) Source Public Required .false.), i: (Variable 192 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 192 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 192 k [] Local () () Default (Integer 4 []) Source Public Required .false.), l: (Variable 192 l [] Local () () Default (Integer 4 []) Source Public Required .false.), newshape: (Variable 192 newshape [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), observed: (Variable 192 observed [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) Source Public Required .false.), observed1d: (Variable 192 observed1d [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 65536 (Integer 4 [])))]) Source Public Required .false.), sin@__lpython_overloaded_1__sin: (ExternalSymbol 192 sin@__lpython_overloaded_1__sin 3 __lpython_overloaded_1__sin numpy [] __lpython_overloaded_1__sin Public)}) elemental_trig_identity (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [sin@__lpython_overloaded_1__sin cos@__lpython_overloaded_1__cos] [] [(= (Var 192 eps) (Cast (RealConstant 0.000001 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 0.000001 (Real 4 []))) ()) (DoLoop ((Var 192 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 64 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 63 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 192 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 32 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 31 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 192 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 8 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 7 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 192 l) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 4 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 3 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 192 arraynd) [(() (Var 192 i) ()) (() (Var 192 j) ()) (() (Var 192 k) ()) (() (Var 192 l) ())] (Real 4 []) RowMajor ()) (Cast (IntegerBinOp (IntegerBinOp (IntegerBinOp (Var 192 i) Add (Var 192 j) (Integer 4 []) ()) Add (Var 192 k) (Integer 4 []) ()) Add (Var 192 l) (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ())])])])]) (= (Var 192 observed) (RealBinOp (RealBinOp (FunctionCall 192 sin@__lpython_overloaded_1__sin 218 sin [((Var 192 arraynd))] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) () ()) Pow (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) ()) Add (RealBinOp (FunctionCall 192 cos@__lpython_overloaded_1__cos 218 cos [((Var 192 arraynd))] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) () ()) Pow (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) ()) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) ()) ()) (= (ArrayItem (Var 192 newshape) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 65536 (Integer 4 [])) ()) (= (Var 192 observed1d) (ArrayReshape (Var 192 observed) (Var 192 newshape) (Real 4 [(() ())]) ()) ()) (DoLoop ((Var 192 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 65536 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 65535 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (ArrayItem (Var 192 observed1d) [(() (Var 192 i) ())] (Real 4 []) RowMajor ()) Sub (Cast (RealConstant 1.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ())] 0 (Real 4 []) ()) LtE (Var 192 eps) (Logical 4 []) ()) ())])] () Public .false. .false.), sin: (ExternalSymbol 218 sin 3 sin numpy [] sin Public), verify1d: (Function (SymbolTable 183 {array: (Variable 183 array [] InOut () () Default (Real 4 [(() ())]) Source Public Required .false.), block: (Block (SymbolTable 193 {sin@__lpython_overloaded_1__sin: (ExternalSymbol 193 sin@__lpython_overloaded_1__sin 3 __lpython_overloaded_1__sin numpy [] __lpython_overloaded_1__sin Public)}) block [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (FunctionCall 193 sin@__lpython_overloaded_1__sin 218 sin [((FunctionCall 193 sin@__lpython_overloaded_1__sin 218 sin [((ArrayItem (Var 183 array) [(() (Var 183 i) ())] (Real 4 []) RowMajor ()))] (Real 4 []) () ()))] (Real 4 []) () ()) Sub (ArrayItem (Var 183 result) [(() (Var 183 i) ())] (Real 4 []) RowMajor ()) (Real 4 []) ())] 0 (Real 4 []) ()) LtE (Var 183 eps) (Logical 4 []) ()) ())]), eps: (Variable 183 eps [] Local () () Default (Real 4 []) Source Public Required .false.), i: (Variable 183 i [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 183 result [] InOut () () Default (Real 4 [(() ())]) Source Public Required .false.), size: (Variable 183 size [] In () () Default (Integer 4 []) Source Public Required .false.)}) verify1d (FunctionType [(Real 4 [(() ())]) (Real 4 [(() ())]) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [sin@__lpython_overloaded_1__sin sin@__lpython_overloaded_1__sin sin@__lpython_overloaded_1__sin sin@__lpython_overloaded_1__sin] [(Var 183 array) (Var 183 result) (Var 183 size)] [(= (Var 183 eps) (Cast (RealConstant 0.000001 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 0.000001 (Real 4 []))) ()) (DoLoop ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 183 size) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 183 block)])] () Public .false. .false.), verify1d_mul: (Function (SymbolTable 187 {array_a: (Variable 187 array_a [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), array_b: (Variable 187 array_b [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), eps: (Variable 187 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 187 i [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 187 result [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), size: (Variable 187 size [] In () () Default (Integer 4 []) Source Public Required .false.)}) verify1d_mul (FunctionType [(Real 8 [(() ())]) (Real 8 [(() ())]) (Real 8 [(() ())]) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 187 array_a) (Var 187 array_b) (Var 187 result) (Var 187 size)] [(= (Var 187 eps) (RealConstant 0.000000 (Real 8 [])) ()) (DoLoop ((Var 187 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 187 size) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (RealBinOp (RealBinOp (ArrayItem (Var 187 array_a) [(() (Var 187 i) ())] (Real 8 []) RowMajor ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Mul (RealConstant 5.000000 (Real 8 [])) (Real 8 []) ()) Mul (RealBinOp (ArrayItem (Var 187 array_b) [(() (Var 187 i) ())] (Real 8 []) RowMajor ()) Pow (RealConstant 3.000000 (Real 8 [])) (Real 8 []) ()) (Real 8 []) ()) Sub (ArrayItem (Var 187 result) [(() (Var 187 i) ())] (Real 8 []) RowMajor ()) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 187 eps) (Logical 4 []) ()) ())])] () Public .false. .false.), verify1d_sum: (Function (SymbolTable 186 {array_a: (Variable 186 array_a [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), array_b: (Variable 186 array_b [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), eps: (Variable 186 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 186 i [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 186 result [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), size: (Variable 186 size [] In () () Default (Integer 4 []) Source Public Required .false.)}) verify1d_sum (FunctionType [(Real 8 [(() ())]) (Real 8 [(() ())]) (Real 8 [(() ())]) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 186 array_a) (Var 186 array_b) (Var 186 result) (Var 186 size)] [(= (Var 186 eps) (RealConstant 0.000000 (Real 8 [])) ()) (DoLoop ((Var 186 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 186 size) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (RealBinOp (ArrayItem (Var 186 array_a) [(() (Var 186 i) ())] (Real 8 []) RowMajor ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Add (RealBinOp (RealConstant 5.000000 (Real 8 [])) Mul (RealBinOp (ArrayItem (Var 186 array_b) [(() (Var 186 i) ())] (Real 8 []) RowMajor ()) Pow (RealConstant 3.000000 (Real 8 [])) (Real 8 []) ()) (Real 8 []) ()) (Real 8 []) ()) Sub (ArrayItem (Var 186 result) [(() (Var 186 i) ())] (Real 8 []) RowMajor ()) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 186 eps) (Logical 4 []) ()) ())])] () Public .false. .false.), verify2d: (Function (SymbolTable 185 {array: (Variable 185 array [] InOut () () Default (Real 8 [(() ()) (() ())]) Source Public Required .false.), block: (Block (SymbolTable 197 {block: (Block (SymbolTable 198 {cos@__lpython_overloaded_0__cos: (ExternalSymbol 198 cos@__lpython_overloaded_0__cos 3 __lpython_overloaded_0__cos numpy [] __lpython_overloaded_0__cos Public)}) block [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (FunctionCall 198 cos@__lpython_overloaded_0__cos 218 cos [((ArrayItem (Var 185 array) [(() (Var 185 i) ()) (() (Var 185 j) ())] (Real 8 []) RowMajor ()))] (Real 8 []) () ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Sub (ArrayItem (Var 185 result) [(() (Var 185 i) ()) (() (Var 185 j) ())] (Real 8 []) RowMajor ()) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 185 eps) (Logical 4 []) ()) ())])}) block [(DoLoop ((Var 185 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 185 size2) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 197 block)])]), eps: (Variable 185 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 185 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 185 j [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 185 result [] InOut () () Default (Real 8 [(() ()) (() ())]) Source Public Required .false.), size1: (Variable 185 size1 [] In () () Default (Integer 4 []) Source Public Required .false.), size2: (Variable 185 size2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) verify2d (FunctionType [(Real 8 [(() ()) (() ())]) (Real 8 [(() ()) (() ())]) (Integer 4 []) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [cos@__lpython_overloaded_0__cos cos@__lpython_overloaded_0__cos cos@__lpython_overloaded_0__cos] [(Var 185 array) (Var 185 result) (Var 185 size1) (Var 185 size2)] [(= (Var 185 eps) (RealConstant 0.000000 (Real 8 [])) ()) (DoLoop ((Var 185 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 185 size1) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 185 block)])] () Public .false. .false.), verifynd: (Function (SymbolTable 184 {array: (Variable 184 array [] InOut () () Default (Real 8 [(() ()) (() ()) (() ())]) Source Public Required .false.), block: (Block (SymbolTable 194 {block: (Block (SymbolTable 195 {block: (Block (SymbolTable 196 {sin@__lpython_overloaded_0__sin: (ExternalSymbol 196 sin@__lpython_overloaded_0__sin 3 __lpython_overloaded_0__sin numpy [] __lpython_overloaded_0__sin Public)}) block [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (FunctionCall 196 sin@__lpython_overloaded_0__sin 218 sin [((ArrayItem (Var 184 array) [(() (Var 184 i) ()) (() (Var 184 j) ()) (() (Var 184 k) ())] (Real 8 []) RowMajor ()))] (Real 8 []) () ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Sub (ArrayItem (Var 184 result) [(() (Var 184 i) ()) (() (Var 184 j) ()) (() (Var 184 k) ())] (Real 8 []) RowMajor ()) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 184 eps) (Logical 4 []) ()) ())])}) block [(DoLoop ((Var 184 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 184 size3) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 195 block)])])}) block [(DoLoop ((Var 184 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 184 size2) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 194 block)])]), eps: (Variable 184 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 184 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 184 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 184 k [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 184 result [] InOut () () Default (Real 8 [(() ()) (() ()) (() ())]) Source Public Required .false.), size1: (Variable 184 size1 [] In () () Default (Integer 4 []) Source Public Required .false.), size2: (Variable 184 size2 [] In () () Default (Integer 4 []) Source Public Required .false.), size3: (Variable 184 size3 [] In () () Default (Integer 4 []) Source Public Required .false.)}) verifynd (FunctionType [(Real 8 [(() ()) (() ()) (() ())]) (Real 8 [(() ()) (() ()) (() ())]) (Integer 4 []) (Integer 4 []) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [sin@__lpython_overloaded_0__sin sin@__lpython_overloaded_0__sin sin@__lpython_overloaded_0__sin sin@__lpython_overloaded_0__sin] [(Var 184 array) (Var 184 result) (Var 184 size1) (Var 184 size2) (Var 184 size3)] [(= (Var 184 eps) (RealConstant 0.000000 (Real 8 [])) ()) (DoLoop ((Var 184 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 184 size1) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 184 block)])] () Public .false. .false.)}) _global_symbols [numpy] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 216 {_lpython_main_program: (ExternalSymbol 216 _lpython_main_program 218 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 216 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 218 {_lpython_main_program: (Function (SymbolTable 217 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [elemental_sin elemental_cos elemental_trig_identity elemental_sum elemental_mul] [] [(SubroutineCall 218 elemental_sin () [] ()) (SubroutineCall 218 elemental_cos () [] ()) (SubroutineCall 218 elemental_trig_identity () [] ()) (SubroutineCall 218 elemental_sum () [] ()) (SubroutineCall 218 elemental_mul () [] ())] () Public .false. .false.), cos: (ExternalSymbol 218 cos 3 cos numpy [] cos Public), elemental_cos: (Function (SymbolTable 191 {array2d: (Variable 191 array2d [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 [])))]) Source Public Required .false.), cos2d: (Variable 191 cos2d [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 [])))]) Source Public Required .false.), cos@__lpython_overloaded_0__cos: (ExternalSymbol 191 cos@__lpython_overloaded_0__cos 3 __lpython_overloaded_0__cos numpy [] __lpython_overloaded_0__cos Public), i: (Variable 191 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 191 j [] Local () () Default (Integer 4 []) Source Public Required .false.)}) elemental_cos (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [cos@__lpython_overloaded_0__cos verify2d] [] [(DoLoop () ((Var 191 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 256 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 255 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 191 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 64 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 63 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 191 array2d) [(() (Var 191 i) ()) (() (Var 191 j) ())] (Real 8 []) RowMajor ()) (Cast (IntegerBinOp (Var 191 i) Add (Var 191 j) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) ())])]) (= (Var 191 cos2d) (RealBinOp (FunctionCall 191 cos@__lpython_overloaded_0__cos 218 cos [((Var 191 array2d))] (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 [])))]) () ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 [])))]) ()) ()) (SubroutineCall 218 verify2d () [((Var 191 array2d)) ((Var 191 cos2d)) ((IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 64 (Integer 4 [])))] ())] () Public .false. .false.), elemental_mul: (Function (SymbolTable 189 {array_a: (Variable 189 array_a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), array_b: (Variable 189 array_b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), array_c: (Variable 189 array_c [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 189 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 189 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 189 k [] Local () () Default (Integer 4 []) Source Public Required .false.)}) elemental_mul (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [verify1d_mul] [] [(DoLoop () ((Var 189 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 100 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 99 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 189 array_a) [(() (Var 189 i) ())] (Real 8 []) RowMajor ()) (Cast (Var 189 i) IntegerToReal (Real 8 []) ()) ())]) (DoLoop () ((Var 189 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 100 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 99 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 189 array_b) [(() (Var 189 j) ())] (Real 8 []) RowMajor ()) (Cast (IntegerBinOp (Var 189 j) Add (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) ())]) (= (Var 189 array_c) (RealBinOp (RealBinOp (RealBinOp (Var 189 array_a) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) Mul (RealConstant 5.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) Mul (RealBinOp (Var 189 array_b) Pow (RealConstant 3.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) ()) (SubroutineCall 218 verify1d_mul () [((Var 189 array_a)) ((Var 189 array_b)) ((Var 189 array_c)) ((IntegerConstant 100 (Integer 4 [])))] ())] () Public .false. .false.), elemental_sin: (Function (SymbolTable 190 {array1d: (Variable 190 array1d [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) Source Public Required .false.), arraynd: (Variable 190 arraynd [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 190 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 190 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 190 k [] Local () () Default (Integer 4 []) Source Public Required .false.), sin1d: (Variable 190 sin1d [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) Source Public Required .false.), sin@__lpython_overloaded_0__sin: (ExternalSymbol 190 sin@__lpython_overloaded_0__sin 3 __lpython_overloaded_0__sin numpy [] __lpython_overloaded_0__sin Public), sin@__lpython_overloaded_1__sin: (ExternalSymbol 190 sin@__lpython_overloaded_1__sin 3 __lpython_overloaded_1__sin numpy [] __lpython_overloaded_1__sin Public), sinnd: (Variable 190 sinnd [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.)}) elemental_sin (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [sin@__lpython_overloaded_1__sin sin@__lpython_overloaded_1__sin verify1d sin@__lpython_overloaded_0__sin verifynd] [] [(DoLoop () ((Var 190 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 256 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 255 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 190 array1d) [(() (Var 190 i) ())] (Real 4 []) RowMajor ()) (Cast (Var 190 i) IntegerToReal (Real 4 []) ()) ())]) (= (Var 190 sin1d) (FunctionCall 190 sin@__lpython_overloaded_1__sin 218 sin [((FunctionCall 190 sin@__lpython_overloaded_1__sin 218 sin [((Var 190 array1d))] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) () ()))] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) () ()) ()) (SubroutineCall 218 verify1d () [((Var 190 array1d)) ((Var 190 sin1d)) ((IntegerConstant 256 (Integer 4 [])))] ()) (DoLoop () ((Var 190 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 256 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 255 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 190 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 64 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 63 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 190 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 190 arraynd) [(() (Var 190 i) ()) (() (Var 190 j) ()) (() (Var 190 k) ())] (Real 8 []) RowMajor ()) (Cast (IntegerBinOp (IntegerBinOp (Var 190 i) Add (Var 190 j) (Integer 4 []) ()) Add (Var 190 k) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) ())])])]) (= (Var 190 sinnd) (RealBinOp (FunctionCall 190 sin@__lpython_overloaded_0__sin 218 sin [((Var 190 arraynd))] (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) () ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) ()) ()) (SubroutineCall 218 verifynd () [((Var 190 arraynd)) ((Var 190 sinnd)) ((IntegerConstant 256 (Integer 4 []))) ((IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 16 (Integer 4 [])))] ())] () Public .false. .false.), elemental_sum: (Function (SymbolTable 188 {array_a: (Variable 188 array_a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), array_b: (Variable 188 array_b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), array_c: (Variable 188 array_c [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 188 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 188 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 188 k [] Local () () Default (Integer 4 []) Source Public Required .false.)}) elemental_sum (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [verify1d_sum] [] [(DoLoop () ((Var 188 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 100 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 99 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 188 array_a) [(() (Var 188 i) ())] (Real 8 []) RowMajor ()) (Cast (Var 188 i) IntegerToReal (Real 8 []) ()) ())]) (DoLoop () ((Var 188 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 100 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 99 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 188 array_b) [(() (Var 188 j) ())] (Real 8 []) RowMajor ()) (Cast (IntegerBinOp (Var 188 j) Add (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) ())]) (= (Var 188 array_c) (RealBinOp (RealBinOp (Var 188 array_a) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) Add (RealBinOp (RealConstant 5.000000 (Real 8 [])) Mul (RealBinOp (Var 188 array_b) Pow (RealConstant 3.000000 (Real 8 [])) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 100 (Integer 4 [])))]) ()) ()) (SubroutineCall 218 verify1d_sum () [((Var 188 array_a)) ((Var 188 array_b)) ((Var 188 array_c)) ((IntegerConstant 100 (Integer 4 [])))] ())] () Public .false. .false.), elemental_trig_identity: (Function (SymbolTable 192 {arraynd: (Variable 192 arraynd [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) Source Public Required .false.), cos@__lpython_overloaded_1__cos: (ExternalSymbol 192 cos@__lpython_overloaded_1__cos 3 __lpython_overloaded_1__cos numpy [] __lpython_overloaded_1__cos Public), eps: (Variable 192 eps [] Local () () Default (Real 4 []) Source Public Required .false.), i: (Variable 192 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 192 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 192 k [] Local () () Default (Integer 4 []) Source Public Required .false.), l: (Variable 192 l [] Local () () Default (Integer 4 []) Source Public Required .false.), newshape: (Variable 192 newshape [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), observed: (Variable 192 observed [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) Source Public Required .false.), observed1d: (Variable 192 observed1d [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 65536 (Integer 4 [])))]) Source Public Required .false.), sin@__lpython_overloaded_1__sin: (ExternalSymbol 192 sin@__lpython_overloaded_1__sin 3 __lpython_overloaded_1__sin numpy [] __lpython_overloaded_1__sin Public)}) elemental_trig_identity (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [sin@__lpython_overloaded_1__sin cos@__lpython_overloaded_1__cos] [] [(= (Var 192 eps) (Cast (RealConstant 0.000001 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 0.000001 (Real 4 []))) ()) (DoLoop () ((Var 192 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 64 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 63 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 192 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 32 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 31 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 192 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 8 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 7 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 192 l) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 4 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 3 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 192 arraynd) [(() (Var 192 i) ()) (() (Var 192 j) ()) (() (Var 192 k) ()) (() (Var 192 l) ())] (Real 4 []) RowMajor ()) (Cast (IntegerBinOp (IntegerBinOp (IntegerBinOp (Var 192 i) Add (Var 192 j) (Integer 4 []) ()) Add (Var 192 k) (Integer 4 []) ()) Add (Var 192 l) (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ())])])])]) (= (Var 192 observed) (RealBinOp (RealBinOp (FunctionCall 192 sin@__lpython_overloaded_1__sin 218 sin [((Var 192 arraynd))] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) () ()) Pow (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) ()) Add (RealBinOp (FunctionCall 192 cos@__lpython_overloaded_1__cos 218 cos [((Var 192 arraynd))] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) () ()) Pow (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) ()) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 64 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 32 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 8 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])))]) ()) ()) (= (ArrayItem (Var 192 newshape) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 65536 (Integer 4 [])) ()) (= (Var 192 observed1d) (ArrayReshape (Var 192 observed) (Var 192 newshape) (Real 4 [(() ())]) ()) ()) (DoLoop () ((Var 192 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 65536 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 65535 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (ArrayItem (Var 192 observed1d) [(() (Var 192 i) ())] (Real 4 []) RowMajor ()) Sub (Cast (RealConstant 1.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ())] 0 (Real 4 []) ()) LtE (Var 192 eps) (Logical 4 []) ()) ())])] () Public .false. .false.), sin: (ExternalSymbol 218 sin 3 sin numpy [] sin Public), verify1d: (Function (SymbolTable 183 {array: (Variable 183 array [] InOut () () Default (Real 4 [(() ())]) Source Public Required .false.), block: (Block (SymbolTable 193 {sin@__lpython_overloaded_1__sin: (ExternalSymbol 193 sin@__lpython_overloaded_1__sin 3 __lpython_overloaded_1__sin numpy [] __lpython_overloaded_1__sin Public)}) block [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (FunctionCall 193 sin@__lpython_overloaded_1__sin 218 sin [((FunctionCall 193 sin@__lpython_overloaded_1__sin 218 sin [((ArrayItem (Var 183 array) [(() (Var 183 i) ())] (Real 4 []) RowMajor ()))] (Real 4 []) () ()))] (Real 4 []) () ()) Sub (ArrayItem (Var 183 result) [(() (Var 183 i) ())] (Real 4 []) RowMajor ()) (Real 4 []) ())] 0 (Real 4 []) ()) LtE (Var 183 eps) (Logical 4 []) ()) ())]), eps: (Variable 183 eps [] Local () () Default (Real 4 []) Source Public Required .false.), i: (Variable 183 i [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 183 result [] InOut () () Default (Real 4 [(() ())]) Source Public Required .false.), size: (Variable 183 size [] In () () Default (Integer 4 []) Source Public Required .false.)}) verify1d (FunctionType [(Real 4 [(() ())]) (Real 4 [(() ())]) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [sin@__lpython_overloaded_1__sin sin@__lpython_overloaded_1__sin sin@__lpython_overloaded_1__sin sin@__lpython_overloaded_1__sin] [(Var 183 array) (Var 183 result) (Var 183 size)] [(= (Var 183 eps) (Cast (RealConstant 0.000001 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 0.000001 (Real 4 []))) ()) (DoLoop () ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 183 size) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 183 block)])] () Public .false. .false.), verify1d_mul: (Function (SymbolTable 187 {array_a: (Variable 187 array_a [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), array_b: (Variable 187 array_b [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), eps: (Variable 187 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 187 i [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 187 result [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), size: (Variable 187 size [] In () () Default (Integer 4 []) Source Public Required .false.)}) verify1d_mul (FunctionType [(Real 8 [(() ())]) (Real 8 [(() ())]) (Real 8 [(() ())]) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 187 array_a) (Var 187 array_b) (Var 187 result) (Var 187 size)] [(= (Var 187 eps) (RealConstant 0.000000 (Real 8 [])) ()) (DoLoop () ((Var 187 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 187 size) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (RealBinOp (RealBinOp (ArrayItem (Var 187 array_a) [(() (Var 187 i) ())] (Real 8 []) RowMajor ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Mul (RealConstant 5.000000 (Real 8 [])) (Real 8 []) ()) Mul (RealBinOp (ArrayItem (Var 187 array_b) [(() (Var 187 i) ())] (Real 8 []) RowMajor ()) Pow (RealConstant 3.000000 (Real 8 [])) (Real 8 []) ()) (Real 8 []) ()) Sub (ArrayItem (Var 187 result) [(() (Var 187 i) ())] (Real 8 []) RowMajor ()) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 187 eps) (Logical 4 []) ()) ())])] () Public .false. .false.), verify1d_sum: (Function (SymbolTable 186 {array_a: (Variable 186 array_a [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), array_b: (Variable 186 array_b [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), eps: (Variable 186 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 186 i [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 186 result [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), size: (Variable 186 size [] In () () Default (Integer 4 []) Source Public Required .false.)}) verify1d_sum (FunctionType [(Real 8 [(() ())]) (Real 8 [(() ())]) (Real 8 [(() ())]) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 186 array_a) (Var 186 array_b) (Var 186 result) (Var 186 size)] [(= (Var 186 eps) (RealConstant 0.000000 (Real 8 [])) ()) (DoLoop () ((Var 186 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 186 size) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (RealBinOp (ArrayItem (Var 186 array_a) [(() (Var 186 i) ())] (Real 8 []) RowMajor ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Add (RealBinOp (RealConstant 5.000000 (Real 8 [])) Mul (RealBinOp (ArrayItem (Var 186 array_b) [(() (Var 186 i) ())] (Real 8 []) RowMajor ()) Pow (RealConstant 3.000000 (Real 8 [])) (Real 8 []) ()) (Real 8 []) ()) (Real 8 []) ()) Sub (ArrayItem (Var 186 result) [(() (Var 186 i) ())] (Real 8 []) RowMajor ()) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 186 eps) (Logical 4 []) ()) ())])] () Public .false. .false.), verify2d: (Function (SymbolTable 185 {array: (Variable 185 array [] InOut () () Default (Real 8 [(() ()) (() ())]) Source Public Required .false.), block: (Block (SymbolTable 197 {block: (Block (SymbolTable 198 {cos@__lpython_overloaded_0__cos: (ExternalSymbol 198 cos@__lpython_overloaded_0__cos 3 __lpython_overloaded_0__cos numpy [] __lpython_overloaded_0__cos Public)}) block [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (FunctionCall 198 cos@__lpython_overloaded_0__cos 218 cos [((ArrayItem (Var 185 array) [(() (Var 185 i) ()) (() (Var 185 j) ())] (Real 8 []) RowMajor ()))] (Real 8 []) () ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Sub (ArrayItem (Var 185 result) [(() (Var 185 i) ()) (() (Var 185 j) ())] (Real 8 []) RowMajor ()) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 185 eps) (Logical 4 []) ()) ())])}) block [(DoLoop () ((Var 185 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 185 size2) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 197 block)])]), eps: (Variable 185 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 185 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 185 j [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 185 result [] InOut () () Default (Real 8 [(() ()) (() ())]) Source Public Required .false.), size1: (Variable 185 size1 [] In () () Default (Integer 4 []) Source Public Required .false.), size2: (Variable 185 size2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) verify2d (FunctionType [(Real 8 [(() ()) (() ())]) (Real 8 [(() ()) (() ())]) (Integer 4 []) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [cos@__lpython_overloaded_0__cos cos@__lpython_overloaded_0__cos cos@__lpython_overloaded_0__cos] [(Var 185 array) (Var 185 result) (Var 185 size1) (Var 185 size2)] [(= (Var 185 eps) (RealConstant 0.000000 (Real 8 [])) ()) (DoLoop () ((Var 185 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 185 size1) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 185 block)])] () Public .false. .false.), verifynd: (Function (SymbolTable 184 {array: (Variable 184 array [] InOut () () Default (Real 8 [(() ()) (() ()) (() ())]) Source Public Required .false.), block: (Block (SymbolTable 194 {block: (Block (SymbolTable 195 {block: (Block (SymbolTable 196 {sin@__lpython_overloaded_0__sin: (ExternalSymbol 196 sin@__lpython_overloaded_0__sin 3 __lpython_overloaded_0__sin numpy [] __lpython_overloaded_0__sin Public)}) block [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (FunctionCall 196 sin@__lpython_overloaded_0__sin 218 sin [((ArrayItem (Var 184 array) [(() (Var 184 i) ()) (() (Var 184 j) ()) (() (Var 184 k) ())] (Real 8 []) RowMajor ()))] (Real 8 []) () ()) Pow (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Sub (ArrayItem (Var 184 result) [(() (Var 184 i) ()) (() (Var 184 j) ()) (() (Var 184 k) ())] (Real 8 []) RowMajor ()) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 184 eps) (Logical 4 []) ()) ())])}) block [(DoLoop () ((Var 184 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 184 size3) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 195 block)])])}) block [(DoLoop () ((Var 184 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 184 size2) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 194 block)])]), eps: (Variable 184 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 184 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 184 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 184 k [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 184 result [] InOut () () Default (Real 8 [(() ()) (() ()) (() ())]) Source Public Required .false.), size1: (Variable 184 size1 [] In () () Default (Integer 4 []) Source Public Required .false.), size2: (Variable 184 size2 [] In () () Default (Integer 4 []) Source Public Required .false.), size3: (Variable 184 size3 [] In () () Default (Integer 4 []) Source Public Required .false.)}) verifynd (FunctionType [(Real 8 [(() ()) (() ()) (() ())]) (Real 8 [(() ()) (() ()) (() ())]) (Integer 4 []) (Integer 4 []) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [sin@__lpython_overloaded_0__sin sin@__lpython_overloaded_0__sin sin@__lpython_overloaded_0__sin sin@__lpython_overloaded_0__sin] [(Var 184 array) (Var 184 result) (Var 184 size1) (Var 184 size2) (Var 184 size3)] [(= (Var 184 eps) (RealConstant 0.000000 (Real 8 [])) ()) (DoLoop () ((Var 184 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 184 size1) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 184 block)])] () Public .false. .false.)}) _global_symbols [numpy] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 216 {_lpython_main_program: (ExternalSymbol 216 _lpython_main_program 218 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 216 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) diff --git a/tests/reference/asr-expr1-8df2d66.json b/tests/reference/asr-expr1-8df2d66.json index cd81b72b51..7ca124fcae 100644 --- a/tests/reference/asr-expr1-8df2d66.json +++ b/tests/reference/asr-expr1-8df2d66.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-expr1-8df2d66.stdout", - "stdout_hash": "fadfe6329ba5deb5f9e55082b47e7f97a6a42775fdf0d2aecf8e70f2", + "stdout_hash": "55ed28248e70106a906620254f1372e1eba21d28a7d869759bc6aa37", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-expr1-8df2d66.stdout b/tests/reference/asr-expr1-8df2d66.stdout index e6f7ac085d..9e435b86b3 100644 --- a/tests/reference/asr-expr1-8df2d66.stdout +++ b/tests/reference/asr-expr1-8df2d66.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {main_program: (Program (SymbolTable 3 {}) main_program [] []), test_namedexpr: (Function (SymbolTable 2 {a: (Variable 2 a [] Local () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_namedexpr (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 x) (NamedExpr (Var 2 y) (IntegerConstant 0 (Integer 4 [])) (Integer 4 [])) ()) (If (NamedExpr (Var 2 a) (StringOrd (StringConstant "3" (Character 1 1 () [])) (Integer 4 []) (IntegerConstant 51 (Integer 4 []))) (Integer 4 [])) [(= (Var 2 x) (IntegerConstant 1 (Integer 4 [])) ())] []) (WhileLoop (NamedExpr (Var 2 a) (IntegerConstant 1 (Integer 4 [])) (Integer 4 [])) [(= (Var 2 y) (IntegerConstant 1 (Integer 4 [])) ())])] () Public .false. .false.)}) []) +(TranslationUnit (SymbolTable 1 {main_program: (Program (SymbolTable 3 {}) main_program [] []), test_namedexpr: (Function (SymbolTable 2 {a: (Variable 2 a [] Local () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_namedexpr (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 x) (NamedExpr (Var 2 y) (IntegerConstant 0 (Integer 4 [])) (Integer 4 [])) ()) (If (NamedExpr (Var 2 a) (StringOrd (StringConstant "3" (Character 1 1 () [])) (Integer 4 []) (IntegerConstant 51 (Integer 4 []))) (Integer 4 [])) [(= (Var 2 x) (IntegerConstant 1 (Integer 4 [])) ())] []) (WhileLoop () (NamedExpr (Var 2 a) (IntegerConstant 1 (Integer 4 [])) (Integer 4 [])) [(= (Var 2 y) (IntegerConstant 1 (Integer 4 [])) ())])] () Public .false. .false.)}) []) diff --git a/tests/reference/asr-expr_09-f3e89c8.json b/tests/reference/asr-expr_09-f3e89c8.json index 686402eac0..8dfa2f82d0 100644 --- a/tests/reference/asr-expr_09-f3e89c8.json +++ b/tests/reference/asr-expr_09-f3e89c8.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-expr_09-f3e89c8.stdout", - "stdout_hash": "7f0e2232c1edafa2951c0388eda503904b84c73f172029e6a10a0a8f", + "stdout_hash": "98460c8688b4adc6b0eac0cb0722d4d186bfe9b6fead721ce84a7048", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-expr_09-f3e89c8.stdout b/tests/reference/asr-expr_09-f3e89c8.stdout index c1956d9ed2..9c2ea6d31f 100644 --- a/tests/reference/asr-expr_09-f3e89c8.stdout +++ b/tests/reference/asr-expr_09-f3e89c8.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 9 {_lpython_main_program: (Function (SymbolTable 8 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_multiple_assign_1 test_issue_928 main0] [] [(SubroutineCall 9 test_multiple_assign_1 () [] ()) (SubroutineCall 9 test_issue_928 () [] ()) (SubroutineCall 9 main0 () [] ())] () Public .false. .false.), main0: (Function (SymbolTable 2 {i1: (Variable 2 i1 [] Local () () Default (Integer 4 []) Source Public Required .false.), i2: (Variable 2 i2 [] Local () () Default (Integer 4 []) Source Public Required .false.)}) main0 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 i1) (IntegerConstant 10 (Integer 4 [])) ()) (= (Var 2 i2) (IntegerConstant 4 (Integer 4 [])) ()) (= (Var 2 i1) (IntegerConstant 3 (Integer 4 [])) ()) (= (Var 2 i2) (IntegerConstant 5 (Integer 4 [])) ()) (Print () [(IntegerBinOp (IntegerUnaryMinus (Var 2 i1) (Integer 4 []) ()) BitXor (IntegerUnaryMinus (Var 2 i2) (Integer 4 []) ()) (Integer 4 []) ())] () ()) (Assert (IntegerCompare (IntegerBinOp (IntegerUnaryMinus (Var 2 i1) (Integer 4 []) ()) BitXor (IntegerUnaryMinus (Var 2 i2) (Integer 4 []) ()) (Integer 4 []) ()) Eq (IntegerConstant 6 (Integer 4 [])) (Logical 4 []) ()) ())] () Public .false. .false.), test_issue_928: (Function (SymbolTable 4 {a: (Variable 4 a [] Local () () Default (Integer 4 []) Source Public Required .false.), b: (Variable 4 b [] Local () () Default (Integer 4 []) Source Public Required .false.), c: (Variable 4 c [] Local () () Default (Tuple [(Integer 4 []) (Integer 4 [])]) Source Public Required .false.)}) test_issue_928 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (TupleConstant [(Var 4 a) (Var 4 b)] (Tuple [(Integer 4 []) (Integer 4 [])])) (TupleConstant [(IntegerConstant 2 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 [])])) ()) (= (Var 4 c) (TupleConstant [(IntegerConstant 2 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 [])])) ()) (Assert (IntegerCompare (Var 4 a) Eq (IntegerConstant 2 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (IntegerCompare (Var 4 b) Eq (IntegerConstant 1 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (LogicalBinOp (IntegerCompare (TupleItem (Var 4 c) (IntegerConstant 0 (Integer 4 [])) (Integer 4 []) ()) Eq (Var 4 a) (Logical 4 []) ()) And (IntegerCompare (TupleItem (Var 4 c) (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) Eq (Var 4 b) (Logical 4 []) ()) (Logical 4 []) ()) ())] () Public .false. .false.), test_multiple_assign_1: (Function (SymbolTable 3 {a: (Variable 3 a [] Local () () Default (Integer 4 []) Source Public Required .false.), b: (Variable 3 b [] Local () () Default (Integer 4 []) Source Public Required .false.), c: (Variable 3 c [] Local () () Default (Integer 4 []) Source Public Required .false.), d: (Variable 3 d [] Local () () Default (Real 8 []) Source Public Required .false.), e: (Variable 3 e [] Local () () Default (Real 8 []) Source Public Required .false.), g: (Variable 3 g [] Local () () Default (Integer 4 []) Source Public Required .false.), i: (Variable 3 i [] Local () () Default (List (Real 8 [])) Source Public Required .false.), j: (Variable 3 j [] Local () () Default (List (Real 8 [])) Source Public Required .false.), k: (Variable 3 k [] Local () () Default (List (Real 8 [])) Source Public Required .false.), x: (Variable 3 x [] Local () () Default (Real 8 []) Source Public Required .false.), y: (Variable 3 y [] Local () () Default (Real 8 []) Source Public Required .false.)}) test_multiple_assign_1 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 3 g) (IntegerConstant 5 (Integer 4 [])) ()) (= (Var 3 d) (RealBinOp (Cast (Var 3 g) IntegerToReal (Real 8 []) ()) Add (RealConstant 1.000000 (Real 8 [])) (Real 8 []) ()) ()) (= (Var 3 e) (RealBinOp (Cast (Var 3 g) IntegerToReal (Real 8 []) ()) Add (RealConstant 1.000000 (Real 8 [])) (Real 8 []) ()) ()) (= (Var 3 a) (IntegerConstant 10 (Integer 4 [])) ()) (= (Var 3 b) (IntegerConstant 10 (Integer 4 [])) ()) (= (Var 3 c) (IntegerConstant 10 (Integer 4 [])) ()) (Assert (IntegerCompare (Var 3 a) Eq (Var 3 b) (Logical 4 []) ()) ()) (Assert (IntegerCompare (Var 3 b) Eq (Var 3 c) (Logical 4 []) ()) ()) (Assert (IntegerCompare (Var 3 a) Eq (IntegerConstant 10 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 3 x) (RealConstant 23.000000 (Real 8 [])) ()) (= (Var 3 y) (RealConstant 23.000000 (Real 8 [])) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (Var 3 x) Sub (RealConstant 23.000000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000001 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (Var 3 y) Sub (RealConstant 23.000000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000000 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (Var 3 e) Sub (RealConstant 6.000000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000001 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (Var 3 d) Sub (RealConstant 6.000000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000000 (Real 8 [])) (Logical 4 []) ()) ()) (= (Var 3 k) (ListConstant [] (List (Real 8 []))) ()) (= (Var 3 g) (IntegerConstant 0 (Integer 4 [])) ()) (DoLoop ((Var 3 g) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 10 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(ListAppend (Var 3 k) (RealBinOp (RealBinOp (Cast (Var 3 g) IntegerToReal (Real 8 []) ()) Mul (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Add (RealConstant 5.000000 (Real 8 [])) (Real 8 []) ()))]) (= (Var 3 i) (Var 3 k) ()) (= (Var 3 j) (Var 3 k) ()) (DoLoop ((Var 3 g) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 10 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (ListItem (Var 3 i) (Var 3 g) (Real 8 []) ()) Sub (ListItem (Var 3 j) (Var 3 g) (Real 8 []) ()) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000000 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (ListItem (Var 3 i) (Var 3 g) (Real 8 []) ()) Sub (ListItem (Var 3 k) (Var 3 g) (Real 8 []) ()) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000000 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (RealBinOp (Cast (Var 3 g) IntegerToReal (Real 8 []) ()) Mul (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Add (RealConstant 5.000000 (Real 8 [])) (Real 8 []) ()) Sub (ListItem (Var 3 k) (Var 3 g) (Real 8 []) ()) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000000 (Real 8 [])) (Logical 4 []) ()) ())])] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 7 {_lpython_main_program: (ExternalSymbol 7 _lpython_main_program 9 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 7 _lpython_main_program () [] ())])}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 9 {_lpython_main_program: (Function (SymbolTable 8 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_multiple_assign_1 test_issue_928 main0] [] [(SubroutineCall 9 test_multiple_assign_1 () [] ()) (SubroutineCall 9 test_issue_928 () [] ()) (SubroutineCall 9 main0 () [] ())] () Public .false. .false.), main0: (Function (SymbolTable 2 {i1: (Variable 2 i1 [] Local () () Default (Integer 4 []) Source Public Required .false.), i2: (Variable 2 i2 [] Local () () Default (Integer 4 []) Source Public Required .false.)}) main0 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 i1) (IntegerConstant 10 (Integer 4 [])) ()) (= (Var 2 i2) (IntegerConstant 4 (Integer 4 [])) ()) (= (Var 2 i1) (IntegerConstant 3 (Integer 4 [])) ()) (= (Var 2 i2) (IntegerConstant 5 (Integer 4 [])) ()) (Print () [(IntegerBinOp (IntegerUnaryMinus (Var 2 i1) (Integer 4 []) ()) BitXor (IntegerUnaryMinus (Var 2 i2) (Integer 4 []) ()) (Integer 4 []) ())] () ()) (Assert (IntegerCompare (IntegerBinOp (IntegerUnaryMinus (Var 2 i1) (Integer 4 []) ()) BitXor (IntegerUnaryMinus (Var 2 i2) (Integer 4 []) ()) (Integer 4 []) ()) Eq (IntegerConstant 6 (Integer 4 [])) (Logical 4 []) ()) ())] () Public .false. .false.), test_issue_928: (Function (SymbolTable 4 {a: (Variable 4 a [] Local () () Default (Integer 4 []) Source Public Required .false.), b: (Variable 4 b [] Local () () Default (Integer 4 []) Source Public Required .false.), c: (Variable 4 c [] Local () () Default (Tuple [(Integer 4 []) (Integer 4 [])]) Source Public Required .false.)}) test_issue_928 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (TupleConstant [(Var 4 a) (Var 4 b)] (Tuple [(Integer 4 []) (Integer 4 [])])) (TupleConstant [(IntegerConstant 2 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 [])])) ()) (= (Var 4 c) (TupleConstant [(IntegerConstant 2 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 [])])) ()) (Assert (IntegerCompare (Var 4 a) Eq (IntegerConstant 2 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (IntegerCompare (Var 4 b) Eq (IntegerConstant 1 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (LogicalBinOp (IntegerCompare (TupleItem (Var 4 c) (IntegerConstant 0 (Integer 4 [])) (Integer 4 []) ()) Eq (Var 4 a) (Logical 4 []) ()) And (IntegerCompare (TupleItem (Var 4 c) (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) Eq (Var 4 b) (Logical 4 []) ()) (Logical 4 []) ()) ())] () Public .false. .false.), test_multiple_assign_1: (Function (SymbolTable 3 {a: (Variable 3 a [] Local () () Default (Integer 4 []) Source Public Required .false.), b: (Variable 3 b [] Local () () Default (Integer 4 []) Source Public Required .false.), c: (Variable 3 c [] Local () () Default (Integer 4 []) Source Public Required .false.), d: (Variable 3 d [] Local () () Default (Real 8 []) Source Public Required .false.), e: (Variable 3 e [] Local () () Default (Real 8 []) Source Public Required .false.), g: (Variable 3 g [] Local () () Default (Integer 4 []) Source Public Required .false.), i: (Variable 3 i [] Local () () Default (List (Real 8 [])) Source Public Required .false.), j: (Variable 3 j [] Local () () Default (List (Real 8 [])) Source Public Required .false.), k: (Variable 3 k [] Local () () Default (List (Real 8 [])) Source Public Required .false.), x: (Variable 3 x [] Local () () Default (Real 8 []) Source Public Required .false.), y: (Variable 3 y [] Local () () Default (Real 8 []) Source Public Required .false.)}) test_multiple_assign_1 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 3 g) (IntegerConstant 5 (Integer 4 [])) ()) (= (Var 3 d) (RealBinOp (Cast (Var 3 g) IntegerToReal (Real 8 []) ()) Add (RealConstant 1.000000 (Real 8 [])) (Real 8 []) ()) ()) (= (Var 3 e) (RealBinOp (Cast (Var 3 g) IntegerToReal (Real 8 []) ()) Add (RealConstant 1.000000 (Real 8 [])) (Real 8 []) ()) ()) (= (Var 3 a) (IntegerConstant 10 (Integer 4 [])) ()) (= (Var 3 b) (IntegerConstant 10 (Integer 4 [])) ()) (= (Var 3 c) (IntegerConstant 10 (Integer 4 [])) ()) (Assert (IntegerCompare (Var 3 a) Eq (Var 3 b) (Logical 4 []) ()) ()) (Assert (IntegerCompare (Var 3 b) Eq (Var 3 c) (Logical 4 []) ()) ()) (Assert (IntegerCompare (Var 3 a) Eq (IntegerConstant 10 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 3 x) (RealConstant 23.000000 (Real 8 [])) ()) (= (Var 3 y) (RealConstant 23.000000 (Real 8 [])) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (Var 3 x) Sub (RealConstant 23.000000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000001 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (Var 3 y) Sub (RealConstant 23.000000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000000 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (Var 3 e) Sub (RealConstant 6.000000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000001 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (Var 3 d) Sub (RealConstant 6.000000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000000 (Real 8 [])) (Logical 4 []) ()) ()) (= (Var 3 k) (ListConstant [] (List (Real 8 []))) ()) (= (Var 3 g) (IntegerConstant 0 (Integer 4 [])) ()) (DoLoop () ((Var 3 g) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 10 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(ListAppend (Var 3 k) (RealBinOp (RealBinOp (Cast (Var 3 g) IntegerToReal (Real 8 []) ()) Mul (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Add (RealConstant 5.000000 (Real 8 [])) (Real 8 []) ()))]) (= (Var 3 i) (Var 3 k) ()) (= (Var 3 j) (Var 3 k) ()) (DoLoop () ((Var 3 g) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 10 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (ListItem (Var 3 i) (Var 3 g) (Real 8 []) ()) Sub (ListItem (Var 3 j) (Var 3 g) (Real 8 []) ()) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000000 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (ListItem (Var 3 i) (Var 3 g) (Real 8 []) ()) Sub (ListItem (Var 3 k) (Var 3 g) (Real 8 []) ()) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000000 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (RealBinOp (Cast (Var 3 g) IntegerToReal (Real 8 []) ()) Mul (RealConstant 2.000000 (Real 8 [])) (Real 8 []) ()) Add (RealConstant 5.000000 (Real 8 [])) (Real 8 []) ()) Sub (ListItem (Var 3 k) (Var 3 g) (Real 8 []) ()) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (RealConstant 0.000000 (Real 8 [])) (Logical 4 []) ()) ())])] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 7 {_lpython_main_program: (ExternalSymbol 7 _lpython_main_program 9 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 7 _lpython_main_program () [] ())])}) []) diff --git a/tests/reference/asr-generics_array_02-22c8dc1.json b/tests/reference/asr-generics_array_02-22c8dc1.json index 72820d3914..ed289620b2 100644 --- a/tests/reference/asr-generics_array_02-22c8dc1.json +++ b/tests/reference/asr-generics_array_02-22c8dc1.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-generics_array_02-22c8dc1.stdout", - "stdout_hash": "55f9667904ac97b4cd5d3b28fb6169aaaab62d8f6fdd4e150370220d", + "stdout_hash": "8c71f0b06e4f8107b9794cdbfe327b262edc5c13f9a1345b60ec4a7c", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-generics_array_02-22c8dc1.stdout b/tests/reference/asr-generics_array_02-22c8dc1.stdout index 140bbd2f19..845089de17 100644 --- a/tests/reference/asr-generics_array_02-22c8dc1.stdout +++ b/tests/reference/asr-generics_array_02-22c8dc1.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 193 {T: (Variable 193 T [] Local () () Default (TypeParameter T []) Source Public Required .false.), __asr_generic_g_0: (Function (SymbolTable 189 {a: (Variable 189 a [n] InOut () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 189 n))]) Source Public Required .false.), b: (Variable 189 b [n] InOut () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 189 n))]) Source Public Required .false.), i: (Variable 189 i [] Local () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 189 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 189 r [n] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 189 n))]) Source Public Required .false.)}) __asr_generic_g_0 (FunctionType [(Integer 4 []) (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 189 n))]) (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 189 n))])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [add_integer] [(Var 189 n) (Var 189 a) (Var 189 b)] [(DoLoop ((Var 189 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 189 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 189 r) [(() (Var 189 i) ())] (Integer 4 []) RowMajor ()) (FunctionCall 193 add_integer () [((ArrayItem (Var 189 a) [(() (Var 189 i) ())] (Integer 4 []) RowMajor ())) ((ArrayItem (Var 189 b) [(() (Var 189 i) ())] (Integer 4 []) RowMajor ()))] (Integer 4 []) () ()) ())]) (Print () [(ArrayItem (Var 189 r) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ())] () ())] () Public .false. .false.), __asr_generic_g_1: (Function (SymbolTable 190 {a: (Variable 190 a [n] InOut () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n))]) Source Public Required .false.), b: (Variable 190 b [n] InOut () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n))]) Source Public Required .false.), i: (Variable 190 i [] Local () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 190 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 190 r [n] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n))]) Source Public Required .false.)}) __asr_generic_g_1 (FunctionType [(Integer 4 []) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n))]) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n))])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [add_float] [(Var 190 n) (Var 190 a) (Var 190 b)] [(DoLoop ((Var 190 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 190 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 190 r) [(() (Var 190 i) ())] (Real 4 []) RowMajor ()) (FunctionCall 193 add_float () [((ArrayItem (Var 190 a) [(() (Var 190 i) ())] (Real 4 []) RowMajor ())) ((ArrayItem (Var 190 b) [(() (Var 190 i) ())] (Real 4 []) RowMajor ()))] (Real 4 []) () ()) ())]) (Print () [(ArrayItem (Var 190 r) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ())] () ())] () Public .false. .false.), _lpython_main_program: (Function (SymbolTable 192 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [main] [] [(SubroutineCall 193 main () [] ())] () Public .false. .false.), add: (Function (SymbolTable 183 {_lpython_return_variable: (Variable 183 _lpython_return_variable [] ReturnVar () () Default (TypeParameter T []) Source Public Required .false.), x: (Variable 183 x [] In () () Default (TypeParameter T []) Source Public Required .false.), y: (Variable 183 y [] In () () Default (TypeParameter T []) Source Public Required .false.)}) add (FunctionType [(TypeParameter T []) (TypeParameter T [])] (TypeParameter T []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [] .true.) [] [(Var 183 x) (Var 183 y)] [] (Var 183 _lpython_return_variable) Public .false. .false.), add_float: (Function (SymbolTable 185 {_lpython_return_variable: (Variable 185 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 185 x [] In () () Default (Real 4 []) Source Public Required .false.), y: (Variable 185 y [] In () () Default (Real 4 []) Source Public Required .false.)}) add_float (FunctionType [(Real 4 []) (Real 4 [])] (Real 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 185 x) (Var 185 y)] [(= (Var 185 _lpython_return_variable) (RealBinOp (Var 185 x) Add (Var 185 y) (Real 4 []) ()) ()) (Return)] (Var 185 _lpython_return_variable) Public .false. .false.), add_integer: (Function (SymbolTable 184 {_lpython_return_variable: (Variable 184 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 184 x [] In () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 184 y [] In () () Default (Integer 4 []) Source Public Required .false.)}) add_integer (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 184 x) (Var 184 y)] [(= (Var 184 _lpython_return_variable) (IntegerBinOp (Var 184 x) Add (Var 184 y) (Integer 4 []) ()) ()) (Return)] (Var 184 _lpython_return_variable) Public .false. .false.), g: (Function (SymbolTable 186 {a: (Variable 186 a [n] InOut () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n))]) Source Public Required .false.), b: (Variable 186 b [n] InOut () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n))]) Source Public Required .false.), i: (Variable 186 i [] Local () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 186 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 186 r [n] Local () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n))]) Source Public Required .false.)}) g (FunctionType [(Integer 4 []) (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n))]) (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n))])] () Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [193 add] .false.) [add] [(Var 186 n) (Var 186 a) (Var 186 b)] [(DoLoop ((Var 186 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 186 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 186 r) [(() (Var 186 i) ())] (TypeParameter T []) RowMajor ()) (FunctionCall 193 add () [((ArrayItem (Var 186 a) [(() (Var 186 i) ())] (TypeParameter T []) RowMajor ())) ((ArrayItem (Var 186 b) [(() (Var 186 i) ())] (TypeParameter T []) RowMajor ()))] (TypeParameter T []) () ()) ())]) (Print () [(ArrayItem (Var 186 r) [(() (IntegerConstant 0 (Integer 4 [])) ())] (TypeParameter T []) RowMajor ())] () ())] () Public .false. .false.), main: (Function (SymbolTable 187 {a_float: (Variable 187 a_float [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), a_int: (Variable 187 a_int [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), b_float: (Variable 187 b_float [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), b_int: (Variable 187 b_int [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.)}) main (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [__asr_generic_g_0 __asr_generic_g_1] [] [(= (ArrayItem (Var 187 a_int) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 400 (Integer 4 [])) ()) (= (ArrayItem (Var 187 b_int) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 20 (Integer 4 [])) ()) (SubroutineCall 193 __asr_generic_g_0 () [((IntegerConstant 1 (Integer 4 []))) ((Var 187 a_int)) ((Var 187 b_int))] ()) (= (ArrayItem (Var 187 a_float) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ()) (Cast (RealConstant 400.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 400.000000 (Real 4 []))) ()) (= (ArrayItem (Var 187 b_float) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ()) (Cast (RealConstant 20.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 20.000000 (Real 4 []))) ()) (SubroutineCall 193 __asr_generic_g_1 () [((IntegerConstant 1 (Integer 4 []))) ((Var 187 a_float)) ((Var 187 b_float))] ())] () Public .false. .false.), n: (Variable 193 n [] Local () () Default (Integer 4 []) Source Public Required .false.)}) _global_symbols [] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 191 {_lpython_main_program: (ExternalSymbol 191 _lpython_main_program 193 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 191 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 193 {T: (Variable 193 T [] Local () () Default (TypeParameter T []) Source Public Required .false.), __asr_generic_g_0: (Function (SymbolTable 189 {a: (Variable 189 a [n] InOut () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 189 n))]) Source Public Required .false.), b: (Variable 189 b [n] InOut () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 189 n))]) Source Public Required .false.), i: (Variable 189 i [] Local () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 189 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 189 r [n] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 189 n))]) Source Public Required .false.)}) __asr_generic_g_0 (FunctionType [(Integer 4 []) (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 189 n))]) (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 189 n))])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [add_integer] [(Var 189 n) (Var 189 a) (Var 189 b)] [(DoLoop () ((Var 189 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 189 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 189 r) [(() (Var 189 i) ())] (Integer 4 []) RowMajor ()) (FunctionCall 193 add_integer () [((ArrayItem (Var 189 a) [(() (Var 189 i) ())] (Integer 4 []) RowMajor ())) ((ArrayItem (Var 189 b) [(() (Var 189 i) ())] (Integer 4 []) RowMajor ()))] (Integer 4 []) () ()) ())]) (Print () [(ArrayItem (Var 189 r) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ())] () ())] () Public .false. .false.), __asr_generic_g_1: (Function (SymbolTable 190 {a: (Variable 190 a [n] InOut () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n))]) Source Public Required .false.), b: (Variable 190 b [n] InOut () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n))]) Source Public Required .false.), i: (Variable 190 i [] Local () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 190 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 190 r [n] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n))]) Source Public Required .false.)}) __asr_generic_g_1 (FunctionType [(Integer 4 []) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n))]) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n))])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [add_float] [(Var 190 n) (Var 190 a) (Var 190 b)] [(DoLoop () ((Var 190 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 190 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 190 r) [(() (Var 190 i) ())] (Real 4 []) RowMajor ()) (FunctionCall 193 add_float () [((ArrayItem (Var 190 a) [(() (Var 190 i) ())] (Real 4 []) RowMajor ())) ((ArrayItem (Var 190 b) [(() (Var 190 i) ())] (Real 4 []) RowMajor ()))] (Real 4 []) () ()) ())]) (Print () [(ArrayItem (Var 190 r) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ())] () ())] () Public .false. .false.), _lpython_main_program: (Function (SymbolTable 192 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [main] [] [(SubroutineCall 193 main () [] ())] () Public .false. .false.), add: (Function (SymbolTable 183 {_lpython_return_variable: (Variable 183 _lpython_return_variable [] ReturnVar () () Default (TypeParameter T []) Source Public Required .false.), x: (Variable 183 x [] In () () Default (TypeParameter T []) Source Public Required .false.), y: (Variable 183 y [] In () () Default (TypeParameter T []) Source Public Required .false.)}) add (FunctionType [(TypeParameter T []) (TypeParameter T [])] (TypeParameter T []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [] .true.) [] [(Var 183 x) (Var 183 y)] [] (Var 183 _lpython_return_variable) Public .false. .false.), add_float: (Function (SymbolTable 185 {_lpython_return_variable: (Variable 185 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 185 x [] In () () Default (Real 4 []) Source Public Required .false.), y: (Variable 185 y [] In () () Default (Real 4 []) Source Public Required .false.)}) add_float (FunctionType [(Real 4 []) (Real 4 [])] (Real 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 185 x) (Var 185 y)] [(= (Var 185 _lpython_return_variable) (RealBinOp (Var 185 x) Add (Var 185 y) (Real 4 []) ()) ()) (Return)] (Var 185 _lpython_return_variable) Public .false. .false.), add_integer: (Function (SymbolTable 184 {_lpython_return_variable: (Variable 184 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 184 x [] In () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 184 y [] In () () Default (Integer 4 []) Source Public Required .false.)}) add_integer (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 184 x) (Var 184 y)] [(= (Var 184 _lpython_return_variable) (IntegerBinOp (Var 184 x) Add (Var 184 y) (Integer 4 []) ()) ()) (Return)] (Var 184 _lpython_return_variable) Public .false. .false.), g: (Function (SymbolTable 186 {a: (Variable 186 a [n] InOut () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n))]) Source Public Required .false.), b: (Variable 186 b [n] InOut () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n))]) Source Public Required .false.), i: (Variable 186 i [] Local () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 186 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 186 r [n] Local () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n))]) Source Public Required .false.)}) g (FunctionType [(Integer 4 []) (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n))]) (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n))])] () Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [193 add] .false.) [add] [(Var 186 n) (Var 186 a) (Var 186 b)] [(DoLoop () ((Var 186 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 186 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 186 r) [(() (Var 186 i) ())] (TypeParameter T []) RowMajor ()) (FunctionCall 193 add () [((ArrayItem (Var 186 a) [(() (Var 186 i) ())] (TypeParameter T []) RowMajor ())) ((ArrayItem (Var 186 b) [(() (Var 186 i) ())] (TypeParameter T []) RowMajor ()))] (TypeParameter T []) () ()) ())]) (Print () [(ArrayItem (Var 186 r) [(() (IntegerConstant 0 (Integer 4 [])) ())] (TypeParameter T []) RowMajor ())] () ())] () Public .false. .false.), main: (Function (SymbolTable 187 {a_float: (Variable 187 a_float [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), a_int: (Variable 187 a_int [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), b_float: (Variable 187 b_float [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), b_int: (Variable 187 b_int [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.)}) main (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [__asr_generic_g_0 __asr_generic_g_1] [] [(= (ArrayItem (Var 187 a_int) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 400 (Integer 4 [])) ()) (= (ArrayItem (Var 187 b_int) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 20 (Integer 4 [])) ()) (SubroutineCall 193 __asr_generic_g_0 () [((IntegerConstant 1 (Integer 4 []))) ((Var 187 a_int)) ((Var 187 b_int))] ()) (= (ArrayItem (Var 187 a_float) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ()) (Cast (RealConstant 400.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 400.000000 (Real 4 []))) ()) (= (ArrayItem (Var 187 b_float) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ()) (Cast (RealConstant 20.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 20.000000 (Real 4 []))) ()) (SubroutineCall 193 __asr_generic_g_1 () [((IntegerConstant 1 (Integer 4 []))) ((Var 187 a_float)) ((Var 187 b_float))] ())] () Public .false. .false.), n: (Variable 193 n [] Local () () Default (Integer 4 []) Source Public Required .false.)}) _global_symbols [] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 191 {_lpython_main_program: (ExternalSymbol 191 _lpython_main_program 193 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 191 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) diff --git a/tests/reference/asr-generics_array_03-fb3706c.json b/tests/reference/asr-generics_array_03-fb3706c.json index c492a5f0a0..ddd28fdd44 100644 --- a/tests/reference/asr-generics_array_03-fb3706c.json +++ b/tests/reference/asr-generics_array_03-fb3706c.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-generics_array_03-fb3706c.stdout", - "stdout_hash": "bf9a4faa0008beacb62c5d8d1133a057c119b9da0cfd6f7b0e377c90", + "stdout_hash": "9cf97eb5fe4722e56f9fd489b7914b05f7f36ec510f0431ff5a839b9", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-generics_array_03-fb3706c.stdout b/tests/reference/asr-generics_array_03-fb3706c.stdout index 0fb58a8e9f..44ef4c88dc 100644 --- a/tests/reference/asr-generics_array_03-fb3706c.stdout +++ b/tests/reference/asr-generics_array_03-fb3706c.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 194 {T: (Variable 194 T [] Local () () Default (TypeParameter T []) Source Public Required .false.), __asr_generic_g_0: (Function (SymbolTable 190 {_lpython_return_variable: (Variable 190 _lpython_return_variable [n m] ReturnVar () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) Source Public Required .false.), a: (Variable 190 a [n m] InOut () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) Source Public Required .false.), b: (Variable 190 b [n m] InOut () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) Source Public Required .false.), i: (Variable 190 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 190 j [] Local () () Default (Integer 4 []) Source Public Required .false.), m: (Variable 190 m [] In () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 190 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 190 r [n m] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) Source Public Required .false.)}) __asr_generic_g_0 (FunctionType [(Integer 4 []) (Integer 4 []) (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))])] (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [add_integer] [(Var 190 n) (Var 190 m) (Var 190 a) (Var 190 b)] [(DoLoop ((Var 190 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 190 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 190 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 190 m) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 190 r) [(() (Var 190 i) ()) (() (Var 190 j) ())] (Integer 4 []) RowMajor ()) (FunctionCall 194 add_integer () [((ArrayItem (Var 190 a) [(() (Var 190 i) ()) (() (Var 190 j) ())] (Integer 4 []) RowMajor ())) ((ArrayItem (Var 190 b) [(() (Var 190 i) ()) (() (Var 190 j) ())] (Integer 4 []) RowMajor ()))] (Integer 4 []) () ()) ())])]) (Print () [(ArrayItem (Var 190 r) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ())] () ())] (Var 190 _lpython_return_variable) Public .false. .false.), __asr_generic_g_1: (Function (SymbolTable 191 {_lpython_return_variable: (Variable 191 _lpython_return_variable [n m] ReturnVar () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) Source Public Required .false.), a: (Variable 191 a [n m] InOut () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) Source Public Required .false.), b: (Variable 191 b [n m] InOut () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) Source Public Required .false.), i: (Variable 191 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 191 j [] Local () () Default (Integer 4 []) Source Public Required .false.), m: (Variable 191 m [] In () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 191 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 191 r [n m] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) Source Public Required .false.)}) __asr_generic_g_1 (FunctionType [(Integer 4 []) (Integer 4 []) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))])] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [add_float] [(Var 191 n) (Var 191 m) (Var 191 a) (Var 191 b)] [(DoLoop ((Var 191 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 191 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 191 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 191 m) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 191 r) [(() (Var 191 i) ()) (() (Var 191 j) ())] (Real 4 []) RowMajor ()) (FunctionCall 194 add_float () [((ArrayItem (Var 191 a) [(() (Var 191 i) ()) (() (Var 191 j) ())] (Real 4 []) RowMajor ())) ((ArrayItem (Var 191 b) [(() (Var 191 i) ()) (() (Var 191 j) ())] (Real 4 []) RowMajor ()))] (Real 4 []) () ()) ())])]) (Print () [(ArrayItem (Var 191 r) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ())] () ())] (Var 191 _lpython_return_variable) Public .false. .false.), _lpython_main_program: (Function (SymbolTable 193 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [main] [] [(SubroutineCall 194 main () [] ())] () Public .false. .false.), add: (Function (SymbolTable 183 {_lpython_return_variable: (Variable 183 _lpython_return_variable [] ReturnVar () () Default (TypeParameter T []) Source Public Required .false.), x: (Variable 183 x [] In () () Default (TypeParameter T []) Source Public Required .false.), y: (Variable 183 y [] In () () Default (TypeParameter T []) Source Public Required .false.)}) add (FunctionType [(TypeParameter T []) (TypeParameter T [])] (TypeParameter T []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [] .true.) [] [(Var 183 x) (Var 183 y)] [] (Var 183 _lpython_return_variable) Public .false. .false.), add_float: (Function (SymbolTable 185 {_lpython_return_variable: (Variable 185 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 185 x [] In () () Default (Real 4 []) Source Public Required .false.), y: (Variable 185 y [] In () () Default (Real 4 []) Source Public Required .false.)}) add_float (FunctionType [(Real 4 []) (Real 4 [])] (Real 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 185 x) (Var 185 y)] [(= (Var 185 _lpython_return_variable) (RealBinOp (Var 185 x) Add (Var 185 y) (Real 4 []) ()) ()) (Return)] (Var 185 _lpython_return_variable) Public .false. .false.), add_integer: (Function (SymbolTable 184 {_lpython_return_variable: (Variable 184 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 184 x [] In () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 184 y [] In () () Default (Integer 4 []) Source Public Required .false.)}) add_integer (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 184 x) (Var 184 y)] [(= (Var 184 _lpython_return_variable) (IntegerBinOp (Var 184 x) Add (Var 184 y) (Integer 4 []) ()) ()) (Return)] (Var 184 _lpython_return_variable) Public .false. .false.), g: (Function (SymbolTable 186 {_lpython_return_variable: (Variable 186 _lpython_return_variable [n m] ReturnVar () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) Source Public Required .false.), a: (Variable 186 a [n m] InOut () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) Source Public Required .false.), b: (Variable 186 b [n m] InOut () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) Source Public Required .false.), i: (Variable 186 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 186 j [] Local () () Default (Integer 4 []) Source Public Required .false.), m: (Variable 186 m [] In () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 186 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 186 r [n m] Local () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) Source Public Required .false.)}) g (FunctionType [(Integer 4 []) (Integer 4 []) (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))])] (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [194 add] .false.) [add] [(Var 186 n) (Var 186 m) (Var 186 a) (Var 186 b)] [(DoLoop ((Var 186 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 186 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 186 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 186 m) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 186 r) [(() (Var 186 i) ()) (() (Var 186 j) ())] (TypeParameter T []) RowMajor ()) (FunctionCall 194 add () [((ArrayItem (Var 186 a) [(() (Var 186 i) ()) (() (Var 186 j) ())] (TypeParameter T []) RowMajor ())) ((ArrayItem (Var 186 b) [(() (Var 186 i) ()) (() (Var 186 j) ())] (TypeParameter T []) RowMajor ()))] (TypeParameter T []) () ()) ())])]) (Print () [(ArrayItem (Var 186 r) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (TypeParameter T []) RowMajor ())] () ())] (Var 186 _lpython_return_variable) Public .false. .false.), m: (Variable 194 m [] Local () () Default (Integer 4 []) Source Public Required .false.), main: (Function (SymbolTable 187 {__lcompilers_dummy: (Variable 187 __lcompilers_dummy [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), __lcompilers_dummy1: (Variable 187 __lcompilers_dummy1 [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), a_float: (Variable 187 a_float [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), a_int: (Variable 187 a_int [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), b_float: (Variable 187 b_float [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), b_int: (Variable 187 b_int [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.)}) main (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [__asr_generic_g_0 __asr_generic_g_1] [] [(= (ArrayItem (Var 187 a_int) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 400 (Integer 4 [])) ()) (= (ArrayItem (Var 187 b_int) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 20 (Integer 4 [])) ()) (= (Var 187 __lcompilers_dummy) (FunctionCall 194 __asr_generic_g_0 () [((IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 1 (Integer 4 []))) ((Var 187 a_int)) ((Var 187 b_int))] (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) () ()) ()) (= (ArrayItem (Var 187 a_float) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ()) (Cast (IntegerConstant 400 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 400.000000 (Real 4 []))) ()) (= (ArrayItem (Var 187 b_float) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ()) (Cast (IntegerConstant 20 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 20.000000 (Real 4 []))) ()) (= (Var 187 __lcompilers_dummy1) (FunctionCall 194 __asr_generic_g_1 () [((IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 1 (Integer 4 []))) ((Var 187 a_float)) ((Var 187 b_float))] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) () ()) ())] () Public .false. .false.), n: (Variable 194 n [] Local () () Default (Integer 4 []) Source Public Required .false.)}) _global_symbols [] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 192 {_lpython_main_program: (ExternalSymbol 192 _lpython_main_program 194 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 192 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 194 {T: (Variable 194 T [] Local () () Default (TypeParameter T []) Source Public Required .false.), __asr_generic_g_0: (Function (SymbolTable 190 {_lpython_return_variable: (Variable 190 _lpython_return_variable [n m] ReturnVar () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) Source Public Required .false.), a: (Variable 190 a [n m] InOut () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) Source Public Required .false.), b: (Variable 190 b [n m] InOut () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) Source Public Required .false.), i: (Variable 190 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 190 j [] Local () () Default (Integer 4 []) Source Public Required .false.), m: (Variable 190 m [] In () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 190 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 190 r [n m] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) Source Public Required .false.)}) __asr_generic_g_0 (FunctionType [(Integer 4 []) (Integer 4 []) (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))])] (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (Var 190 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 190 m))]) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [add_integer] [(Var 190 n) (Var 190 m) (Var 190 a) (Var 190 b)] [(DoLoop () ((Var 190 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 190 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 190 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 190 m) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 190 r) [(() (Var 190 i) ()) (() (Var 190 j) ())] (Integer 4 []) RowMajor ()) (FunctionCall 194 add_integer () [((ArrayItem (Var 190 a) [(() (Var 190 i) ()) (() (Var 190 j) ())] (Integer 4 []) RowMajor ())) ((ArrayItem (Var 190 b) [(() (Var 190 i) ()) (() (Var 190 j) ())] (Integer 4 []) RowMajor ()))] (Integer 4 []) () ()) ())])]) (Print () [(ArrayItem (Var 190 r) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ())] () ())] (Var 190 _lpython_return_variable) Public .false. .false.), __asr_generic_g_1: (Function (SymbolTable 191 {_lpython_return_variable: (Variable 191 _lpython_return_variable [n m] ReturnVar () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) Source Public Required .false.), a: (Variable 191 a [n m] InOut () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) Source Public Required .false.), b: (Variable 191 b [n m] InOut () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) Source Public Required .false.), i: (Variable 191 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 191 j [] Local () () Default (Integer 4 []) Source Public Required .false.), m: (Variable 191 m [] In () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 191 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 191 r [n m] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) Source Public Required .false.)}) __asr_generic_g_1 (FunctionType [(Integer 4 []) (Integer 4 []) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))])] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (Var 191 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 191 m))]) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [add_float] [(Var 191 n) (Var 191 m) (Var 191 a) (Var 191 b)] [(DoLoop () ((Var 191 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 191 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 191 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 191 m) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 191 r) [(() (Var 191 i) ()) (() (Var 191 j) ())] (Real 4 []) RowMajor ()) (FunctionCall 194 add_float () [((ArrayItem (Var 191 a) [(() (Var 191 i) ()) (() (Var 191 j) ())] (Real 4 []) RowMajor ())) ((ArrayItem (Var 191 b) [(() (Var 191 i) ()) (() (Var 191 j) ())] (Real 4 []) RowMajor ()))] (Real 4 []) () ()) ())])]) (Print () [(ArrayItem (Var 191 r) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ())] () ())] (Var 191 _lpython_return_variable) Public .false. .false.), _lpython_main_program: (Function (SymbolTable 193 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [main] [] [(SubroutineCall 194 main () [] ())] () Public .false. .false.), add: (Function (SymbolTable 183 {_lpython_return_variable: (Variable 183 _lpython_return_variable [] ReturnVar () () Default (TypeParameter T []) Source Public Required .false.), x: (Variable 183 x [] In () () Default (TypeParameter T []) Source Public Required .false.), y: (Variable 183 y [] In () () Default (TypeParameter T []) Source Public Required .false.)}) add (FunctionType [(TypeParameter T []) (TypeParameter T [])] (TypeParameter T []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [] .true.) [] [(Var 183 x) (Var 183 y)] [] (Var 183 _lpython_return_variable) Public .false. .false.), add_float: (Function (SymbolTable 185 {_lpython_return_variable: (Variable 185 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 185 x [] In () () Default (Real 4 []) Source Public Required .false.), y: (Variable 185 y [] In () () Default (Real 4 []) Source Public Required .false.)}) add_float (FunctionType [(Real 4 []) (Real 4 [])] (Real 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 185 x) (Var 185 y)] [(= (Var 185 _lpython_return_variable) (RealBinOp (Var 185 x) Add (Var 185 y) (Real 4 []) ()) ()) (Return)] (Var 185 _lpython_return_variable) Public .false. .false.), add_integer: (Function (SymbolTable 184 {_lpython_return_variable: (Variable 184 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 184 x [] In () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 184 y [] In () () Default (Integer 4 []) Source Public Required .false.)}) add_integer (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 184 x) (Var 184 y)] [(= (Var 184 _lpython_return_variable) (IntegerBinOp (Var 184 x) Add (Var 184 y) (Integer 4 []) ()) ()) (Return)] (Var 184 _lpython_return_variable) Public .false. .false.), g: (Function (SymbolTable 186 {_lpython_return_variable: (Variable 186 _lpython_return_variable [n m] ReturnVar () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) Source Public Required .false.), a: (Variable 186 a [n m] InOut () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) Source Public Required .false.), b: (Variable 186 b [n m] InOut () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) Source Public Required .false.), i: (Variable 186 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 186 j [] Local () () Default (Integer 4 []) Source Public Required .false.), m: (Variable 186 m [] In () () Default (Integer 4 []) Source Public Required .false.), n: (Variable 186 n [] In () () Default (Integer 4 []) Source Public Required .false.), r: (Variable 186 r [n m] Local () () Default (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) Source Public Required .false.)}) g (FunctionType [(Integer 4 []) (Integer 4 []) (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))])] (TypeParameter T [((IntegerConstant 0 (Integer 4 [])) (Var 186 n)) ((IntegerConstant 0 (Integer 4 [])) (Var 186 m))]) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [194 add] .false.) [add] [(Var 186 n) (Var 186 m) (Var 186 a) (Var 186 b)] [(DoLoop () ((Var 186 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 186 n) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 186 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 186 m) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 186 r) [(() (Var 186 i) ()) (() (Var 186 j) ())] (TypeParameter T []) RowMajor ()) (FunctionCall 194 add () [((ArrayItem (Var 186 a) [(() (Var 186 i) ()) (() (Var 186 j) ())] (TypeParameter T []) RowMajor ())) ((ArrayItem (Var 186 b) [(() (Var 186 i) ()) (() (Var 186 j) ())] (TypeParameter T []) RowMajor ()))] (TypeParameter T []) () ()) ())])]) (Print () [(ArrayItem (Var 186 r) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (TypeParameter T []) RowMajor ())] () ())] (Var 186 _lpython_return_variable) Public .false. .false.), m: (Variable 194 m [] Local () () Default (Integer 4 []) Source Public Required .false.), main: (Function (SymbolTable 187 {__lcompilers_dummy: (Variable 187 __lcompilers_dummy [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), __lcompilers_dummy1: (Variable 187 __lcompilers_dummy1 [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), a_float: (Variable 187 a_float [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), a_int: (Variable 187 a_int [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), b_float: (Variable 187 b_float [] Local () () Default (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), b_int: (Variable 187 b_int [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.)}) main (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [__asr_generic_g_0 __asr_generic_g_1] [] [(= (ArrayItem (Var 187 a_int) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 400 (Integer 4 [])) ()) (= (ArrayItem (Var 187 b_int) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 20 (Integer 4 [])) ()) (= (Var 187 __lcompilers_dummy) (FunctionCall 194 __asr_generic_g_0 () [((IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 1 (Integer 4 []))) ((Var 187 a_int)) ((Var 187 b_int))] (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) () ()) ()) (= (ArrayItem (Var 187 a_float) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ()) (Cast (IntegerConstant 400 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 400.000000 (Real 4 []))) ()) (= (ArrayItem (Var 187 b_float) [(() (IntegerConstant 0 (Integer 4 [])) ()) (() (IntegerConstant 0 (Integer 4 [])) ())] (Real 4 []) RowMajor ()) (Cast (IntegerConstant 20 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 20.000000 (Real 4 []))) ()) (= (Var 187 __lcompilers_dummy1) (FunctionCall 194 __asr_generic_g_1 () [((IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 1 (Integer 4 []))) ((Var 187 a_float)) ((Var 187 b_float))] (Real 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) () ()) ())] () Public .false. .false.), n: (Variable 194 n [] Local () () Default (Integer 4 []) Source Public Required .false.)}) _global_symbols [] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 192 {_lpython_main_program: (ExternalSymbol 192 _lpython_main_program 194 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 192 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) diff --git a/tests/reference/asr-generics_list_01-39c4044.json b/tests/reference/asr-generics_list_01-39c4044.json index 5d93313839..ebcd49b7aa 100644 --- a/tests/reference/asr-generics_list_01-39c4044.json +++ b/tests/reference/asr-generics_list_01-39c4044.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-generics_list_01-39c4044.stdout", - "stdout_hash": "a667c06b34ca752eafd109fadfe4ae03353fd0d5523a8d50be832d64", + "stdout_hash": "17bc818e31ecc2be8a26e7ec507c96971cf6b2b2d6a4a3b45a2713a1", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-generics_list_01-39c4044.stdout b/tests/reference/asr-generics_list_01-39c4044.stdout index 42e8952df7..45ac0e1def 100644 --- a/tests/reference/asr-generics_list_01-39c4044.stdout +++ b/tests/reference/asr-generics_list_01-39c4044.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 21 {T: (Variable 21 T [] Local () () Default (TypeParameter T []) Source Public Required .false.), __asr_generic_mean_0: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), i: (Variable 16 i [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 16 k [] Local () () Default (Integer 4 []) Source Public Required .false.), res: (Variable 16 res [] Local () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 16 x [] In () () Default (List (Integer 4 [])) Source Public Required .false.)}) __asr_generic_mean_0 (FunctionType [(List (Integer 4 []))] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [empty_integer add_integer div_integer] [(Var 16 x)] [(= (Var 16 k) (ListLen (Var 16 x) (Integer 4 []) ()) ()) (If (IntegerCompare (Var 16 k) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 16 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] []) (= (Var 16 res) (FunctionCall 21 empty_integer () [((ListItem (Var 16 x) (IntegerConstant 0 (Integer 4 [])) (Integer 4 []) ()))] (Integer 4 []) () ()) ()) (DoLoop ((Var 16 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 16 k) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 16 res) (FunctionCall 21 add_integer () [((Var 16 res)) ((ListItem (Var 16 x) (Var 16 i) (Integer 4 []) ()))] (Integer 4 []) () ()) ())]) (= (Var 16 _lpython_return_variable) (FunctionCall 21 div_integer () [((Var 16 res)) ((Var 16 k))] (Real 8 []) () ()) ()) (Return)] (Var 16 _lpython_return_variable) Public .false. .false.), __asr_generic_mean_1: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), i: (Variable 17 i [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 17 k [] Local () () Default (Integer 4 []) Source Public Required .false.), res: (Variable 17 res [] Local () () Default (Real 8 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (List (Real 8 [])) Source Public Required .false.)}) __asr_generic_mean_1 (FunctionType [(List (Real 8 []))] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [empty_float add_float div_float] [(Var 17 x)] [(= (Var 17 k) (ListLen (Var 17 x) (Integer 4 []) ()) ()) (If (IntegerCompare (Var 17 k) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 17 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] []) (= (Var 17 res) (FunctionCall 21 empty_float () [((ListItem (Var 17 x) (IntegerConstant 0 (Integer 4 [])) (Real 8 []) ()))] (Real 8 []) () ()) ()) (DoLoop ((Var 17 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 17 k) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 17 res) (FunctionCall 21 add_float () [((Var 17 res)) ((ListItem (Var 17 x) (Var 17 i) (Real 8 []) ()))] (Real 8 []) () ()) ())]) (= (Var 17 _lpython_return_variable) (FunctionCall 21 div_float () [((Var 17 res)) ((Var 17 k))] (Real 8 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __asr_generic_mean_2: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), i: (Variable 18 i [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 18 k [] Local () () Default (Integer 4 []) Source Public Required .false.), res: (Variable 18 res [] Local () () Default (Character 1 1 () []) Source Public Required .false.), x: (Variable 18 x [] In () () Default (List (Character 1 1 () [])) Source Public Required .false.)}) __asr_generic_mean_2 (FunctionType [(List (Character 1 1 () []))] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [empty_string add_string div_string] [(Var 18 x)] [(= (Var 18 k) (ListLen (Var 18 x) (Integer 4 []) ()) ()) (If (IntegerCompare (Var 18 k) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 18 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] []) (= (Var 18 res) (FunctionCall 21 empty_string () [((ListItem (Var 18 x) (IntegerConstant 0 (Integer 4 [])) (Character 1 1 () []) ()))] (Character 1 1 () []) () ()) ()) (DoLoop ((Var 18 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 18 k) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 18 res) (FunctionCall 21 add_string () [((Var 18 res)) ((ListItem (Var 18 x) (Var 18 i) (Character 1 1 () []) ()))] (Character 1 1 () []) () ()) ())]) (= (Var 18 _lpython_return_variable) (FunctionCall 21 div_string () [((Var 18 res)) ((Var 18 k))] (Real 8 []) () ()) ()) (Return)] (Var 18 _lpython_return_variable) Public .false. .false.), _lpython_main_program: (Function (SymbolTable 20 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [__asr_generic_mean_0 __asr_generic_mean_1 __asr_generic_mean_2] [] [(Print () [(FunctionCall 21 __asr_generic_mean_0 () [((ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 []))] (List (Integer 4 []))))] (Real 8 []) () ())] () ()) (Print () [(FunctionCall 21 __asr_generic_mean_1 () [((ListConstant [(RealConstant 1.000000 (Real 8 [])) (RealConstant 2.000000 (Real 8 [])) (RealConstant 3.000000 (Real 8 []))] (List (Real 8 []))))] (Real 8 []) () ())] () ()) (Print () [(FunctionCall 21 __asr_generic_mean_2 () [((ListConstant [(StringConstant "a" (Character 1 1 () [])) (StringConstant "b" (Character 1 1 () [])) (StringConstant "c" (Character 1 1 () []))] (List (Character 1 1 () []))))] (Real 8 []) () ())] () ())] () Public .false. .false.), add: (Function (SymbolTable 3 {_lpython_return_variable: (Variable 3 _lpython_return_variable [] ReturnVar () () Default (TypeParameter T []) Source Public Required .false.), x: (Variable 3 x [] In () () Default (TypeParameter T []) Source Public Required .false.), y: (Variable 3 y [] In () () Default (TypeParameter T []) Source Public Required .false.)}) add (FunctionType [(TypeParameter T []) (TypeParameter T [])] (TypeParameter T []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [] .true.) [] [(Var 3 x) (Var 3 y)] [] (Var 3 _lpython_return_variable) Public .false. .false.), add_float: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.), y: (Variable 9 y [] In () () Default (Real 8 []) Source Public Required .false.)}) add_float (FunctionType [(Real 8 []) (Real 8 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 9 x) (Var 9 y)] [(= (Var 9 _lpython_return_variable) (RealBinOp (Var 9 x) Add (Var 9 y) (Real 8 []) ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), add_integer: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 6 x [] In () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 6 y [] In () () Default (Integer 4 []) Source Public Required .false.)}) add_integer (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x) (Var 6 y)] [(= (Var 6 _lpython_return_variable) (IntegerBinOp (Var 6 x) Add (Var 6 y) (Integer 4 []) ()) ()) (Return)] (Var 6 _lpython_return_variable) Public .false. .false.), add_string: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Character 1 -2 () []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Character 1 -2 () []) Source Public Required .false.), y: (Variable 12 y [] In () () Default (Character 1 -2 () []) Source Public Required .false.)}) add_string (FunctionType [(Character 1 -2 () []) (Character 1 -2 () [])] (Character 1 -2 () []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x) (Var 12 y)] [(= (Var 12 _lpython_return_variable) (StringConcat (Var 12 x) (Var 12 y) (Character 1 -4 () []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), div: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), k: (Variable 4 k [] In () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 4 x [] In () () Default (TypeParameter T []) Source Public Required .false.)}) div (FunctionType [(TypeParameter T []) (Integer 4 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [] .true.) [] [(Var 4 x) (Var 4 k)] [] (Var 4 _lpython_return_variable) Public .false. .false.), div_float: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), k: (Variable 10 k [] In () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 10 x [] In () () Default (Real 8 []) Source Public Required .false.)}) div_float (FunctionType [(Real 8 []) (Integer 4 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x) (Var 10 k)] [(= (Var 10 _lpython_return_variable) (RealBinOp (Var 10 x) Div (Cast (Var 10 k) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) ()) (Return)] (Var 10 _lpython_return_variable) Public .false. .false.), div_integer: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), k: (Variable 7 k [] In () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Integer 4 []) Source Public Required .false.)}) div_integer (FunctionType [(Integer 4 []) (Integer 4 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 7 x) (Var 7 k)] [(= (Var 7 _lpython_return_variable) (RealBinOp (Cast (Var 7 x) IntegerToReal (Real 8 []) ()) Div (Cast (Var 7 k) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), div_string: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), k: (Variable 13 k [] In () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Character 1 -2 () []) Source Public Required .false.)}) div_string (FunctionType [(Character 1 -2 () []) (Integer 4 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x) (Var 13 k)] [(= (Var 13 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), empty_float: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) Source Public Required .false.)}) empty_float (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [(= (Var 8 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] (Var 8 _lpython_return_variable) Public .false. .false.), empty_integer: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Integer 4 []) Source Public Required .false.)}) empty_integer (FunctionType [(Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), empty_string: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Character 1 -2 () []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Character 1 -2 () []) Source Public Required .false.)}) empty_string (FunctionType [(Character 1 -2 () [])] (Character 1 -2 () []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (StringConstant "" (Character 1 0 () [])) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), mean: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), i: (Variable 14 i [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 14 k [] Local () () Default (Integer 4 []) Source Public Required .false.), res: (Variable 14 res [] Local () () Default (TypeParameter T []) Source Public Required .false.), x: (Variable 14 x [] In () () Default (List (TypeParameter T [])) Source Public Required .false.)}) mean (FunctionType [(List (TypeParameter T []))] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [21 zero 21 add 21 div] .false.) [zero add div] [(Var 14 x)] [(= (Var 14 k) (ListLen (Var 14 x) (Integer 4 []) ()) ()) (If (IntegerCompare (Var 14 k) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 14 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] []) (= (Var 14 res) (FunctionCall 21 zero () [((ListItem (Var 14 x) (IntegerConstant 0 (Integer 4 [])) (TypeParameter T []) ()))] (TypeParameter T []) () ()) ()) (DoLoop ((Var 14 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 14 k) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 14 res) (FunctionCall 21 add () [((Var 14 res)) ((ListItem (Var 14 x) (Var 14 i) (TypeParameter T []) ()))] (TypeParameter T []) () ()) ())]) (= (Var 14 _lpython_return_variable) (FunctionCall 21 div () [((Var 14 res)) ((Var 14 k))] (Real 8 []) () ()) ()) (Return)] (Var 14 _lpython_return_variable) Public .false. .false.), zero: (Function (SymbolTable 2 {_lpython_return_variable: (Variable 2 _lpython_return_variable [] ReturnVar () () Default (TypeParameter T []) Source Public Required .false.), x: (Variable 2 x [] In () () Default (TypeParameter T []) Source Public Required .false.)}) zero (FunctionType [(TypeParameter T [])] (TypeParameter T []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [] .true.) [] [(Var 2 x)] [] (Var 2 _lpython_return_variable) Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 19 {_lpython_main_program: (ExternalSymbol 19 _lpython_main_program 21 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 19 _lpython_main_program () [] ())])}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 21 {T: (Variable 21 T [] Local () () Default (TypeParameter T []) Source Public Required .false.), __asr_generic_mean_0: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), i: (Variable 16 i [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 16 k [] Local () () Default (Integer 4 []) Source Public Required .false.), res: (Variable 16 res [] Local () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 16 x [] In () () Default (List (Integer 4 [])) Source Public Required .false.)}) __asr_generic_mean_0 (FunctionType [(List (Integer 4 []))] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [empty_integer add_integer div_integer] [(Var 16 x)] [(= (Var 16 k) (ListLen (Var 16 x) (Integer 4 []) ()) ()) (If (IntegerCompare (Var 16 k) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 16 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] []) (= (Var 16 res) (FunctionCall 21 empty_integer () [((ListItem (Var 16 x) (IntegerConstant 0 (Integer 4 [])) (Integer 4 []) ()))] (Integer 4 []) () ()) ()) (DoLoop () ((Var 16 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 16 k) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 16 res) (FunctionCall 21 add_integer () [((Var 16 res)) ((ListItem (Var 16 x) (Var 16 i) (Integer 4 []) ()))] (Integer 4 []) () ()) ())]) (= (Var 16 _lpython_return_variable) (FunctionCall 21 div_integer () [((Var 16 res)) ((Var 16 k))] (Real 8 []) () ()) ()) (Return)] (Var 16 _lpython_return_variable) Public .false. .false.), __asr_generic_mean_1: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), i: (Variable 17 i [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 17 k [] Local () () Default (Integer 4 []) Source Public Required .false.), res: (Variable 17 res [] Local () () Default (Real 8 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (List (Real 8 [])) Source Public Required .false.)}) __asr_generic_mean_1 (FunctionType [(List (Real 8 []))] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [empty_float add_float div_float] [(Var 17 x)] [(= (Var 17 k) (ListLen (Var 17 x) (Integer 4 []) ()) ()) (If (IntegerCompare (Var 17 k) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 17 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] []) (= (Var 17 res) (FunctionCall 21 empty_float () [((ListItem (Var 17 x) (IntegerConstant 0 (Integer 4 [])) (Real 8 []) ()))] (Real 8 []) () ()) ()) (DoLoop () ((Var 17 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 17 k) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 17 res) (FunctionCall 21 add_float () [((Var 17 res)) ((ListItem (Var 17 x) (Var 17 i) (Real 8 []) ()))] (Real 8 []) () ()) ())]) (= (Var 17 _lpython_return_variable) (FunctionCall 21 div_float () [((Var 17 res)) ((Var 17 k))] (Real 8 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __asr_generic_mean_2: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), i: (Variable 18 i [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 18 k [] Local () () Default (Integer 4 []) Source Public Required .false.), res: (Variable 18 res [] Local () () Default (Character 1 1 () []) Source Public Required .false.), x: (Variable 18 x [] In () () Default (List (Character 1 1 () [])) Source Public Required .false.)}) __asr_generic_mean_2 (FunctionType [(List (Character 1 1 () []))] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [empty_string add_string div_string] [(Var 18 x)] [(= (Var 18 k) (ListLen (Var 18 x) (Integer 4 []) ()) ()) (If (IntegerCompare (Var 18 k) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 18 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] []) (= (Var 18 res) (FunctionCall 21 empty_string () [((ListItem (Var 18 x) (IntegerConstant 0 (Integer 4 [])) (Character 1 1 () []) ()))] (Character 1 1 () []) () ()) ()) (DoLoop () ((Var 18 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 18 k) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 18 res) (FunctionCall 21 add_string () [((Var 18 res)) ((ListItem (Var 18 x) (Var 18 i) (Character 1 1 () []) ()))] (Character 1 1 () []) () ()) ())]) (= (Var 18 _lpython_return_variable) (FunctionCall 21 div_string () [((Var 18 res)) ((Var 18 k))] (Real 8 []) () ()) ()) (Return)] (Var 18 _lpython_return_variable) Public .false. .false.), _lpython_main_program: (Function (SymbolTable 20 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [__asr_generic_mean_0 __asr_generic_mean_1 __asr_generic_mean_2] [] [(Print () [(FunctionCall 21 __asr_generic_mean_0 () [((ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 []))] (List (Integer 4 []))))] (Real 8 []) () ())] () ()) (Print () [(FunctionCall 21 __asr_generic_mean_1 () [((ListConstant [(RealConstant 1.000000 (Real 8 [])) (RealConstant 2.000000 (Real 8 [])) (RealConstant 3.000000 (Real 8 []))] (List (Real 8 []))))] (Real 8 []) () ())] () ()) (Print () [(FunctionCall 21 __asr_generic_mean_2 () [((ListConstant [(StringConstant "a" (Character 1 1 () [])) (StringConstant "b" (Character 1 1 () [])) (StringConstant "c" (Character 1 1 () []))] (List (Character 1 1 () []))))] (Real 8 []) () ())] () ())] () Public .false. .false.), add: (Function (SymbolTable 3 {_lpython_return_variable: (Variable 3 _lpython_return_variable [] ReturnVar () () Default (TypeParameter T []) Source Public Required .false.), x: (Variable 3 x [] In () () Default (TypeParameter T []) Source Public Required .false.), y: (Variable 3 y [] In () () Default (TypeParameter T []) Source Public Required .false.)}) add (FunctionType [(TypeParameter T []) (TypeParameter T [])] (TypeParameter T []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [] .true.) [] [(Var 3 x) (Var 3 y)] [] (Var 3 _lpython_return_variable) Public .false. .false.), add_float: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.), y: (Variable 9 y [] In () () Default (Real 8 []) Source Public Required .false.)}) add_float (FunctionType [(Real 8 []) (Real 8 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 9 x) (Var 9 y)] [(= (Var 9 _lpython_return_variable) (RealBinOp (Var 9 x) Add (Var 9 y) (Real 8 []) ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), add_integer: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 6 x [] In () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 6 y [] In () () Default (Integer 4 []) Source Public Required .false.)}) add_integer (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x) (Var 6 y)] [(= (Var 6 _lpython_return_variable) (IntegerBinOp (Var 6 x) Add (Var 6 y) (Integer 4 []) ()) ()) (Return)] (Var 6 _lpython_return_variable) Public .false. .false.), add_string: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Character 1 -2 () []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Character 1 -2 () []) Source Public Required .false.), y: (Variable 12 y [] In () () Default (Character 1 -2 () []) Source Public Required .false.)}) add_string (FunctionType [(Character 1 -2 () []) (Character 1 -2 () [])] (Character 1 -2 () []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x) (Var 12 y)] [(= (Var 12 _lpython_return_variable) (StringConcat (Var 12 x) (Var 12 y) (Character 1 -4 () []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), div: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), k: (Variable 4 k [] In () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 4 x [] In () () Default (TypeParameter T []) Source Public Required .false.)}) div (FunctionType [(TypeParameter T []) (Integer 4 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [] .true.) [] [(Var 4 x) (Var 4 k)] [] (Var 4 _lpython_return_variable) Public .false. .false.), div_float: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), k: (Variable 10 k [] In () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 10 x [] In () () Default (Real 8 []) Source Public Required .false.)}) div_float (FunctionType [(Real 8 []) (Integer 4 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x) (Var 10 k)] [(= (Var 10 _lpython_return_variable) (RealBinOp (Var 10 x) Div (Cast (Var 10 k) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) ()) (Return)] (Var 10 _lpython_return_variable) Public .false. .false.), div_integer: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), k: (Variable 7 k [] In () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Integer 4 []) Source Public Required .false.)}) div_integer (FunctionType [(Integer 4 []) (Integer 4 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 7 x) (Var 7 k)] [(= (Var 7 _lpython_return_variable) (RealBinOp (Cast (Var 7 x) IntegerToReal (Real 8 []) ()) Div (Cast (Var 7 k) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), div_string: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), k: (Variable 13 k [] In () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Character 1 -2 () []) Source Public Required .false.)}) div_string (FunctionType [(Character 1 -2 () []) (Integer 4 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x) (Var 13 k)] [(= (Var 13 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), empty_float: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) Source Public Required .false.)}) empty_float (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [(= (Var 8 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] (Var 8 _lpython_return_variable) Public .false. .false.), empty_integer: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Integer 4 []) Source Public Required .false.)}) empty_integer (FunctionType [(Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), empty_string: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Character 1 -2 () []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Character 1 -2 () []) Source Public Required .false.)}) empty_string (FunctionType [(Character 1 -2 () [])] (Character 1 -2 () []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (StringConstant "" (Character 1 0 () [])) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), mean: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), i: (Variable 14 i [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 14 k [] Local () () Default (Integer 4 []) Source Public Required .false.), res: (Variable 14 res [] Local () () Default (TypeParameter T []) Source Public Required .false.), x: (Variable 14 x [] In () () Default (List (TypeParameter T [])) Source Public Required .false.)}) mean (FunctionType [(List (TypeParameter T []))] (Real 8 []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [21 zero 21 add 21 div] .false.) [zero add div] [(Var 14 x)] [(= (Var 14 k) (ListLen (Var 14 x) (Integer 4 []) ()) ()) (If (IntegerCompare (Var 14 k) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 14 _lpython_return_variable) (RealConstant 0.000000 (Real 8 [])) ()) (Return)] []) (= (Var 14 res) (FunctionCall 21 zero () [((ListItem (Var 14 x) (IntegerConstant 0 (Integer 4 [])) (TypeParameter T []) ()))] (TypeParameter T []) () ()) ()) (DoLoop () ((Var 14 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 14 k) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 14 res) (FunctionCall 21 add () [((Var 14 res)) ((ListItem (Var 14 x) (Var 14 i) (TypeParameter T []) ()))] (TypeParameter T []) () ()) ())]) (= (Var 14 _lpython_return_variable) (FunctionCall 21 div () [((Var 14 res)) ((Var 14 k))] (Real 8 []) () ()) ()) (Return)] (Var 14 _lpython_return_variable) Public .false. .false.), zero: (Function (SymbolTable 2 {_lpython_return_variable: (Variable 2 _lpython_return_variable [] ReturnVar () () Default (TypeParameter T []) Source Public Required .false.), x: (Variable 2 x [] In () () Default (TypeParameter T []) Source Public Required .false.)}) zero (FunctionType [(TypeParameter T [])] (TypeParameter T []) Source Implementation () .false. .false. .false. .false. .false. [(TypeParameter T [])] [] .true.) [] [(Var 2 x)] [] (Var 2 _lpython_return_variable) Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 19 {_lpython_main_program: (ExternalSymbol 19 _lpython_main_program 21 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 19 _lpython_main_program () [] ())])}) []) diff --git a/tests/reference/asr-loop1-10d3109.json b/tests/reference/asr-loop1-10d3109.json index 6ade4d4a30..98704c87a8 100644 --- a/tests/reference/asr-loop1-10d3109.json +++ b/tests/reference/asr-loop1-10d3109.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-loop1-10d3109.stdout", - "stdout_hash": "d70ea45193d1b52f5a725f38c1c991f4878a353e4ed3d405b3bd6cad", + "stdout_hash": "9a063316258f17ab690b3c5dda147a58044c56e96a1a1b6dd3345237", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-loop1-10d3109.stdout b/tests/reference/asr-loop1-10d3109.stdout index 67dce95cd7..528d99870d 100644 --- a/tests/reference/asr-loop1-10d3109.stdout +++ b/tests/reference/asr-loop1-10d3109.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 9 {_lpython_main_program: (Function (SymbolTable 8 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [main0] [] [(SubroutineCall 9 main0 () [] ())] () Public .false. .false.), main0: (Function (SymbolTable 5 {i: (Variable 5 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 5 j [] Local () () Default (Integer 8 []) Source Public Required .false.)}) main0 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_factorial_1 test_factorial_2 test_factorial_3] [] [(= (Var 5 i) (FunctionCall 9 test_factorial_1 () [((IntegerConstant 4 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 5 i) (FunctionCall 9 test_factorial_2 () [((IntegerConstant 4 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 5 j) (FunctionCall 9 test_factorial_3 () [((IntegerConstant 5 (Integer 4 [])))] (Integer 8 []) () ()) ())] () Public .false. .false.), test_factorial_1: (Function (SymbolTable 2 {_lpython_return_variable: (Variable 2 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 2 result [] Local () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 2 x [] In () () Default (Integer 4 []) Source Public Required .false.)}) test_factorial_1 (FunctionType [(Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 2 x)] [(If (IntegerCompare (Var 2 x) Lt (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 2 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 2 result) (IntegerConstant 1 (Integer 4 [])) ()) (WhileLoop (IntegerCompare (Var 2 x) Gt (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 2 result) (IntegerBinOp (Var 2 result) Mul (Var 2 x) (Integer 4 []) ()) ()) (= (Var 2 x) (IntegerBinOp (Var 2 x) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) ())]) (= (Var 2 _lpython_return_variable) (Var 2 result) ()) (Return)] (Var 2 _lpython_return_variable) Public .false. .false.), test_factorial_2: (Function (SymbolTable 3 {_lpython_return_variable: (Variable 3 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), i: (Variable 3 i [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 3 result [] Local () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 3 x [] In () () Default (Integer 4 []) Source Public Required .false.)}) test_factorial_2 (FunctionType [(Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 3 x)] [(= (Var 3 result) (IntegerConstant 1 (Integer 4 [])) ()) (DoLoop ((Var 3 i) (IntegerConstant 1 (Integer 4 [])) (IntegerBinOp (IntegerBinOp (Var 3 x) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 3 result) (IntegerBinOp (Var 3 result) Mul (Var 3 i) (Integer 4 []) ()) ())]) (= (Var 3 _lpython_return_variable) (Var 3 result) ()) (Return)] (Var 3 _lpython_return_variable) Public .false. .false.), test_factorial_3: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), result: (Variable 4 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 4 x [] In () () Default (Integer 4 []) Source Public Required .false.)}) test_factorial_3 (FunctionType [(Integer 4 [])] (Integer 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [(= (Var 4 result) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (If (IntegerCompare (Var 4 x) Lt (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 4 _lpython_return_variable) (Var 4 result) ()) (Return)] []) (= (Var 4 result) (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) ()) (WhileLoop (IntegerCompare (Var 4 x) Gt (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 4 result) (IntegerBinOp (Var 4 result) Mul (Cast (Var 4 x) IntegerToInteger (Integer 8 []) ()) (Integer 8 []) ()) ()) (= (Var 4 x) (IntegerBinOp (Var 4 x) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) ())]) (= (Var 4 _lpython_return_variable) (Var 4 result) ()) (Return)] (Var 4 _lpython_return_variable) Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 7 {_lpython_main_program: (ExternalSymbol 7 _lpython_main_program 9 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 7 _lpython_main_program () [] ())])}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 9 {_lpython_main_program: (Function (SymbolTable 8 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [main0] [] [(SubroutineCall 9 main0 () [] ())] () Public .false. .false.), main0: (Function (SymbolTable 5 {i: (Variable 5 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 5 j [] Local () () Default (Integer 8 []) Source Public Required .false.)}) main0 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_factorial_1 test_factorial_2 test_factorial_3] [] [(= (Var 5 i) (FunctionCall 9 test_factorial_1 () [((IntegerConstant 4 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 5 i) (FunctionCall 9 test_factorial_2 () [((IntegerConstant 4 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 5 j) (FunctionCall 9 test_factorial_3 () [((IntegerConstant 5 (Integer 4 [])))] (Integer 8 []) () ()) ())] () Public .false. .false.), test_factorial_1: (Function (SymbolTable 2 {_lpython_return_variable: (Variable 2 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 2 result [] Local () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 2 x [] In () () Default (Integer 4 []) Source Public Required .false.)}) test_factorial_1 (FunctionType [(Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 2 x)] [(If (IntegerCompare (Var 2 x) Lt (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 2 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 2 result) (IntegerConstant 1 (Integer 4 [])) ()) (WhileLoop () (IntegerCompare (Var 2 x) Gt (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 2 result) (IntegerBinOp (Var 2 result) Mul (Var 2 x) (Integer 4 []) ()) ()) (= (Var 2 x) (IntegerBinOp (Var 2 x) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) ())]) (= (Var 2 _lpython_return_variable) (Var 2 result) ()) (Return)] (Var 2 _lpython_return_variable) Public .false. .false.), test_factorial_2: (Function (SymbolTable 3 {_lpython_return_variable: (Variable 3 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), i: (Variable 3 i [] Local () () Default (Integer 4 []) Source Public Required .false.), result: (Variable 3 result [] Local () () Default (Integer 4 []) Source Public Required .false.), x: (Variable 3 x [] In () () Default (Integer 4 []) Source Public Required .false.)}) test_factorial_2 (FunctionType [(Integer 4 [])] (Integer 4 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 3 x)] [(= (Var 3 result) (IntegerConstant 1 (Integer 4 [])) ()) (DoLoop () ((Var 3 i) (IntegerConstant 1 (Integer 4 [])) (IntegerBinOp (IntegerBinOp (Var 3 x) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 3 result) (IntegerBinOp (Var 3 result) Mul (Var 3 i) (Integer 4 []) ()) ())]) (= (Var 3 _lpython_return_variable) (Var 3 result) ()) (Return)] (Var 3 _lpython_return_variable) Public .false. .false.), test_factorial_3: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), result: (Variable 4 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 4 x [] In () () Default (Integer 4 []) Source Public Required .false.)}) test_factorial_3 (FunctionType [(Integer 4 [])] (Integer 8 []) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [(= (Var 4 result) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (If (IntegerCompare (Var 4 x) Lt (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 4 _lpython_return_variable) (Var 4 result) ()) (Return)] []) (= (Var 4 result) (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) ()) (WhileLoop () (IntegerCompare (Var 4 x) Gt (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 4 result) (IntegerBinOp (Var 4 result) Mul (Cast (Var 4 x) IntegerToInteger (Integer 8 []) ()) (Integer 8 []) ()) ()) (= (Var 4 x) (IntegerBinOp (Var 4 x) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) ())]) (= (Var 4 _lpython_return_variable) (Var 4 result) ()) (Return)] (Var 4 _lpython_return_variable) Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 7 {_lpython_main_program: (ExternalSymbol 7 _lpython_main_program 9 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 7 _lpython_main_program () [] ())])}) []) diff --git a/tests/reference/asr-loop2-e874469.json b/tests/reference/asr-loop2-e874469.json index 337adddde9..8cd76bc9c1 100644 --- a/tests/reference/asr-loop2-e874469.json +++ b/tests/reference/asr-loop2-e874469.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-loop2-e874469.stdout", - "stdout_hash": "a220436da35d5e12a46fa91d654fa36c43f936d0189825ec08a8f2bb", + "stdout_hash": "a638b21a77e1590ade6d5ad24df33ea74b5c14e9038cfa3ab99720f2", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-loop2-e874469.stdout b/tests/reference/asr-loop2-e874469.stdout index 64cbe06856..2dcf93a789 100644 --- a/tests/reference/asr-loop2-e874469.stdout +++ b/tests/reference/asr-loop2-e874469.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 13 {_lpython_main_program: (Function (SymbolTable 12 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_for] [] [(SubroutineCall 13 test_for () [] ())] () Public .false. .false.), exit: (ExternalSymbol 13 exit 3 exit sys [] exit Public), test_for: (Function (SymbolTable 9 {i: (Variable 9 i [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_for (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [exit] [] [(DoLoop ((Var 9 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 10 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(If (IntegerCompare (Var 9 i) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(Cycle)] []) (If (IntegerCompare (Var 9 i) Gt (IntegerConstant 5 (Integer 4 [])) (Logical 4 []) ()) [(Exit)] []) (If (IntegerCompare (Var 9 i) Eq (IntegerConstant 3 (Integer 4 [])) (Logical 4 []) ()) [(Stop ())] [])]) (SubroutineCall 13 exit () [((IntegerConstant 2 (Integer 4 [])))] ())] () Public .false. .false.)}) _global_symbols [sys] .false. .false.), main_program: (Program (SymbolTable 11 {_lpython_main_program: (ExternalSymbol 11 _lpython_main_program 13 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 11 _lpython_main_program () [] ())]), sys: (Module (SymbolTable 3 {_lpython_argv: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (List (Character 1 -2 () [])) Source Public Required .false.), argc: (Variable 5 argc [] Local () () Default (Integer 4 []) Source Public Required .false.), argv: (Variable 5 argv [] Local () () Default (List (Character 1 -2 () [])) Source Public Required .false.), i: (Variable 5 i [] Local () () Default (Integer 4 []) Source Public Required .false.)}) _lpython_argv (FunctionType [] (List (Character 1 -2 () [])) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [_lpython_get_argc _lpython_get_argv] [] [(= (Var 5 argc) (FunctionCall 3 _lpython_get_argc () [] (Integer 4 []) () ()) ()) (DoLoop ((Var 5 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 5 argc) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(ListAppend (Var 5 argv) (FunctionCall 3 _lpython_get_argv () [((Var 5 i))] (Character 1 -2 () []) () ()))]) (= (Var 5 _lpython_return_variable) (Var 5 argv) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), _lpython_get_argc: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) BindC Public Required .false.)}) _lpython_get_argc (FunctionType [] (Integer 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lpython_get_argv: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Character 1 -2 () []) BindC Public Required .false.), index: (Variable 7 index [] In () () Default (Integer 4 []) BindC Public Required .true.)}) _lpython_get_argv (FunctionType [(Integer 4 [])] (Character 1 -2 () []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 7 index)] [] (Var 7 _lpython_return_variable) Public .false. .false.), exit: (Function (SymbolTable 4 {error_code: (Variable 4 error_code [] In () () Default (Integer 4 []) Source Public Required .false.)}) exit (FunctionType [(Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 error_code)] [(Stop (Var 4 error_code))] () Public .false. .false.)}) sys [] .false. .false.)}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 13 {_lpython_main_program: (Function (SymbolTable 12 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_for] [] [(SubroutineCall 13 test_for () [] ())] () Public .false. .false.), exit: (ExternalSymbol 13 exit 3 exit sys [] exit Public), test_for: (Function (SymbolTable 9 {i: (Variable 9 i [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_for (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [exit] [] [(DoLoop () ((Var 9 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 10 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(If (IntegerCompare (Var 9 i) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(Cycle ())] []) (If (IntegerCompare (Var 9 i) Gt (IntegerConstant 5 (Integer 4 [])) (Logical 4 []) ()) [(Exit ())] []) (If (IntegerCompare (Var 9 i) Eq (IntegerConstant 3 (Integer 4 [])) (Logical 4 []) ()) [(Stop ())] [])]) (SubroutineCall 13 exit () [((IntegerConstant 2 (Integer 4 [])))] ())] () Public .false. .false.)}) _global_symbols [sys] .false. .false.), main_program: (Program (SymbolTable 11 {_lpython_main_program: (ExternalSymbol 11 _lpython_main_program 13 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 11 _lpython_main_program () [] ())]), sys: (Module (SymbolTable 3 {_lpython_argv: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (List (Character 1 -2 () [])) Source Public Required .false.), argc: (Variable 5 argc [] Local () () Default (Integer 4 []) Source Public Required .false.), argv: (Variable 5 argv [] Local () () Default (List (Character 1 -2 () [])) Source Public Required .false.), i: (Variable 5 i [] Local () () Default (Integer 4 []) Source Public Required .false.)}) _lpython_argv (FunctionType [] (List (Character 1 -2 () [])) Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [_lpython_get_argc _lpython_get_argv] [] [(= (Var 5 argc) (FunctionCall 3 _lpython_get_argc () [] (Integer 4 []) () ()) ()) (DoLoop () ((Var 5 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (Var 5 argc) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(ListAppend (Var 5 argv) (FunctionCall 3 _lpython_get_argv () [((Var 5 i))] (Character 1 -2 () []) () ()))]) (= (Var 5 _lpython_return_variable) (Var 5 argv) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), _lpython_get_argc: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) BindC Public Required .false.)}) _lpython_get_argc (FunctionType [] (Integer 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lpython_get_argv: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Character 1 -2 () []) BindC Public Required .false.), index: (Variable 7 index [] In () () Default (Integer 4 []) BindC Public Required .true.)}) _lpython_get_argv (FunctionType [(Integer 4 [])] (Character 1 -2 () []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 7 index)] [] (Var 7 _lpython_return_variable) Public .false. .false.), exit: (Function (SymbolTable 4 {error_code: (Variable 4 error_code [] In () () Default (Integer 4 []) Source Public Required .false.)}) exit (FunctionType [(Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 error_code)] [(Stop (Var 4 error_code))] () Public .false. .false.)}) sys [] .false. .false.)}) []) diff --git a/tests/reference/asr-loop3-a579196.json b/tests/reference/asr-loop3-a579196.json index ddd2223dfc..db3a68b0c9 100644 --- a/tests/reference/asr-loop3-a579196.json +++ b/tests/reference/asr-loop3-a579196.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-loop3-a579196.stdout", - "stdout_hash": "3abf6d5f47236ac1e19bd51bcf889da303bdb23f6102e4cf92f8384d", + "stdout_hash": "2a912cfabde57c7dc6a1c2ad431ee0f0fa8b45632adccf548c9fa52c", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-loop3-a579196.stdout b/tests/reference/asr-loop3-a579196.stdout index cd5d4ee425..a813394030 100644 --- a/tests/reference/asr-loop3-a579196.stdout +++ b/tests/reference/asr-loop3-a579196.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {main_program: (Program (SymbolTable 3 {}) main_program [] []), test_pass: (Function (SymbolTable 2 {a: (Variable 2 a [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_pass (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 a) (IntegerConstant 1 (Integer 4 [])) ()) (WhileLoop (IntegerCompare (Var 2 a) Gt (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [])] () Public .false. .false.)}) []) +(TranslationUnit (SymbolTable 1 {main_program: (Program (SymbolTable 3 {}) main_program [] []), test_pass: (Function (SymbolTable 2 {a: (Variable 2 a [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_pass (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 a) (IntegerConstant 1 (Integer 4 [])) ()) (WhileLoop () (IntegerCompare (Var 2 a) Gt (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [])] () Public .false. .false.)}) []) diff --git a/tests/reference/asr-structs_01-be14d49.json b/tests/reference/asr-structs_01-be14d49.json index f76b46f801..3289196316 100644 --- a/tests/reference/asr-structs_01-be14d49.json +++ b/tests/reference/asr-structs_01-be14d49.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_01-be14d49.stdout", - "stdout_hash": "b846eb1fc4c9e3ab31b13337f5be5493bf42e77a10f500895b760482", + "stdout_hash": "1c4eea2ff7db1c5fdbe747271469c6abb8d973e529eeccfee8f0d118", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_01-be14d49.stdout b/tests/reference/asr-structs_01-be14d49.stdout index 8e5a80df54..5ef0c7788e 100644 --- a/tests/reference/asr-structs_01-be14d49.stdout +++ b/tests/reference/asr-structs_01-be14d49.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 8 {A: (StructType (SymbolTable 2 {x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Real 4 []) Source Public Required .false.)}) A [] [y x] Source Public .false. () ()), _lpython_main_program: (Function (SymbolTable 7 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [g] [] [(SubroutineCall 8 g () [] ())] () Public .false. .false.), change_struct: (Function (SymbolTable 4 {a: (Variable 4 a [] In () () Default (Struct 8 A []) Source Public Required .false.)}) change_struct (FunctionType [(Struct 8 A [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 a)] [(= (StructInstanceMember (Var 4 a) 2 x (Integer 4 []) ()) (IntegerBinOp (StructInstanceMember (Var 4 a) 2 x (Integer 4 []) ()) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) ()) (= (StructInstanceMember (Var 4 a) 2 y (Real 4 []) ()) (RealBinOp (StructInstanceMember (Var 4 a) 2 y (Real 4 []) ()) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ())] () Public .false. .false.), f: (Function (SymbolTable 3 {a: (Variable 3 a [] In () () Default (Struct 8 A []) Source Public Required .false.)}) f (FunctionType [(Struct 8 A [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 3 a)] [(Print () [(StructInstanceMember (Var 3 a) 2 x (Integer 4 []) ())] () ()) (Print () [(StructInstanceMember (Var 3 a) 2 y (Real 4 []) ())] () ())] () Public .false. .false.), g: (Function (SymbolTable 5 {x: (Variable 5 x [] Local () () Default (Struct 8 A []) Source Public Required .false.)}) g (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [f f change_struct] [] [(= (Var 5 x) (StructTypeConstructor 8 A [((Cast (RealConstant 3.250000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.250000 (Real 4 [])))) ((IntegerConstant 3 (Integer 4 [])))] (Struct 8 A []) ()) ()) (SubroutineCall 8 f () [((Var 5 x))] ()) (Assert (IntegerCompare (StructInstanceMember (Var 5 x) 2 x (Integer 4 []) ()) Eq (IntegerConstant 3 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 5 x) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 3.250000 (Real 8 [])) (Logical 4 []) ()) ()) (= (StructInstanceMember (Var 5 x) 2 x (Integer 4 []) ()) (IntegerConstant 5 (Integer 4 [])) ()) (= (StructInstanceMember (Var 5 x) 2 y (Real 4 []) ()) (Cast (RealConstant 5.500000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 5.500000 (Real 4 []))) ()) (SubroutineCall 8 f () [((Var 5 x))] ()) (Assert (IntegerCompare (StructInstanceMember (Var 5 x) 2 x (Integer 4 []) ()) Eq (IntegerConstant 5 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 5 x) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 5.500000 (Real 8 [])) (Logical 4 []) ()) ()) (SubroutineCall 8 change_struct () [((Var 5 x))] ()) (Assert (IntegerCompare (StructInstanceMember (Var 5 x) 2 x (Integer 4 []) ()) Eq (IntegerConstant 6 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 5 x) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 6.500000 (Real 8 [])) (Logical 4 []) ()) ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 6 {_lpython_main_program: (ExternalSymbol 6 _lpython_main_program 8 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 6 _lpython_main_program () [] ())])}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 8 {A: (StructType (SymbolTable 2 {x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Real 4 []) Source Public Required .false.)}) A [] [y x] Source Public .false. .false. () ()), _lpython_main_program: (Function (SymbolTable 7 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [g] [] [(SubroutineCall 8 g () [] ())] () Public .false. .false.), change_struct: (Function (SymbolTable 4 {a: (Variable 4 a [] In () () Default (Struct 8 A []) Source Public Required .false.)}) change_struct (FunctionType [(Struct 8 A [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 a)] [(= (StructInstanceMember (Var 4 a) 2 x (Integer 4 []) ()) (IntegerBinOp (StructInstanceMember (Var 4 a) 2 x (Integer 4 []) ()) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) ()) (= (StructInstanceMember (Var 4 a) 2 y (Real 4 []) ()) (RealBinOp (StructInstanceMember (Var 4 a) 2 y (Real 4 []) ()) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ())] () Public .false. .false.), f: (Function (SymbolTable 3 {a: (Variable 3 a [] In () () Default (Struct 8 A []) Source Public Required .false.)}) f (FunctionType [(Struct 8 A [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 3 a)] [(Print () [(StructInstanceMember (Var 3 a) 2 x (Integer 4 []) ())] () ()) (Print () [(StructInstanceMember (Var 3 a) 2 y (Real 4 []) ())] () ())] () Public .false. .false.), g: (Function (SymbolTable 5 {x: (Variable 5 x [] Local () () Default (Struct 8 A []) Source Public Required .false.)}) g (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [f f change_struct] [] [(= (Var 5 x) (StructTypeConstructor 8 A [((Cast (RealConstant 3.250000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.250000 (Real 4 [])))) ((IntegerConstant 3 (Integer 4 [])))] (Struct 8 A []) ()) ()) (SubroutineCall 8 f () [((Var 5 x))] ()) (Assert (IntegerCompare (StructInstanceMember (Var 5 x) 2 x (Integer 4 []) ()) Eq (IntegerConstant 3 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 5 x) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 3.250000 (Real 8 [])) (Logical 4 []) ()) ()) (= (StructInstanceMember (Var 5 x) 2 x (Integer 4 []) ()) (IntegerConstant 5 (Integer 4 [])) ()) (= (StructInstanceMember (Var 5 x) 2 y (Real 4 []) ()) (Cast (RealConstant 5.500000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 5.500000 (Real 4 []))) ()) (SubroutineCall 8 f () [((Var 5 x))] ()) (Assert (IntegerCompare (StructInstanceMember (Var 5 x) 2 x (Integer 4 []) ()) Eq (IntegerConstant 5 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 5 x) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 5.500000 (Real 8 [])) (Logical 4 []) ()) ()) (SubroutineCall 8 change_struct () [((Var 5 x))] ()) (Assert (IntegerCompare (StructInstanceMember (Var 5 x) 2 x (Integer 4 []) ()) Eq (IntegerConstant 6 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 5 x) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 6.500000 (Real 8 [])) (Logical 4 []) ()) ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 6 {_lpython_main_program: (ExternalSymbol 6 _lpython_main_program 8 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 6 _lpython_main_program () [] ())])}) []) diff --git a/tests/reference/asr-structs_02-2ab459a.json b/tests/reference/asr-structs_02-2ab459a.json index 959915cf47..d39d8222b9 100644 --- a/tests/reference/asr-structs_02-2ab459a.json +++ b/tests/reference/asr-structs_02-2ab459a.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_02-2ab459a.stdout", - "stdout_hash": "307f33ebe205c2db704979606cd08768c0ca349d55166e81ab8b5b61", + "stdout_hash": "044772cf1953da8ff01ec447e8aec755529823a9a9259a2a6fd727b7", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_02-2ab459a.stdout b/tests/reference/asr-structs_02-2ab459a.stdout index 2ca979bbbd..eb803a73b9 100644 --- a/tests/reference/asr-structs_02-2ab459a.stdout +++ b/tests/reference/asr-structs_02-2ab459a.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 7 {A: (StructType (SymbolTable 2 {x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Real 4 []) Source Public Required .false.)}) A [] [x y] Source Public .false. () ()), _lpython_main_program: (Function (SymbolTable 6 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [g] [] [(SubroutineCall 7 g () [] ())] () Public .false. .false.), f: (Function (SymbolTable 3 {a: (Variable 3 a [] In () () Default (CPtr) BindC Public Required .true.), a1: (Variable 3 a1 [] Local () () Default (Struct 7 A []) Source Public Required .false.), a2: (Variable 3 a2 [] Local () () Default (Pointer (Struct 7 A [])) Source Public Required .false.), x: (Variable 3 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 3 y [] Local () () Default (Real 4 []) Source Public Required .false.)}) f (FunctionType [(CPtr)] () BindC Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 3 a)] [(= (Var 3 a1) (StructTypeConstructor 7 A [((IntegerConstant 3 (Integer 4 []))) ((Cast (RealConstant 3.250000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.250000 (Real 4 []))))] (Struct 7 A []) ()) ()) (= (Var 3 a2) (GetPointer (Var 3 a1) (Pointer (Struct 7 A [])) ()) ()) (Print () [(Var 3 a2) (GetPointer (Var 3 a1) (Pointer (Struct 7 A [])) ())] () ()) (= (Var 3 x) (StructInstanceMember (Var 3 a2) 2 x (Integer 4 []) ()) ()) (= (Var 3 y) (StructInstanceMember (Var 3 a2) 2 y (Real 4 []) ()) ()) (Assert (IntegerCompare (Var 3 x) Eq (IntegerConstant 3 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (Var 3 y) RealToReal (Real 8 []) ()) Eq (RealConstant 3.250000 (Real 8 [])) (Logical 4 []) ()) ()) (CPtrToPointer (Var 3 a) (Var 3 a2) ()) (Print () [(Var 3 a) (Var 3 a2) (GetPointer (Var 3 a1) (Pointer (Struct 7 A [])) ())] () ())] () Public .false. .false.), g: (Function (SymbolTable 4 {b: (Variable 4 b [] Local () () Default (CPtr) Source Public Required .false.)}) g (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [f] [] [(SubroutineCall 7 f () [((Var 4 b))] ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 5 {_lpython_main_program: (ExternalSymbol 5 _lpython_main_program 7 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 5 _lpython_main_program () [] ())])}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 7 {A: (StructType (SymbolTable 2 {x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Real 4 []) Source Public Required .false.)}) A [] [x y] Source Public .false. .false. () ()), _lpython_main_program: (Function (SymbolTable 6 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [g] [] [(SubroutineCall 7 g () [] ())] () Public .false. .false.), f: (Function (SymbolTable 3 {a: (Variable 3 a [] In () () Default (CPtr) BindC Public Required .true.), a1: (Variable 3 a1 [] Local () () Default (Struct 7 A []) Source Public Required .false.), a2: (Variable 3 a2 [] Local () () Default (Pointer (Struct 7 A [])) Source Public Required .false.), x: (Variable 3 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 3 y [] Local () () Default (Real 4 []) Source Public Required .false.)}) f (FunctionType [(CPtr)] () BindC Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 3 a)] [(= (Var 3 a1) (StructTypeConstructor 7 A [((IntegerConstant 3 (Integer 4 []))) ((Cast (RealConstant 3.250000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.250000 (Real 4 []))))] (Struct 7 A []) ()) ()) (= (Var 3 a2) (GetPointer (Var 3 a1) (Pointer (Struct 7 A [])) ()) ()) (Print () [(Var 3 a2) (GetPointer (Var 3 a1) (Pointer (Struct 7 A [])) ())] () ()) (= (Var 3 x) (StructInstanceMember (Var 3 a2) 2 x (Integer 4 []) ()) ()) (= (Var 3 y) (StructInstanceMember (Var 3 a2) 2 y (Real 4 []) ()) ()) (Assert (IntegerCompare (Var 3 x) Eq (IntegerConstant 3 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (Var 3 y) RealToReal (Real 8 []) ()) Eq (RealConstant 3.250000 (Real 8 [])) (Logical 4 []) ()) ()) (CPtrToPointer (Var 3 a) (Var 3 a2) ()) (Print () [(Var 3 a) (Var 3 a2) (GetPointer (Var 3 a1) (Pointer (Struct 7 A [])) ())] () ())] () Public .false. .false.), g: (Function (SymbolTable 4 {b: (Variable 4 b [] Local () () Default (CPtr) Source Public Required .false.)}) g (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [f] [] [(SubroutineCall 7 f () [((Var 4 b))] ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 5 {_lpython_main_program: (ExternalSymbol 5 _lpython_main_program 7 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 5 _lpython_main_program () [] ())])}) []) diff --git a/tests/reference/asr-structs_03-0cef911.json b/tests/reference/asr-structs_03-0cef911.json index d66b5a77a1..b19a967d54 100644 --- a/tests/reference/asr-structs_03-0cef911.json +++ b/tests/reference/asr-structs_03-0cef911.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_03-0cef911.stdout", - "stdout_hash": "18ac59879acbbcbf1cd7180817cd17e88e09946a462e7226a9d865d6", + "stdout_hash": "00411c85f7d796c9d7d77784aa9abf503b9bddcbd0d8e4bca04c5862", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_03-0cef911.stdout b/tests/reference/asr-structs_03-0cef911.stdout index 3daa663b51..8425e80ee0 100644 --- a/tests/reference/asr-structs_03-0cef911.stdout +++ b/tests/reference/asr-structs_03-0cef911.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 7 {A: (StructType (SymbolTable 2 {x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Real 4 []) Source Public Required .false.)}) A [] [x y] Source Public .false. () ()), _lpython_main_program: (Function (SymbolTable 6 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [g] [] [(SubroutineCall 7 g () [] ())] () Public .false. .false.), f: (Function (SymbolTable 3 {pa: (Variable 3 pa [] In () () Default (Pointer (Struct 7 A [])) Source Public Required .false.)}) f (FunctionType [(Pointer (Struct 7 A []))] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 3 pa)] [(Print () [(StructInstanceMember (Var 3 pa) 2 x (Integer 4 []) ())] () ()) (Print () [(StructInstanceMember (Var 3 pa) 2 y (Real 4 []) ())] () ())] () Public .false. .false.), g: (Function (SymbolTable 4 {x: (Variable 4 x [] Local () () Default (Struct 7 A []) Source Public Required .false.), xp: (Variable 4 xp [] Local () () Default (Pointer (Struct 7 A [])) Source Public Required .false.)}) g (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [f] [] [(= (Var 4 x) (StructTypeConstructor 7 A [((IntegerConstant 3 (Integer 4 []))) ((Cast (RealConstant 3.250000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.250000 (Real 4 []))))] (Struct 7 A []) ()) ()) (= (Var 4 xp) (GetPointer (Var 4 x) (Pointer (Struct 7 A [])) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 4 xp) 2 x (Integer 4 []) ()) Eq (IntegerConstant 3 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 4 xp) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 3.250000 (Real 8 [])) (Logical 4 []) ()) ()) (= (StructInstanceMember (Var 4 xp) 2 x (Integer 4 []) ()) (IntegerConstant 5 (Integer 4 [])) ()) (= (StructInstanceMember (Var 4 xp) 2 y (Real 4 []) ()) (Cast (RealConstant 5.500000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 5.500000 (Real 4 []))) ()) (SubroutineCall 7 f () [((Var 4 xp))] ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 5 {_lpython_main_program: (ExternalSymbol 5 _lpython_main_program 7 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 5 _lpython_main_program () [] ())])}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 7 {A: (StructType (SymbolTable 2 {x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Real 4 []) Source Public Required .false.)}) A [] [x y] Source Public .false. .false. () ()), _lpython_main_program: (Function (SymbolTable 6 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [g] [] [(SubroutineCall 7 g () [] ())] () Public .false. .false.), f: (Function (SymbolTable 3 {pa: (Variable 3 pa [] In () () Default (Pointer (Struct 7 A [])) Source Public Required .false.)}) f (FunctionType [(Pointer (Struct 7 A []))] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 3 pa)] [(Print () [(StructInstanceMember (Var 3 pa) 2 x (Integer 4 []) ())] () ()) (Print () [(StructInstanceMember (Var 3 pa) 2 y (Real 4 []) ())] () ())] () Public .false. .false.), g: (Function (SymbolTable 4 {x: (Variable 4 x [] Local () () Default (Struct 7 A []) Source Public Required .false.), xp: (Variable 4 xp [] Local () () Default (Pointer (Struct 7 A [])) Source Public Required .false.)}) g (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [f] [] [(= (Var 4 x) (StructTypeConstructor 7 A [((IntegerConstant 3 (Integer 4 []))) ((Cast (RealConstant 3.250000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.250000 (Real 4 []))))] (Struct 7 A []) ()) ()) (= (Var 4 xp) (GetPointer (Var 4 x) (Pointer (Struct 7 A [])) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 4 xp) 2 x (Integer 4 []) ()) Eq (IntegerConstant 3 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 4 xp) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 3.250000 (Real 8 [])) (Logical 4 []) ()) ()) (= (StructInstanceMember (Var 4 xp) 2 x (Integer 4 []) ()) (IntegerConstant 5 (Integer 4 [])) ()) (= (StructInstanceMember (Var 4 xp) 2 y (Real 4 []) ()) (Cast (RealConstant 5.500000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 5.500000 (Real 4 []))) ()) (SubroutineCall 7 f () [((Var 4 xp))] ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 5 {_lpython_main_program: (ExternalSymbol 5 _lpython_main_program 7 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 5 _lpython_main_program () [] ())])}) []) diff --git a/tests/reference/asr-structs_04-387747b.json b/tests/reference/asr-structs_04-387747b.json index eb93021063..c5bc520aa3 100644 --- a/tests/reference/asr-structs_04-387747b.json +++ b/tests/reference/asr-structs_04-387747b.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_04-387747b.stdout", - "stdout_hash": "fe42ef6eccb8a49bb420bfef442da81febf0ce1effb954772be70b3b", + "stdout_hash": "0edfaa41c273362ba4d754344f5823e334dc5017333eb7244eaceea7", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_04-387747b.stdout b/tests/reference/asr-structs_04-387747b.stdout index e8ddc795b6..3d6327caad 100644 --- a/tests/reference/asr-structs_04-387747b.stdout +++ b/tests/reference/asr-structs_04-387747b.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 8 {A: (StructType (SymbolTable 2 {x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Real 4 []) Source Public Required .false.)}) A [] [y x] Source Public .false. () ()), B: (StructType (SymbolTable 3 {a: (Variable 3 a [] Local () () Default (Struct 8 A []) Source Public Required .false.), z: (Variable 3 z [] Local () () Default (Integer 4 []) Source Public Required .false.)}) B [A] [a z] Source Public .false. () ()), _lpython_main_program: (Function (SymbolTable 7 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [g] [] [(SubroutineCall 8 g () [] ())] () Public .false. .false.), f: (Function (SymbolTable 4 {b: (Variable 4 b [] In () () Default (Struct 8 B []) Source Public Required .false.)}) f (FunctionType [(Struct 8 B [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 b)] [(Print () [(StructInstanceMember (Var 4 b) 3 z (Integer 4 []) ()) (StructInstanceMember (StructInstanceMember (Var 4 b) 3 a (Struct 8 A []) ()) 2 x (Integer 4 []) ()) (StructInstanceMember (StructInstanceMember (Var 4 b) 3 a (Struct 8 A []) ()) 2 y (Real 4 []) ())] () ()) (Assert (IntegerCompare (StructInstanceMember (Var 4 b) 3 z (Integer 4 []) ()) Eq (IntegerConstant 1 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (StructInstanceMember (Var 4 b) 3 a (Struct 8 A []) ()) 2 x (Integer 4 []) ()) Eq (IntegerConstant 2 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (StructInstanceMember (Var 4 b) 3 a (Struct 8 A []) ()) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 3.000000 (Real 8 [])) (Logical 4 []) ()) ())] () Public .false. .false.), g: (Function (SymbolTable 5 {a1: (Variable 5 a1 [] Local () () Default (Struct 8 A []) Source Public Required .false.), a2: (Variable 5 a2 [] Local () () Default (Struct 8 A []) Source Public Required .false.), b: (Variable 5 b [] Local () () Default (Struct 8 B []) Source Public Required .false.)}) g (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [f] [] [(= (Var 5 a1) (StructTypeConstructor 8 A [((Cast (RealConstant 1.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 1.000000 (Real 4 [])))) ((IntegerConstant 1 (Integer 4 [])))] (Struct 8 A []) ()) ()) (= (Var 5 a2) (StructTypeConstructor 8 A [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 [])))) ((IntegerConstant 2 (Integer 4 [])))] (Struct 8 A []) ()) ()) (= (Var 5 b) (StructTypeConstructor 8 B [((Var 5 a1)) ((IntegerConstant 1 (Integer 4 [])))] (Struct 8 B []) ()) ()) (= (StructInstanceMember (Var 5 b) 3 a (Struct 8 A []) ()) (Var 5 a2) ()) (= (StructInstanceMember (Var 5 b) 3 z (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 [])) ()) (= (StructInstanceMember (StructInstanceMember (Var 5 b) 3 a (Struct 8 A []) ()) 2 x (Integer 4 []) ()) (IntegerConstant 2 (Integer 4 [])) ()) (= (StructInstanceMember (StructInstanceMember (Var 5 b) 3 a (Struct 8 A []) ()) 2 y (Real 4 []) ()) (Cast (RealConstant 3.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.000000 (Real 4 []))) ()) (Assert (IntegerCompare (StructInstanceMember (Var 5 a1) 2 x (Integer 4 []) ()) Eq (IntegerConstant 1 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 5 a1) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 1.000000 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 5 a2) 2 x (Integer 4 []) ()) Eq (IntegerConstant 2 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 5 a2) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 2.000000 (Real 8 [])) (Logical 4 []) ()) ()) (SubroutineCall 8 f () [((Var 5 b))] ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 6 {_lpython_main_program: (ExternalSymbol 6 _lpython_main_program 8 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 6 _lpython_main_program () [] ())])}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 8 {A: (StructType (SymbolTable 2 {x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Real 4 []) Source Public Required .false.)}) A [] [y x] Source Public .false. .false. () ()), B: (StructType (SymbolTable 3 {a: (Variable 3 a [] Local () () Default (Struct 8 A []) Source Public Required .false.), z: (Variable 3 z [] Local () () Default (Integer 4 []) Source Public Required .false.)}) B [A] [a z] Source Public .false. .false. () ()), _lpython_main_program: (Function (SymbolTable 7 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [g] [] [(SubroutineCall 8 g () [] ())] () Public .false. .false.), f: (Function (SymbolTable 4 {b: (Variable 4 b [] In () () Default (Struct 8 B []) Source Public Required .false.)}) f (FunctionType [(Struct 8 B [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 b)] [(Print () [(StructInstanceMember (Var 4 b) 3 z (Integer 4 []) ()) (StructInstanceMember (StructInstanceMember (Var 4 b) 3 a (Struct 8 A []) ()) 2 x (Integer 4 []) ()) (StructInstanceMember (StructInstanceMember (Var 4 b) 3 a (Struct 8 A []) ()) 2 y (Real 4 []) ())] () ()) (Assert (IntegerCompare (StructInstanceMember (Var 4 b) 3 z (Integer 4 []) ()) Eq (IntegerConstant 1 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (StructInstanceMember (Var 4 b) 3 a (Struct 8 A []) ()) 2 x (Integer 4 []) ()) Eq (IntegerConstant 2 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (StructInstanceMember (Var 4 b) 3 a (Struct 8 A []) ()) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 3.000000 (Real 8 [])) (Logical 4 []) ()) ())] () Public .false. .false.), g: (Function (SymbolTable 5 {a1: (Variable 5 a1 [] Local () () Default (Struct 8 A []) Source Public Required .false.), a2: (Variable 5 a2 [] Local () () Default (Struct 8 A []) Source Public Required .false.), b: (Variable 5 b [] Local () () Default (Struct 8 B []) Source Public Required .false.)}) g (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [f] [] [(= (Var 5 a1) (StructTypeConstructor 8 A [((Cast (RealConstant 1.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 1.000000 (Real 4 [])))) ((IntegerConstant 1 (Integer 4 [])))] (Struct 8 A []) ()) ()) (= (Var 5 a2) (StructTypeConstructor 8 A [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 [])))) ((IntegerConstant 2 (Integer 4 [])))] (Struct 8 A []) ()) ()) (= (Var 5 b) (StructTypeConstructor 8 B [((Var 5 a1)) ((IntegerConstant 1 (Integer 4 [])))] (Struct 8 B []) ()) ()) (= (StructInstanceMember (Var 5 b) 3 a (Struct 8 A []) ()) (Var 5 a2) ()) (= (StructInstanceMember (Var 5 b) 3 z (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 [])) ()) (= (StructInstanceMember (StructInstanceMember (Var 5 b) 3 a (Struct 8 A []) ()) 2 x (Integer 4 []) ()) (IntegerConstant 2 (Integer 4 [])) ()) (= (StructInstanceMember (StructInstanceMember (Var 5 b) 3 a (Struct 8 A []) ()) 2 y (Real 4 []) ()) (Cast (RealConstant 3.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.000000 (Real 4 []))) ()) (Assert (IntegerCompare (StructInstanceMember (Var 5 a1) 2 x (Integer 4 []) ()) Eq (IntegerConstant 1 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 5 a1) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 1.000000 (Real 8 [])) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 5 a2) 2 x (Integer 4 []) ()) Eq (IntegerConstant 2 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (RealCompare (Cast (StructInstanceMember (Var 5 a2) 2 y (Real 4 []) ()) RealToReal (Real 8 []) ()) Eq (RealConstant 2.000000 (Real 8 [])) (Logical 4 []) ()) ()) (SubroutineCall 8 f () [((Var 5 b))] ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 6 {_lpython_main_program: (ExternalSymbol 6 _lpython_main_program 8 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 6 _lpython_main_program () [] ())])}) []) diff --git a/tests/reference/asr-structs_05-fa98307.json b/tests/reference/asr-structs_05-fa98307.json index 9bba4f81af..095faf8e1a 100644 --- a/tests/reference/asr-structs_05-fa98307.json +++ b/tests/reference/asr-structs_05-fa98307.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-structs_05-fa98307.stdout", - "stdout_hash": "019142ee03a6fa0f9bbe13eb6d260708e70c1bd39b293a1255bc3641", + "stdout_hash": "e18ab87182def0f315e857d5106a5257f3a90fcb9ff94969ac75d651", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_05-fa98307.stdout b/tests/reference/asr-structs_05-fa98307.stdout index ab6067479b..e31bcbe1dc 100644 --- a/tests/reference/asr-structs_05-fa98307.stdout +++ b/tests/reference/asr-structs_05-fa98307.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 9 {A: (StructType (SymbolTable 2 {a: (Variable 2 a [] Local () () Default (Real 4 []) Source Public Required .false.), b: (Variable 2 b [] Local () () Default (Integer 2 []) Source Public Required .false.), c: (Variable 2 c [] Local () () Default (Integer 1 []) Source Public Required .false.), d: (Variable 2 d [] Local () () Default (Logical 4 []) Source Public Required .false.), x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Real 8 []) Source Public Required .false.), z: (Variable 2 z [] Local () () Default (Integer 8 []) Source Public Required .false.)}) A [] [y x z a b c d] Source Public .false. () ()), _lpython_main_program: (Function (SymbolTable 8 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [g] [] [(SubroutineCall 9 g () [] ())] () Public .false. .false.), g: (Function (SymbolTable 6 {y: (Variable 6 y [] Local () () Default (Struct 9 A [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])))]) Source Public Required .false.)}) g (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [verify update_1 update_2 verify] [] [(= (ArrayItem (Var 6 y) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) (StructTypeConstructor 9 A [((RealConstant 1.100000 (Real 8 []))) ((IntegerConstant 1 (Integer 4 []))) ((Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 [])))) ((Cast (RealConstant 1.100000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 1.100000 (Real 4 [])))) ((Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 2 []) (IntegerConstant 1 (Integer 2 [])))) ((Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 1 []) (IntegerConstant 1 (Integer 1 [])))) ((LogicalConstant .true. (Logical 4 [])))] (Struct 9 A []) ()) ()) (= (ArrayItem (Var 6 y) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) (StructTypeConstructor 9 A [((RealConstant 2.200000 (Real 8 []))) ((IntegerConstant 2 (Integer 4 []))) ((Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 2 (Integer 8 [])))) ((Cast (RealConstant 2.200000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.200000 (Real 4 [])))) ((Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 2 []) (IntegerConstant 2 (Integer 2 [])))) ((Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 1 []) (IntegerConstant 2 (Integer 1 [])))) ((LogicalConstant .true. (Logical 4 [])))] (Struct 9 A []) ()) ()) (SubroutineCall 9 verify () [((Var 6 y)) ((IntegerConstant 1 (Integer 4 []))) ((RealConstant 1.100000 (Real 8 []))) ((IntegerConstant 2 (Integer 4 []))) ((RealConstant 2.200000 (Real 8 [])))] ()) (SubroutineCall 9 update_1 () [((ArrayItem (Var 6 y) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()))] ()) (SubroutineCall 9 update_2 () [((Var 6 y))] ()) (SubroutineCall 9 verify () [((Var 6 y)) ((IntegerConstant 2 (Integer 4 []))) ((RealConstant 1.200000 (Real 8 []))) ((IntegerConstant 3 (Integer 4 []))) ((RealConstant 2.300000 (Real 8 [])))] ())] () Public .false. .false.), update_1: (Function (SymbolTable 4 {s: (Variable 4 s [] In () () Default (Struct 9 A []) Source Public Required .false.)}) update_1 (FunctionType [(Struct 9 A [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 s)] [(= (StructInstanceMember (Var 4 s) 2 x (Integer 4 []) ()) (IntegerConstant 2 (Integer 4 [])) ()) (= (StructInstanceMember (Var 4 s) 2 y (Real 8 []) ()) (RealConstant 1.200000 (Real 8 [])) ()) (= (StructInstanceMember (Var 4 s) 2 z (Integer 8 []) ()) (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 2 (Integer 8 []))) ()) (= (StructInstanceMember (Var 4 s) 2 a (Real 4 []) ()) (Cast (RealConstant 1.200000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 1.200000 (Real 4 []))) ()) (= (StructInstanceMember (Var 4 s) 2 b (Integer 2 []) ()) (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 2 []) (IntegerConstant 2 (Integer 2 []))) ()) (= (StructInstanceMember (Var 4 s) 2 c (Integer 1 []) ()) (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 1 []) (IntegerConstant 2 (Integer 1 []))) ())] () Public .false. .false.), update_2: (Function (SymbolTable 5 {s: (Variable 5 s [] InOut () () Default (Struct 9 A [(() ())]) Source Public Required .false.)}) update_2 (FunctionType [(Struct 9 A [(() ())])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 5 s)] [(= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 x (Integer 4 []) ()) (IntegerConstant 3 (Integer 4 [])) ()) (= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 y (Real 8 []) ()) (RealConstant 2.300000 (Real 8 [])) ()) (= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 z (Integer 8 []) ()) (Cast (IntegerConstant 3 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 3 (Integer 8 []))) ()) (= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 a (Real 4 []) ()) (Cast (RealConstant 2.300000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.300000 (Real 4 []))) ()) (= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 b (Integer 2 []) ()) (Cast (IntegerConstant 3 (Integer 4 [])) IntegerToInteger (Integer 2 []) (IntegerConstant 3 (Integer 2 []))) ()) (= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 c (Integer 1 []) ()) (Cast (IntegerConstant 3 (Integer 4 [])) IntegerToInteger (Integer 1 []) (IntegerConstant 3 (Integer 1 []))) ())] () Public .false. .false.), verify: (Function (SymbolTable 3 {eps: (Variable 3 eps [] Local () () Default (Real 8 []) Source Public Required .false.), s: (Variable 3 s [] InOut () () Default (Struct 9 A [(() ())]) Source Public Required .false.), s0: (Variable 3 s0 [] Local () () Default (Struct 9 A []) Source Public Required .false.), s1: (Variable 3 s1 [] Local () () Default (Struct 9 A []) Source Public Required .false.), x1: (Variable 3 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 3 x2 [] In () () Default (Integer 4 []) Source Public Required .false.), y1: (Variable 3 y1 [] In () () Default (Real 8 []) Source Public Required .false.), y2: (Variable 3 y2 [] In () () Default (Real 8 []) Source Public Required .false.)}) verify (FunctionType [(Struct 9 A [(() ())]) (Integer 4 []) (Real 8 []) (Integer 4 []) (Real 8 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 3 s) (Var 3 x1) (Var 3 y1) (Var 3 x2) (Var 3 y2)] [(= (Var 3 eps) (RealConstant 0.000000 (Real 8 [])) ()) (= (Var 3 s0) (ArrayItem (Var 3 s) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) ()) (Print () [(StructInstanceMember (Var 3 s0) 2 x (Integer 4 []) ()) (StructInstanceMember (Var 3 s0) 2 y (Real 8 []) ()) (StructInstanceMember (Var 3 s0) 2 z (Integer 8 []) ()) (StructInstanceMember (Var 3 s0) 2 a (Real 4 []) ()) (StructInstanceMember (Var 3 s0) 2 b (Integer 2 []) ()) (StructInstanceMember (Var 3 s0) 2 c (Integer 1 []) ()) (StructInstanceMember (Var 3 s0) 2 d (Logical 4 []) ())] () ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s0) 2 x (Integer 4 []) ()) Eq (Var 3 x1) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (StructInstanceMember (Var 3 s0) 2 y (Real 8 []) ()) Sub (Var 3 y1) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (Var 3 eps) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s0) 2 z (Integer 8 []) ()) Eq (Cast (Var 3 x1) IntegerToInteger (Integer 8 []) ()) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (StructInstanceMember (Var 3 s0) 2 a (Real 4 []) ()) Sub (Cast (Var 3 y1) RealToReal (Real 4 []) ()) (Real 4 []) ())] 0 (Real 4 []) ()) Lt (Cast (RealConstant 0.000001 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 0.000001 (Real 4 []))) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s0) 2 b (Integer 2 []) ()) Eq (Cast (Var 3 x1) IntegerToInteger (Integer 2 []) ()) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s0) 2 c (Integer 1 []) ()) Eq (Cast (Var 3 x1) IntegerToInteger (Integer 1 []) ()) (Logical 4 []) ()) ()) (Assert (StructInstanceMember (Var 3 s0) 2 d (Logical 4 []) ()) ()) (= (Var 3 s1) (ArrayItem (Var 3 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) ()) (Print () [(StructInstanceMember (Var 3 s1) 2 x (Integer 4 []) ()) (StructInstanceMember (Var 3 s1) 2 y (Real 8 []) ()) (StructInstanceMember (Var 3 s1) 2 z (Integer 8 []) ()) (StructInstanceMember (Var 3 s1) 2 a (Real 4 []) ()) (StructInstanceMember (Var 3 s1) 2 b (Integer 2 []) ()) (StructInstanceMember (Var 3 s1) 2 c (Integer 1 []) ()) (StructInstanceMember (Var 3 s1) 2 d (Logical 4 []) ())] () ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s1) 2 x (Integer 4 []) ()) Eq (Var 3 x2) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (StructInstanceMember (Var 3 s1) 2 y (Real 8 []) ()) Sub (Var 3 y2) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (Var 3 eps) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s1) 2 z (Integer 8 []) ()) Eq (Cast (Var 3 x2) IntegerToInteger (Integer 8 []) ()) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (StructInstanceMember (Var 3 s1) 2 a (Real 4 []) ()) Sub (Cast (Var 3 y2) RealToReal (Real 4 []) ()) (Real 4 []) ())] 0 (Real 4 []) ()) Lt (Cast (RealConstant 0.000001 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 0.000001 (Real 4 []))) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s1) 2 b (Integer 2 []) ()) Eq (Cast (Var 3 x2) IntegerToInteger (Integer 2 []) ()) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s1) 2 c (Integer 1 []) ()) Eq (Cast (Var 3 x2) IntegerToInteger (Integer 1 []) ()) (Logical 4 []) ()) ()) (Assert (StructInstanceMember (Var 3 s1) 2 d (Logical 4 []) ()) ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 7 {_lpython_main_program: (ExternalSymbol 7 _lpython_main_program 9 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 7 _lpython_main_program () [] ())])}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 9 {A: (StructType (SymbolTable 2 {a: (Variable 2 a [] Local () () Default (Real 4 []) Source Public Required .false.), b: (Variable 2 b [] Local () () Default (Integer 2 []) Source Public Required .false.), c: (Variable 2 c [] Local () () Default (Integer 1 []) Source Public Required .false.), d: (Variable 2 d [] Local () () Default (Logical 4 []) Source Public Required .false.), x: (Variable 2 x [] Local () () Default (Integer 4 []) Source Public Required .false.), y: (Variable 2 y [] Local () () Default (Real 8 []) Source Public Required .false.), z: (Variable 2 z [] Local () () Default (Integer 8 []) Source Public Required .false.)}) A [] [y x z a b c d] Source Public .false. .false. () ()), _lpython_main_program: (Function (SymbolTable 8 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [g] [] [(SubroutineCall 9 g () [] ())] () Public .false. .false.), g: (Function (SymbolTable 6 {y: (Variable 6 y [] Local () () Default (Struct 9 A [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])))]) Source Public Required .false.)}) g (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [verify update_1 update_2 verify] [] [(= (ArrayItem (Var 6 y) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) (StructTypeConstructor 9 A [((RealConstant 1.100000 (Real 8 []))) ((IntegerConstant 1 (Integer 4 []))) ((Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 [])))) ((Cast (RealConstant 1.100000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 1.100000 (Real 4 [])))) ((Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 2 []) (IntegerConstant 1 (Integer 2 [])))) ((Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 1 []) (IntegerConstant 1 (Integer 1 [])))) ((LogicalConstant .true. (Logical 4 [])))] (Struct 9 A []) ()) ()) (= (ArrayItem (Var 6 y) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) (StructTypeConstructor 9 A [((RealConstant 2.200000 (Real 8 []))) ((IntegerConstant 2 (Integer 4 []))) ((Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 2 (Integer 8 [])))) ((Cast (RealConstant 2.200000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.200000 (Real 4 [])))) ((Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 2 []) (IntegerConstant 2 (Integer 2 [])))) ((Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 1 []) (IntegerConstant 2 (Integer 1 [])))) ((LogicalConstant .true. (Logical 4 [])))] (Struct 9 A []) ()) ()) (SubroutineCall 9 verify () [((Var 6 y)) ((IntegerConstant 1 (Integer 4 []))) ((RealConstant 1.100000 (Real 8 []))) ((IntegerConstant 2 (Integer 4 []))) ((RealConstant 2.200000 (Real 8 [])))] ()) (SubroutineCall 9 update_1 () [((ArrayItem (Var 6 y) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()))] ()) (SubroutineCall 9 update_2 () [((Var 6 y))] ()) (SubroutineCall 9 verify () [((Var 6 y)) ((IntegerConstant 2 (Integer 4 []))) ((RealConstant 1.200000 (Real 8 []))) ((IntegerConstant 3 (Integer 4 []))) ((RealConstant 2.300000 (Real 8 [])))] ())] () Public .false. .false.), update_1: (Function (SymbolTable 4 {s: (Variable 4 s [] In () () Default (Struct 9 A []) Source Public Required .false.)}) update_1 (FunctionType [(Struct 9 A [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 s)] [(= (StructInstanceMember (Var 4 s) 2 x (Integer 4 []) ()) (IntegerConstant 2 (Integer 4 [])) ()) (= (StructInstanceMember (Var 4 s) 2 y (Real 8 []) ()) (RealConstant 1.200000 (Real 8 [])) ()) (= (StructInstanceMember (Var 4 s) 2 z (Integer 8 []) ()) (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 2 (Integer 8 []))) ()) (= (StructInstanceMember (Var 4 s) 2 a (Real 4 []) ()) (Cast (RealConstant 1.200000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 1.200000 (Real 4 []))) ()) (= (StructInstanceMember (Var 4 s) 2 b (Integer 2 []) ()) (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 2 []) (IntegerConstant 2 (Integer 2 []))) ()) (= (StructInstanceMember (Var 4 s) 2 c (Integer 1 []) ()) (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToInteger (Integer 1 []) (IntegerConstant 2 (Integer 1 []))) ())] () Public .false. .false.), update_2: (Function (SymbolTable 5 {s: (Variable 5 s [] InOut () () Default (Struct 9 A [(() ())]) Source Public Required .false.)}) update_2 (FunctionType [(Struct 9 A [(() ())])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 5 s)] [(= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 x (Integer 4 []) ()) (IntegerConstant 3 (Integer 4 [])) ()) (= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 y (Real 8 []) ()) (RealConstant 2.300000 (Real 8 [])) ()) (= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 z (Integer 8 []) ()) (Cast (IntegerConstant 3 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 3 (Integer 8 []))) ()) (= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 a (Real 4 []) ()) (Cast (RealConstant 2.300000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.300000 (Real 4 []))) ()) (= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 b (Integer 2 []) ()) (Cast (IntegerConstant 3 (Integer 4 [])) IntegerToInteger (Integer 2 []) (IntegerConstant 3 (Integer 2 []))) ()) (= (StructInstanceMember (ArrayItem (Var 5 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) 2 c (Integer 1 []) ()) (Cast (IntegerConstant 3 (Integer 4 [])) IntegerToInteger (Integer 1 []) (IntegerConstant 3 (Integer 1 []))) ())] () Public .false. .false.), verify: (Function (SymbolTable 3 {eps: (Variable 3 eps [] Local () () Default (Real 8 []) Source Public Required .false.), s: (Variable 3 s [] InOut () () Default (Struct 9 A [(() ())]) Source Public Required .false.), s0: (Variable 3 s0 [] Local () () Default (Struct 9 A []) Source Public Required .false.), s1: (Variable 3 s1 [] Local () () Default (Struct 9 A []) Source Public Required .false.), x1: (Variable 3 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 3 x2 [] In () () Default (Integer 4 []) Source Public Required .false.), y1: (Variable 3 y1 [] In () () Default (Real 8 []) Source Public Required .false.), y2: (Variable 3 y2 [] In () () Default (Real 8 []) Source Public Required .false.)}) verify (FunctionType [(Struct 9 A [(() ())]) (Integer 4 []) (Real 8 []) (Integer 4 []) (Real 8 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 3 s) (Var 3 x1) (Var 3 y1) (Var 3 x2) (Var 3 y2)] [(= (Var 3 eps) (RealConstant 0.000000 (Real 8 [])) ()) (= (Var 3 s0) (ArrayItem (Var 3 s) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) ()) (Print () [(StructInstanceMember (Var 3 s0) 2 x (Integer 4 []) ()) (StructInstanceMember (Var 3 s0) 2 y (Real 8 []) ()) (StructInstanceMember (Var 3 s0) 2 z (Integer 8 []) ()) (StructInstanceMember (Var 3 s0) 2 a (Real 4 []) ()) (StructInstanceMember (Var 3 s0) 2 b (Integer 2 []) ()) (StructInstanceMember (Var 3 s0) 2 c (Integer 1 []) ()) (StructInstanceMember (Var 3 s0) 2 d (Logical 4 []) ())] () ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s0) 2 x (Integer 4 []) ()) Eq (Var 3 x1) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (StructInstanceMember (Var 3 s0) 2 y (Real 8 []) ()) Sub (Var 3 y1) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (Var 3 eps) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s0) 2 z (Integer 8 []) ()) Eq (Cast (Var 3 x1) IntegerToInteger (Integer 8 []) ()) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (StructInstanceMember (Var 3 s0) 2 a (Real 4 []) ()) Sub (Cast (Var 3 y1) RealToReal (Real 4 []) ()) (Real 4 []) ())] 0 (Real 4 []) ()) Lt (Cast (RealConstant 0.000001 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 0.000001 (Real 4 []))) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s0) 2 b (Integer 2 []) ()) Eq (Cast (Var 3 x1) IntegerToInteger (Integer 2 []) ()) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s0) 2 c (Integer 1 []) ()) Eq (Cast (Var 3 x1) IntegerToInteger (Integer 1 []) ()) (Logical 4 []) ()) ()) (Assert (StructInstanceMember (Var 3 s0) 2 d (Logical 4 []) ()) ()) (= (Var 3 s1) (ArrayItem (Var 3 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct 9 A []) RowMajor ()) ()) (Print () [(StructInstanceMember (Var 3 s1) 2 x (Integer 4 []) ()) (StructInstanceMember (Var 3 s1) 2 y (Real 8 []) ()) (StructInstanceMember (Var 3 s1) 2 z (Integer 8 []) ()) (StructInstanceMember (Var 3 s1) 2 a (Real 4 []) ()) (StructInstanceMember (Var 3 s1) 2 b (Integer 2 []) ()) (StructInstanceMember (Var 3 s1) 2 c (Integer 1 []) ()) (StructInstanceMember (Var 3 s1) 2 d (Logical 4 []) ())] () ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s1) 2 x (Integer 4 []) ()) Eq (Var 3 x2) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (StructInstanceMember (Var 3 s1) 2 y (Real 8 []) ()) Sub (Var 3 y2) (Real 8 []) ())] 0 (Real 8 []) ()) Lt (Var 3 eps) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s1) 2 z (Integer 8 []) ()) Eq (Cast (Var 3 x2) IntegerToInteger (Integer 8 []) ()) (Logical 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (StructInstanceMember (Var 3 s1) 2 a (Real 4 []) ()) Sub (Cast (Var 3 y2) RealToReal (Real 4 []) ()) (Real 4 []) ())] 0 (Real 4 []) ()) Lt (Cast (RealConstant 0.000001 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 0.000001 (Real 4 []))) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s1) 2 b (Integer 2 []) ()) Eq (Cast (Var 3 x2) IntegerToInteger (Integer 2 []) ()) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StructInstanceMember (Var 3 s1) 2 c (Integer 1 []) ()) Eq (Cast (Var 3 x2) IntegerToInteger (Integer 1 []) ()) (Logical 4 []) ()) ()) (Assert (StructInstanceMember (Var 3 s1) 2 d (Logical 4 []) ()) ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 7 {_lpython_main_program: (ExternalSymbol 7 _lpython_main_program 9 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 7 _lpython_main_program () [] ())])}) []) diff --git a/tests/reference/asr-test_builtin_len-55b0dec.json b/tests/reference/asr-test_builtin_len-55b0dec.json index cab151deaa..315fe55621 100644 --- a/tests/reference/asr-test_builtin_len-55b0dec.json +++ b/tests/reference/asr-test_builtin_len-55b0dec.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-test_builtin_len-55b0dec.stdout", - "stdout_hash": "98523e1f01b6310e41d5ac89269386c94e9fe494d13d30c0a10806a3", + "stdout_hash": "e0721b973ad1fade9669b541f83a31bd5f594d0e81d3377fe0666c48", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-test_builtin_len-55b0dec.stdout b/tests/reference/asr-test_builtin_len-55b0dec.stdout index b27048d95d..341a88bb03 100644 --- a/tests/reference/asr-test_builtin_len-55b0dec.stdout +++ b/tests/reference/asr-test_builtin_len-55b0dec.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 7 {_lpython_main_program: (Function (SymbolTable 6 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_len] [] [(SubroutineCall 7 test_len () [] ())] () Public .false. .false.), test_len: (Function (SymbolTable 2 {i: (Variable 2 i [] Local () () Default (Integer 4 []) Source Public Required .false.), l: (Variable 2 l [] Local () () Default (List (Integer 4 [])) Source Public Required .false.), l2: (Variable 2 l2 [] Local () () Default (List (Real 8 [])) Source Public Required .false.), l3: (Variable 2 l3 [] Local () () Default (List (Integer 4 [])) Source Public Required .false.), list_len: (Variable 2 list_len [] Local () () Default (Integer 4 []) Source Public Required .false.), s: (Variable 2 s [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), t: (Variable 2 t [] Local () () Default (Tuple [(Integer 4 []) (Integer 4 []) (Character 1 -2 () [])]) Source Public Required .false.), t2: (Variable 2 t2 [] Local () () Default (Tuple [(Real 8 []) (Logical 4 []) (Logical 4 []) (Character 1 -2 () []) (Integer 4 [])]) Source Public Required .false.), t3: (Variable 2 t3 [] Local () () Default (Integer 4 []) Source Public Required .false.), tmp: (Variable 2 tmp [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_len (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 s) (StringConstant "abcd" (Character 1 4 () [])) ()) (Assert (IntegerCompare (StringLen (Var 2 s) (Integer 4 []) ()) Eq (IntegerConstant 4 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 s) (StringConstant "" (Character 1 0 () [])) ()) (Assert (IntegerCompare (StringLen (Var 2 s) (Integer 4 []) ()) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StringLen (StringConstant "abcd" (Character 1 4 () [])) (Integer 4 []) (IntegerConstant 4 (Integer 4 []))) Eq (IntegerConstant 4 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (IntegerCompare (StringLen (StringConstant "" (Character 1 0 () [])) (Integer 4 []) (IntegerConstant 0 (Integer 4 []))) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (= (Var 2 l) (ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (List (Integer 4 []))) ()) (Assert (IntegerCompare (ListLen (Var 2 l) (Integer 4 []) ()) Eq (IntegerConstant 4 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 l2) (ListConstant [(RealConstant 1.200000 (Real 8 [])) (RealConstant 3.400000 (Real 8 [])) (RealConstant 5.600000 (Real 8 [])) (RealConstant 7.800000 (Real 8 [])) (RealConstant 9.000000 (Real 8 []))] (List (Real 8 []))) ()) (Assert (IntegerCompare (ListLen (Var 2 l2) (Integer 4 []) ()) Eq (IntegerConstant 5 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 l3) (ListConstant [] (List (Integer 4 []))) ()) (Assert (IntegerCompare (ListLen (Var 2 l3) (Integer 4 []) ()) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) ()) (DoLoop ((Var 2 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 50 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 49 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(ListAppend (Var 2 l3) (Var 2 i))]) (Assert (IntegerCompare (ListLen (Var 2 l3) (Integer 4 []) ()) Eq (IntegerConstant 50 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 list_len) (ListLen (ListConstant [(RealConstant 1.000000 (Real 8 [])) (RealConstant 2.000000 (Real 8 []))] (List (Real 8 []))) (Integer 4 []) (IntegerConstant 2 (Integer 4 []))) ()) (Assert (IntegerCompare (Var 2 list_len) Eq (IntegerConstant 2 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 t) (TupleConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (StringConstant "a" (Character 1 1 () []))] (Tuple [(Integer 4 []) (Integer 4 []) (Character 1 1 () [])])) ()) (Assert (IntegerCompare (TupleLen (Var 2 t) (Integer 4 []) (IntegerConstant 3 (Integer 4 []))) Eq (IntegerConstant 3 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (= (Var 2 t2) (TupleConstant [(RealConstant 1.200000 (Real 8 [])) (LogicalConstant .true. (Logical 4 [])) (LogicalConstant .false. (Logical 4 [])) (StringConstant "b" (Character 1 1 () [])) (IntegerConstant 3 (Integer 4 []))] (Tuple [(Real 8 []) (Logical 4 []) (Logical 4 []) (Character 1 1 () []) (Integer 4 [])])) ()) (Assert (IntegerCompare (TupleLen (Var 2 t2) (Integer 4 []) (IntegerConstant 5 (Integer 4 []))) Eq (IntegerConstant 5 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (= (Var 2 t3) (TupleLen (TupleConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])) (IntegerConstant 5 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 []) (Integer 4 []) (Integer 4 []) (Integer 4 [])])) (Integer 4 []) (IntegerConstant 5 (Integer 4 []))) ()) (Assert (IntegerCompare (Var 2 t3) Eq (IntegerConstant 5 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 tmp) (ListLen (Var 2 l) (Integer 4 []) ()) ()) (DoLoop ((Var 2 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (TupleLen (Var 2 t2) (Integer 4 []) (IntegerConstant 5 (Integer 4 []))) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 4 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(ListAppend (Var 2 l) (Var 2 i))]) (Assert (IntegerCompare (ListLen (Var 2 l) (Integer 4 []) ()) Eq (IntegerBinOp (TupleLen (Var 2 t2) (Integer 4 []) (IntegerConstant 5 (Integer 4 []))) Add (Var 2 tmp) (Integer 4 []) ()) (Logical 4 []) ()) ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 5 {_lpython_main_program: (ExternalSymbol 5 _lpython_main_program 7 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 5 _lpython_main_program () [] ())])}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 7 {_lpython_main_program: (Function (SymbolTable 6 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_len] [] [(SubroutineCall 7 test_len () [] ())] () Public .false. .false.), test_len: (Function (SymbolTable 2 {i: (Variable 2 i [] Local () () Default (Integer 4 []) Source Public Required .false.), l: (Variable 2 l [] Local () () Default (List (Integer 4 [])) Source Public Required .false.), l2: (Variable 2 l2 [] Local () () Default (List (Real 8 [])) Source Public Required .false.), l3: (Variable 2 l3 [] Local () () Default (List (Integer 4 [])) Source Public Required .false.), list_len: (Variable 2 list_len [] Local () () Default (Integer 4 []) Source Public Required .false.), s: (Variable 2 s [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), t: (Variable 2 t [] Local () () Default (Tuple [(Integer 4 []) (Integer 4 []) (Character 1 -2 () [])]) Source Public Required .false.), t2: (Variable 2 t2 [] Local () () Default (Tuple [(Real 8 []) (Logical 4 []) (Logical 4 []) (Character 1 -2 () []) (Integer 4 [])]) Source Public Required .false.), t3: (Variable 2 t3 [] Local () () Default (Integer 4 []) Source Public Required .false.), tmp: (Variable 2 tmp [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_len (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 s) (StringConstant "abcd" (Character 1 4 () [])) ()) (Assert (IntegerCompare (StringLen (Var 2 s) (Integer 4 []) ()) Eq (IntegerConstant 4 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 s) (StringConstant "" (Character 1 0 () [])) ()) (Assert (IntegerCompare (StringLen (Var 2 s) (Integer 4 []) ()) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) ()) (Assert (IntegerCompare (StringLen (StringConstant "abcd" (Character 1 4 () [])) (Integer 4 []) (IntegerConstant 4 (Integer 4 []))) Eq (IntegerConstant 4 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (IntegerCompare (StringLen (StringConstant "" (Character 1 0 () [])) (Integer 4 []) (IntegerConstant 0 (Integer 4 []))) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (= (Var 2 l) (ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (List (Integer 4 []))) ()) (Assert (IntegerCompare (ListLen (Var 2 l) (Integer 4 []) ()) Eq (IntegerConstant 4 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 l2) (ListConstant [(RealConstant 1.200000 (Real 8 [])) (RealConstant 3.400000 (Real 8 [])) (RealConstant 5.600000 (Real 8 [])) (RealConstant 7.800000 (Real 8 [])) (RealConstant 9.000000 (Real 8 []))] (List (Real 8 []))) ()) (Assert (IntegerCompare (ListLen (Var 2 l2) (Integer 4 []) ()) Eq (IntegerConstant 5 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 l3) (ListConstant [] (List (Integer 4 []))) ()) (Assert (IntegerCompare (ListLen (Var 2 l3) (Integer 4 []) ()) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) ()) (DoLoop () ((Var 2 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 50 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 49 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(ListAppend (Var 2 l3) (Var 2 i))]) (Assert (IntegerCompare (ListLen (Var 2 l3) (Integer 4 []) ()) Eq (IntegerConstant 50 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 list_len) (ListLen (ListConstant [(RealConstant 1.000000 (Real 8 [])) (RealConstant 2.000000 (Real 8 []))] (List (Real 8 []))) (Integer 4 []) (IntegerConstant 2 (Integer 4 []))) ()) (Assert (IntegerCompare (Var 2 list_len) Eq (IntegerConstant 2 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 t) (TupleConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (StringConstant "a" (Character 1 1 () []))] (Tuple [(Integer 4 []) (Integer 4 []) (Character 1 1 () [])])) ()) (Assert (IntegerCompare (TupleLen (Var 2 t) (Integer 4 []) (IntegerConstant 3 (Integer 4 []))) Eq (IntegerConstant 3 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (= (Var 2 t2) (TupleConstant [(RealConstant 1.200000 (Real 8 [])) (LogicalConstant .true. (Logical 4 [])) (LogicalConstant .false. (Logical 4 [])) (StringConstant "b" (Character 1 1 () [])) (IntegerConstant 3 (Integer 4 []))] (Tuple [(Real 8 []) (Logical 4 []) (Logical 4 []) (Character 1 1 () []) (Integer 4 [])])) ()) (Assert (IntegerCompare (TupleLen (Var 2 t2) (Integer 4 []) (IntegerConstant 5 (Integer 4 []))) Eq (IntegerConstant 5 (Integer 4 [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (= (Var 2 t3) (TupleLen (TupleConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])) (IntegerConstant 5 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 []) (Integer 4 []) (Integer 4 []) (Integer 4 [])])) (Integer 4 []) (IntegerConstant 5 (Integer 4 []))) ()) (Assert (IntegerCompare (Var 2 t3) Eq (IntegerConstant 5 (Integer 4 [])) (Logical 4 []) ()) ()) (= (Var 2 tmp) (ListLen (Var 2 l) (Integer 4 []) ()) ()) (DoLoop () ((Var 2 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (TupleLen (Var 2 t2) (Integer 4 []) (IntegerConstant 5 (Integer 4 []))) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 4 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(ListAppend (Var 2 l) (Var 2 i))]) (Assert (IntegerCompare (ListLen (Var 2 l) (Integer 4 []) ()) Eq (IntegerBinOp (TupleLen (Var 2 t2) (Integer 4 []) (IntegerConstant 5 (Integer 4 []))) Add (Var 2 tmp) (Integer 4 []) ()) (Logical 4 []) ()) ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 5 {_lpython_main_program: (ExternalSymbol 5 _lpython_main_program 7 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 5 _lpython_main_program () [] ())])}) []) diff --git a/tests/reference/asr-test_builtin_str-580e920.json b/tests/reference/asr-test_builtin_str-580e920.json index 036bd86568..c6a0efe519 100644 --- a/tests/reference/asr-test_builtin_str-580e920.json +++ b/tests/reference/asr-test_builtin_str-580e920.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-test_builtin_str-580e920.stdout", - "stdout_hash": "a34ff81c22135e31ba7141fe5aff5cf47a19facf707dca5167829055", + "stdout_hash": "f38f1ca62fcd1e67729ad96102c1ec6c459b303c0311e31320c6dd8f", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-test_builtin_str-580e920.stdout b/tests/reference/asr-test_builtin_str-580e920.stdout index 30b2b1fe68..a4d2dca5b9 100644 --- a/tests/reference/asr-test_builtin_str-580e920.stdout +++ b/tests/reference/asr-test_builtin_str-580e920.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 9 {_lpython_main_program: (Function (SymbolTable 8 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_str_int_float str_conv_for_variables test_str_slice_step test_issue_883] [] [(SubroutineCall 9 test_str_int_float () [] ()) (SubroutineCall 9 str_conv_for_variables () [] ()) (SubroutineCall 9 test_str_slice_step () [] ()) (SubroutineCall 9 test_issue_883 () [] ())] () Public .false. .false.), str_conv_for_variables: (Function (SymbolTable 3 {bool_t: (Variable 3 bool_t [] Local () () Default (Logical 4 []) Source Public Required .false.), str_t: (Variable 3 str_t [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), x: (Variable 3 x [] Local () () Default (Integer 4 []) Source Public Required .false.), xx: (Variable 3 xx [] Local () () Default (Real 4 []) Source Public Required .false.), yy: (Variable 3 yy [] Local () () Default (Real 8 []) Source Public Required .false.)}) str_conv_for_variables (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 3 x) (IntegerConstant 123 (Integer 4 [])) ()) (Assert (StringCompare (StringConstant "123" (Character 1 3 () [])) Eq (Cast (Var 3 x) IntegerToCharacter (Character 1 -2 () []) ()) (Logical 4 []) ()) ()) (= (Var 3 x) (IntegerConstant 12345 (Integer 4 [])) ()) (Assert (StringCompare (StringConstant "12345" (Character 1 5 () [])) Eq (Cast (Var 3 x) IntegerToCharacter (Character 1 -2 () []) ()) (Logical 4 []) ()) ()) (= (Var 3 x) (IntegerUnaryMinus (IntegerConstant 12 (Integer 4 [])) (Integer 4 []) (IntegerConstant -12 (Integer 4 []))) ()) (Assert (StringCompare (StringConstant "-12" (Character 1 3 () [])) Eq (Cast (Var 3 x) IntegerToCharacter (Character 1 -2 () []) ()) (Logical 4 []) ()) ()) (= (Var 3 x) (IntegerUnaryMinus (IntegerConstant 121212 (Integer 4 [])) (Integer 4 []) (IntegerConstant -121212 (Integer 4 []))) ()) (Assert (StringCompare (StringConstant "-121212" (Character 1 7 () [])) Eq (Cast (Var 3 x) IntegerToCharacter (Character 1 -2 () []) ()) (Logical 4 []) ()) ()) (= (Var 3 xx) (Cast (RealConstant 12.322234 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 12.322234 (Real 4 []))) ()) (Assert (StringCompare (Cast (Var 3 xx) RealToCharacter (Character 1 -2 () []) ()) Eq (StringConstant "12.322234" (Character 1 9 () [])) (Logical 4 []) ()) ()) (= (Var 3 yy) (RealConstant 12.322234 (Real 8 [])) ()) (Assert (StringCompare (Cast (Var 3 yy) RealToCharacter (Character 1 -2 () []) ()) Eq (StringConstant "12.322234" (Character 1 9 () [])) (Logical 4 []) ()) ()) (= (Var 3 bool_t) (LogicalConstant .true. (Logical 4 [])) ()) (Assert (StringCompare (Cast (Var 3 bool_t) LogicalToCharacter (Character 1 -2 () []) ()) Eq (StringConstant "True" (Character 1 4 () [])) (Logical 4 []) ()) ()) (= (Var 3 bool_t) (LogicalConstant .false. (Logical 4 [])) ()) (Assert (StringCompare (Cast (Var 3 bool_t) LogicalToCharacter (Character 1 -2 () []) ()) Eq (StringConstant "False" (Character 1 5 () [])) (Logical 4 []) ()) ()) (= (Var 3 str_t) (StringConstant "just a str" (Character 1 10 () [])) ()) (Assert (StringCompare (Var 3 str_t) Eq (Var 3 str_t) (Logical 4 []) ()) ())] () Public .false. .false.), test_issue_883: (Function (SymbolTable 5 {__explicit_iterator: (Variable 5 __explicit_iterator [] Local () () Default (Integer 4 []) Source Public Required .false.), __tmp_assign_for_loop: (Variable 5 __tmp_assign_for_loop [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), c: (Variable 5 c [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), d: (Variable 5 d [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), i: (Variable 5 i [] Local () () Default (Integer 4 []) Source Public Required .false.), s: (Variable 5 s [] Local () () Default (Character 1 -2 () []) Source Public Required .false.)}) test_issue_883 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 5 s) (StringConstant "abcde" (Character 1 5 () [])) ()) (= (Var 5 d) (StringConstant "edcba" (Character 1 5 () [])) ()) (= (Var 5 i) (IntegerConstant 0 (Integer 4 [])) ()) (= (Var 5 __tmp_assign_for_loop) (StringSection (Var 5 s) () () (IntegerUnaryMinus (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant -1 (Integer 4 []))) (Character 1 -2 () []) ()) ()) (DoLoop ((Var 5 __explicit_iterator) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (StringLen (Var 5 __tmp_assign_for_loop) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 5 c) (StringItem (Var 5 __tmp_assign_for_loop) (IntegerBinOp (Var 5 __explicit_iterator) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) ()) (Print () [(Var 5 c)] () ()) (Assert (StringCompare (Var 5 c) Eq (StringItem (Var 5 d) (IntegerBinOp (Var 5 i) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Character 1 -2 () []) ()) (Logical 4 []) ()) ()) (= (Var 5 i) (IntegerBinOp (Var 5 i) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) ())])] () Public .false. .false.), test_str_int_float: (Function (SymbolTable 2 {s: (Variable 2 s [] Local () () Default (Character 1 -2 () []) Source Public Required .false.)}) test_str_int_float (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 s) (Cast (IntegerConstant 356 (Integer 4 [])) IntegerToCharacter (Character 1 -2 () []) (StringConstant "356" (Character 1 3 () []))) ()) (Assert (StringCompare (Var 2 s) Eq (StringConstant "356" (Character 1 3 () [])) (Logical 4 []) ()) ()) (= (Var 2 s) (Cast (IntegerUnaryMinus (IntegerConstant 567 (Integer 4 [])) (Integer 4 []) (IntegerConstant -567 (Integer 4 []))) IntegerToCharacter (Character 1 -2 () []) (StringConstant "-567" (Character 1 4 () []))) ()) (Assert (StringCompare (Var 2 s) Eq (StringConstant "-567" (Character 1 4 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (Cast (IntegerConstant 4 (Integer 4 [])) IntegerToCharacter (Character 1 -2 () []) (StringConstant "4" (Character 1 1 () []))) Eq (StringConstant "4" (Character 1 1 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (Cast (IntegerUnaryMinus (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) (IntegerConstant -5 (Integer 4 []))) IntegerToCharacter (Character 1 -2 () []) (StringConstant "-5" (Character 1 2 () []))) Eq (StringConstant "-5" (Character 1 2 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (StringConstant "" (Character 1 0 () [])) Eq (StringConstant "" (Character 1 0 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (StringConstant "1234" (Character 1 4 () [])) Eq (StringConstant "1234" (Character 1 4 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (Cast (LogicalConstant .false. (Logical 4 [])) LogicalToCharacter (Character 1 -2 () []) (StringConstant "False" (Character 1 5 () []))) Eq (StringConstant "False" (Character 1 5 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (Cast (LogicalConstant .true. (Logical 4 [])) LogicalToCharacter (Character 1 -2 () []) (StringConstant "True" (Character 1 4 () []))) Eq (StringConstant "True" (Character 1 4 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (StringConstant "just a str" (Character 1 10 () [])) Eq (StringConstant "just a str" (Character 1 10 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (StringSection (Cast (RealConstant 12.123400 (Real 8 [])) RealToCharacter (Character 1 -2 () []) (StringConstant "12.1234" (Character 1 7 () []))) () (IntegerConstant 7 (Integer 4 [])) () (Character 1 -2 () []) ()) Eq (StringConstant "12.1234" (Character 1 7 () [])) (Logical 4 []) ()) ())] () Public .false. .false.), test_str_slice_step: (Function (SymbolTable 4 {end: (Variable 4 end [] Local () () Default (Integer 4 []) Source Public Required .false.), s: (Variable 4 s [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), start: (Variable 4 start [] Local () () Default (Integer 4 []) Source Public Required .false.), step: (Variable 4 step [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_str_slice_step (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 4 s) (StringConstant "abcdefghijk" (Character 1 11 () [])) ()) (= (Var 4 start) (IntegerConstant 1 (Integer 4 [])) ()) (= (Var 4 end) (IntegerConstant 4 (Integer 4 [])) ()) (= (Var 4 step) (IntegerConstant 1 (Integer 4 [])) ()) (Assert (StringCompare (StringSection (Var 4 s) () () () (Character 1 -2 () []) ()) Eq (StringConstant "abcdefghijk" (Character 1 11 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 1 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])) () (Character 1 -2 () []) ()) Eq (StringConstant "bcd" (Character 1 3 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) () (IntegerConstant 4 (Integer 4 [])) (IntegerConstant 5 (Integer 4 [])) (Character 1 -2 () []) ()) Eq (StringConstant "a" (Character 1 1 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) () () (IntegerUnaryMinus (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant -1 (Integer 4 []))) (Character 1 -2 () []) ()) Eq (StringConstant "kjihgfedcba" (Character 1 11 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 12 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (Character 1 -2 () []) ()) Eq (StringConstant "dgj" (Character 1 3 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 1 (Integer 4 [])) () (IntegerConstant 3 (Integer 4 [])) (Character 1 -2 () []) ()) Eq (StringConstant "behk" (Character 1 4 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 4 (Integer 4 [])) () () (Character 1 -2 () []) ()) Eq (StringConstant "efghijk" (Character 1 7 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) () (IntegerConstant 5 (Integer 4 [])) () (Character 1 -2 () []) ()) Eq (StringConstant "abcde" (Character 1 5 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 9 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (Character 1 -2 () []) ()) Eq (StringConstant "dg" (Character 1 2 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 10 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerUnaryMinus (IntegerConstant 2 (Integer 4 [])) (Integer 4 []) (IntegerConstant -2 (Integer 4 []))) (Character 1 -2 () []) ()) Eq (StringConstant "kige" (Character 1 4 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerUnaryMinus (IntegerConstant 2 (Integer 4 [])) (Integer 4 []) (IntegerConstant -2 (Integer 4 []))) (IntegerUnaryMinus (IntegerConstant 10 (Integer 4 [])) (Integer 4 []) (IntegerConstant -10 (Integer 4 []))) () (Character 1 -2 () []) ()) Eq (StringConstant "" (Character 1 0 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerUnaryMinus (IntegerConstant 9 (Integer 4 [])) (Integer 4 []) (IntegerConstant -9 (Integer 4 []))) (IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (Character 1 -2 () []) ()) Eq (StringConstant "if" (Character 1 2 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerUnaryMinus (IntegerConstant 10 (Integer 4 [])) (Integer 4 []) (IntegerConstant -10 (Integer 4 []))) (IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (Character 1 -2 () []) ()) Eq (StringConstant "ifc" (Character 1 3 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (Var 4 start) (Var 4 end) (Var 4 step) (Character 1 -2 () []) ()) Eq (StringConstant "bcd" (Character 1 3 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (Var 4 start) (IntegerBinOp (IntegerBinOp (IntegerConstant 2 (Integer 4 [])) Mul (Var 4 end) (Integer 4 []) ()) Sub (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) ()) (Var 4 step) (Character 1 -2 () []) ()) Eq (StringConstant "bcde" (Character 1 4 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (Var 4 start) (IntegerBinOp (IntegerBinOp (IntegerConstant 2 (Integer 4 [])) Mul (Var 4 end) (Integer 4 []) ()) Sub (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) ()) (IntegerUnaryMinus (Var 4 step) (Integer 4 []) ()) (Character 1 -2 () []) ()) Eq (StringConstant "" (Character 1 0 () [])) (Logical 4 []) ()) ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 7 {_lpython_main_program: (ExternalSymbol 7 _lpython_main_program 9 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 7 _lpython_main_program () [] ())])}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 9 {_lpython_main_program: (Function (SymbolTable 8 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_str_int_float str_conv_for_variables test_str_slice_step test_issue_883] [] [(SubroutineCall 9 test_str_int_float () [] ()) (SubroutineCall 9 str_conv_for_variables () [] ()) (SubroutineCall 9 test_str_slice_step () [] ()) (SubroutineCall 9 test_issue_883 () [] ())] () Public .false. .false.), str_conv_for_variables: (Function (SymbolTable 3 {bool_t: (Variable 3 bool_t [] Local () () Default (Logical 4 []) Source Public Required .false.), str_t: (Variable 3 str_t [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), x: (Variable 3 x [] Local () () Default (Integer 4 []) Source Public Required .false.), xx: (Variable 3 xx [] Local () () Default (Real 4 []) Source Public Required .false.), yy: (Variable 3 yy [] Local () () Default (Real 8 []) Source Public Required .false.)}) str_conv_for_variables (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 3 x) (IntegerConstant 123 (Integer 4 [])) ()) (Assert (StringCompare (StringConstant "123" (Character 1 3 () [])) Eq (Cast (Var 3 x) IntegerToCharacter (Character 1 -2 () []) ()) (Logical 4 []) ()) ()) (= (Var 3 x) (IntegerConstant 12345 (Integer 4 [])) ()) (Assert (StringCompare (StringConstant "12345" (Character 1 5 () [])) Eq (Cast (Var 3 x) IntegerToCharacter (Character 1 -2 () []) ()) (Logical 4 []) ()) ()) (= (Var 3 x) (IntegerUnaryMinus (IntegerConstant 12 (Integer 4 [])) (Integer 4 []) (IntegerConstant -12 (Integer 4 []))) ()) (Assert (StringCompare (StringConstant "-12" (Character 1 3 () [])) Eq (Cast (Var 3 x) IntegerToCharacter (Character 1 -2 () []) ()) (Logical 4 []) ()) ()) (= (Var 3 x) (IntegerUnaryMinus (IntegerConstant 121212 (Integer 4 [])) (Integer 4 []) (IntegerConstant -121212 (Integer 4 []))) ()) (Assert (StringCompare (StringConstant "-121212" (Character 1 7 () [])) Eq (Cast (Var 3 x) IntegerToCharacter (Character 1 -2 () []) ()) (Logical 4 []) ()) ()) (= (Var 3 xx) (Cast (RealConstant 12.322234 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 12.322234 (Real 4 []))) ()) (Assert (StringCompare (Cast (Var 3 xx) RealToCharacter (Character 1 -2 () []) ()) Eq (StringConstant "12.322234" (Character 1 9 () [])) (Logical 4 []) ()) ()) (= (Var 3 yy) (RealConstant 12.322234 (Real 8 [])) ()) (Assert (StringCompare (Cast (Var 3 yy) RealToCharacter (Character 1 -2 () []) ()) Eq (StringConstant "12.322234" (Character 1 9 () [])) (Logical 4 []) ()) ()) (= (Var 3 bool_t) (LogicalConstant .true. (Logical 4 [])) ()) (Assert (StringCompare (Cast (Var 3 bool_t) LogicalToCharacter (Character 1 -2 () []) ()) Eq (StringConstant "True" (Character 1 4 () [])) (Logical 4 []) ()) ()) (= (Var 3 bool_t) (LogicalConstant .false. (Logical 4 [])) ()) (Assert (StringCompare (Cast (Var 3 bool_t) LogicalToCharacter (Character 1 -2 () []) ()) Eq (StringConstant "False" (Character 1 5 () [])) (Logical 4 []) ()) ()) (= (Var 3 str_t) (StringConstant "just a str" (Character 1 10 () [])) ()) (Assert (StringCompare (Var 3 str_t) Eq (Var 3 str_t) (Logical 4 []) ()) ())] () Public .false. .false.), test_issue_883: (Function (SymbolTable 5 {__explicit_iterator: (Variable 5 __explicit_iterator [] Local () () Default (Integer 4 []) Source Public Required .false.), __tmp_assign_for_loop: (Variable 5 __tmp_assign_for_loop [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), c: (Variable 5 c [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), d: (Variable 5 d [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), i: (Variable 5 i [] Local () () Default (Integer 4 []) Source Public Required .false.), s: (Variable 5 s [] Local () () Default (Character 1 -2 () []) Source Public Required .false.)}) test_issue_883 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 5 s) (StringConstant "abcde" (Character 1 5 () [])) ()) (= (Var 5 d) (StringConstant "edcba" (Character 1 5 () [])) ()) (= (Var 5 i) (IntegerConstant 0 (Integer 4 [])) ()) (= (Var 5 __tmp_assign_for_loop) (StringSection (Var 5 s) () () (IntegerUnaryMinus (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant -1 (Integer 4 []))) (Character 1 -2 () []) ()) ()) (DoLoop () ((Var 5 __explicit_iterator) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (StringLen (Var 5 __tmp_assign_for_loop) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(= (Var 5 c) (StringItem (Var 5 __tmp_assign_for_loop) (IntegerBinOp (Var 5 __explicit_iterator) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) ()) (Print () [(Var 5 c)] () ()) (Assert (StringCompare (Var 5 c) Eq (StringItem (Var 5 d) (IntegerBinOp (Var 5 i) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Character 1 -2 () []) ()) (Logical 4 []) ()) ()) (= (Var 5 i) (IntegerBinOp (Var 5 i) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) ())])] () Public .false. .false.), test_str_int_float: (Function (SymbolTable 2 {s: (Variable 2 s [] Local () () Default (Character 1 -2 () []) Source Public Required .false.)}) test_str_int_float (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 s) (Cast (IntegerConstant 356 (Integer 4 [])) IntegerToCharacter (Character 1 -2 () []) (StringConstant "356" (Character 1 3 () []))) ()) (Assert (StringCompare (Var 2 s) Eq (StringConstant "356" (Character 1 3 () [])) (Logical 4 []) ()) ()) (= (Var 2 s) (Cast (IntegerUnaryMinus (IntegerConstant 567 (Integer 4 [])) (Integer 4 []) (IntegerConstant -567 (Integer 4 []))) IntegerToCharacter (Character 1 -2 () []) (StringConstant "-567" (Character 1 4 () []))) ()) (Assert (StringCompare (Var 2 s) Eq (StringConstant "-567" (Character 1 4 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (Cast (IntegerConstant 4 (Integer 4 [])) IntegerToCharacter (Character 1 -2 () []) (StringConstant "4" (Character 1 1 () []))) Eq (StringConstant "4" (Character 1 1 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (Cast (IntegerUnaryMinus (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) (IntegerConstant -5 (Integer 4 []))) IntegerToCharacter (Character 1 -2 () []) (StringConstant "-5" (Character 1 2 () []))) Eq (StringConstant "-5" (Character 1 2 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (StringConstant "" (Character 1 0 () [])) Eq (StringConstant "" (Character 1 0 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (StringConstant "1234" (Character 1 4 () [])) Eq (StringConstant "1234" (Character 1 4 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (Cast (LogicalConstant .false. (Logical 4 [])) LogicalToCharacter (Character 1 -2 () []) (StringConstant "False" (Character 1 5 () []))) Eq (StringConstant "False" (Character 1 5 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (Cast (LogicalConstant .true. (Logical 4 [])) LogicalToCharacter (Character 1 -2 () []) (StringConstant "True" (Character 1 4 () []))) Eq (StringConstant "True" (Character 1 4 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (StringConstant "just a str" (Character 1 10 () [])) Eq (StringConstant "just a str" (Character 1 10 () [])) (Logical 4 []) (LogicalConstant .true. (Logical 4 []))) ()) (Assert (StringCompare (StringSection (Cast (RealConstant 12.123400 (Real 8 [])) RealToCharacter (Character 1 -2 () []) (StringConstant "12.1234" (Character 1 7 () []))) () (IntegerConstant 7 (Integer 4 [])) () (Character 1 -2 () []) ()) Eq (StringConstant "12.1234" (Character 1 7 () [])) (Logical 4 []) ()) ())] () Public .false. .false.), test_str_slice_step: (Function (SymbolTable 4 {end: (Variable 4 end [] Local () () Default (Integer 4 []) Source Public Required .false.), s: (Variable 4 s [] Local () () Default (Character 1 -2 () []) Source Public Required .false.), start: (Variable 4 start [] Local () () Default (Integer 4 []) Source Public Required .false.), step: (Variable 4 step [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_str_slice_step (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 4 s) (StringConstant "abcdefghijk" (Character 1 11 () [])) ()) (= (Var 4 start) (IntegerConstant 1 (Integer 4 [])) ()) (= (Var 4 end) (IntegerConstant 4 (Integer 4 [])) ()) (= (Var 4 step) (IntegerConstant 1 (Integer 4 [])) ()) (Assert (StringCompare (StringSection (Var 4 s) () () () (Character 1 -2 () []) ()) Eq (StringConstant "abcdefghijk" (Character 1 11 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 1 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])) () (Character 1 -2 () []) ()) Eq (StringConstant "bcd" (Character 1 3 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) () (IntegerConstant 4 (Integer 4 [])) (IntegerConstant 5 (Integer 4 [])) (Character 1 -2 () []) ()) Eq (StringConstant "a" (Character 1 1 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) () () (IntegerUnaryMinus (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant -1 (Integer 4 []))) (Character 1 -2 () []) ()) Eq (StringConstant "kjihgfedcba" (Character 1 11 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 12 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (Character 1 -2 () []) ()) Eq (StringConstant "dgj" (Character 1 3 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 1 (Integer 4 [])) () (IntegerConstant 3 (Integer 4 [])) (Character 1 -2 () []) ()) Eq (StringConstant "behk" (Character 1 4 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 4 (Integer 4 [])) () () (Character 1 -2 () []) ()) Eq (StringConstant "efghijk" (Character 1 7 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) () (IntegerConstant 5 (Integer 4 [])) () (Character 1 -2 () []) ()) Eq (StringConstant "abcde" (Character 1 5 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 9 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (Character 1 -2 () []) ()) Eq (StringConstant "dg" (Character 1 2 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerConstant 10 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerUnaryMinus (IntegerConstant 2 (Integer 4 [])) (Integer 4 []) (IntegerConstant -2 (Integer 4 []))) (Character 1 -2 () []) ()) Eq (StringConstant "kige" (Character 1 4 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerUnaryMinus (IntegerConstant 2 (Integer 4 [])) (Integer 4 []) (IntegerConstant -2 (Integer 4 []))) (IntegerUnaryMinus (IntegerConstant 10 (Integer 4 [])) (Integer 4 []) (IntegerConstant -10 (Integer 4 []))) () (Character 1 -2 () []) ()) Eq (StringConstant "" (Character 1 0 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerUnaryMinus (IntegerConstant 9 (Integer 4 [])) (Integer 4 []) (IntegerConstant -9 (Integer 4 []))) (IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (Character 1 -2 () []) ()) Eq (StringConstant "if" (Character 1 2 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerUnaryMinus (IntegerConstant 10 (Integer 4 [])) (Integer 4 []) (IntegerConstant -10 (Integer 4 []))) (IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (Character 1 -2 () []) ()) Eq (StringConstant "ifc" (Character 1 3 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (Var 4 start) (Var 4 end) (Var 4 step) (Character 1 -2 () []) ()) Eq (StringConstant "bcd" (Character 1 3 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (Var 4 start) (IntegerBinOp (IntegerBinOp (IntegerConstant 2 (Integer 4 [])) Mul (Var 4 end) (Integer 4 []) ()) Sub (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) ()) (Var 4 step) (Character 1 -2 () []) ()) Eq (StringConstant "bcde" (Character 1 4 () [])) (Logical 4 []) ()) ()) (Assert (StringCompare (StringSection (Var 4 s) (Var 4 start) (IntegerBinOp (IntegerBinOp (IntegerConstant 2 (Integer 4 [])) Mul (Var 4 end) (Integer 4 []) ()) Sub (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) ()) (IntegerUnaryMinus (Var 4 step) (Integer 4 []) ()) (Character 1 -2 () []) ()) Eq (StringConstant "" (Character 1 0 () [])) (Logical 4 []) ()) ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 7 {_lpython_main_program: (ExternalSymbol 7 _lpython_main_program 9 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 7 _lpython_main_program () [] ())])}) []) diff --git a/tests/reference/asr-test_numpy_03-e600a49.json b/tests/reference/asr-test_numpy_03-e600a49.json index 929ab023d0..94ca09424d 100644 --- a/tests/reference/asr-test_numpy_03-e600a49.json +++ b/tests/reference/asr-test_numpy_03-e600a49.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-test_numpy_03-e600a49.stdout", - "stdout_hash": "03297da27bcaac933b67b62ecd9bbe7d03ac0db8b0eb8397609c49e3", + "stdout_hash": "d1e7c08f9b8af6268730cf64cbf24bd0591214d22dcf6f51fe845ba0", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-test_numpy_03-e600a49.stdout b/tests/reference/asr-test_numpy_03-e600a49.stdout index ed7ff76ef0..8b7a73d22e 100644 --- a/tests/reference/asr-test_numpy_03-e600a49.stdout +++ b/tests/reference/asr-test_numpy_03-e600a49.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 202 {_lpython_main_program: (Function (SymbolTable 201 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_reshape_with_argument] [] [(SubroutineCall 202 test_reshape_with_argument () [] ())] () Public .false. .false.), test_1d_to_nd: (Function (SymbolTable 184 {a: (Variable 184 a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.), b: (Variable 184 b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) Source Public Required .false.), block: (Block (SymbolTable 191 {_lpython_floordiv: (ExternalSymbol 191 _lpython_floordiv 79 _lpython_floordiv lpython_builtin [] _lpython_floordiv Private), _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv: (ExternalSymbol 191 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 79 __lpython_overloaded_4___lpython_floordiv lpython_builtin [] __lpython_overloaded_4___lpython_floordiv Public)}) block [(= (Var 184 i) (FunctionCall 191 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 191 _lpython_floordiv [((Var 184 k)) ((IntegerConstant 16 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 184 j) (IntegerBinOp (Var 184 k) Sub (IntegerBinOp (Var 184 i) Mul (IntegerConstant 16 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) ()) (= (ArrayItem (Var 184 b) [(() (Var 184 k) ())] (Real 8 []) RowMajor ()) (RealBinOp (Cast (IntegerBinOp (Var 184 i) Add (Var 184 j) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) Add (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ()) ())]), c: (Variable 184 c [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.), d: (Variable 184 d [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), eps: (Variable 184 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 184 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 184 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 184 k [] Local () () Default (Integer 4 []) Source Public Required .false.), l: (Variable 184 l [] Local () () Default (Integer 4 []) Source Public Required .false.), newshape: (Variable 184 newshape [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])))]) Source Public Required .false.), newshape1: (Variable 184 newshape1 [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])))]) Source Public Required .false.)}) test_1d_to_nd (FunctionType [(Real 8 [(() ())])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [_lpython_floordiv@__lpython_overloaded_4___lpython_floordiv _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv] [(Var 184 d)] [(= (Var 184 eps) (RealConstant 0.000000 (Real 8 [])) ()) (DoLoop ((Var 184 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 256 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 255 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 184 block)]) (= (ArrayItem (Var 184 newshape) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 16 (Integer 4 [])) ()) (= (ArrayItem (Var 184 newshape) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 16 (Integer 4 [])) ()) (= (Var 184 a) (ArrayReshape (Var 184 b) (Var 184 newshape) (Real 8 [(() ())]) ()) ()) (DoLoop ((Var 184 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 184 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (ArrayItem (Var 184 a) [(() (Var 184 i) ()) (() (Var 184 j) ())] (Real 8 []) RowMajor ()) Sub (Cast (IntegerBinOp (Var 184 i) Add (Var 184 j) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) Sub (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 184 eps) (Logical 4 []) ()) ())])]) (= (ArrayItem (Var 184 newshape1) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 16 (Integer 4 [])) ()) (= (ArrayItem (Var 184 newshape1) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 16 (Integer 4 [])) ()) (= (ArrayItem (Var 184 newshape1) [(() (IntegerConstant 2 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 16 (Integer 4 [])) ()) (= (Var 184 c) (ArrayReshape (Var 184 d) (Var 184 newshape1) (Real 8 [(() ())]) ()) ()) (DoLoop ((Var 184 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 184 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 184 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (ArrayItem (Var 184 c) [(() (Var 184 i) ()) (() (Var 184 j) ()) (() (Var 184 k) ())] (Real 8 []) RowMajor ()) Sub (Cast (IntegerBinOp (IntegerBinOp (Var 184 i) Add (Var 184 j) (Integer 4 []) ()) Add (Var 184 k) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) Sub (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 184 eps) (Logical 4 []) ()) ())])])])] () Public .false. .false.), test_nd_to_1d: (Function (SymbolTable 183 {a: (Variable 183 a [] InOut () () Default (Real 8 [(() ()) (() ())]) Source Public Required .false.), b: (Variable 183 b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) Source Public Required .false.), block: (Block (SymbolTable 186 {_lpython_floordiv: (ExternalSymbol 186 _lpython_floordiv 79 _lpython_floordiv lpython_builtin [] _lpython_floordiv Private), _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv: (ExternalSymbol 186 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 79 __lpython_overloaded_4___lpython_floordiv lpython_builtin [] __lpython_overloaded_4___lpython_floordiv Public)}) block [(= (Var 183 i) (FunctionCall 186 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 186 _lpython_floordiv [((Var 183 k)) ((IntegerConstant 16 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 183 j) (IntegerBinOp (Var 183 k) Sub (IntegerBinOp (Var 183 i) Mul (IntegerConstant 16 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (ArrayItem (Var 183 b) [(() (Var 183 k) ())] (Real 8 []) RowMajor ()) Sub (Cast (IntegerBinOp (Var 183 i) Add (Var 183 j) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) Sub (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 183 eps) (Logical 4 []) ()) ())]), block1: (Block (SymbolTable 190 {_lpython_floordiv: (ExternalSymbol 190 _lpython_floordiv 79 _lpython_floordiv lpython_builtin [] _lpython_floordiv Private), _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv: (ExternalSymbol 190 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 79 __lpython_overloaded_4___lpython_floordiv lpython_builtin [] __lpython_overloaded_4___lpython_floordiv Public)}) block1 [(= (Var 183 i) (Cast (Cast (RealBinOp (Cast (Var 183 l) IntegerToReal (Real 8 []) ()) Div (Cast (IntegerConstant 256 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 256.000000 (Real 8 []))) (Real 8 []) ()) RealToInteger (Integer 8 []) ()) IntegerToInteger (Integer 4 []) ()) ()) (= (Var 183 j) (FunctionCall 190 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 190 _lpython_floordiv [((IntegerBinOp (Var 183 l) Sub (IntegerBinOp (Var 183 i) Mul (IntegerConstant 256 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ())) ((IntegerConstant 16 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 183 k) (IntegerBinOp (IntegerBinOp (Var 183 l) Sub (IntegerBinOp (Var 183 i) Mul (IntegerConstant 256 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) Sub (IntegerBinOp (Var 183 j) Mul (IntegerConstant 16 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (ArrayItem (Var 183 d) [(() (Var 183 l) ())] (Real 8 []) RowMajor ()) Sub (Cast (IntegerBinOp (IntegerBinOp (Var 183 i) Add (Var 183 j) (Integer 4 []) ()) Add (Var 183 k) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) Sub (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 183 eps) (Logical 4 []) ()) ())]), c: (Variable 183 c [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.), d: (Variable 183 d [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4096 (Integer 4 [])))]) Source Public Required .false.), eps: (Variable 183 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 183 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 183 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 183 k [] Local () () Default (Integer 4 []) Source Public Required .false.), l: (Variable 183 l [] Local () () Default (Integer 4 []) Source Public Required .false.), newshape: (Variable 183 newshape [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), newshape1: (Variable 183 newshape1 [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.)}) test_nd_to_1d (FunctionType [(Real 8 [(() ()) (() ())])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [_lpython_floordiv@__lpython_overloaded_4___lpython_floordiv _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv] [(Var 183 a)] [(= (Var 183 eps) (RealConstant 0.000000 (Real 8 [])) ()) (= (ArrayItem (Var 183 newshape) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 256 (Integer 4 [])) ()) (= (Var 183 b) (ArrayReshape (Var 183 a) (Var 183 newshape) (Real 8 [(() ())]) ()) ()) (DoLoop ((Var 183 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 256 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 255 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 183 block)]) (DoLoop ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 183 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 183 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 183 c) [(() (Var 183 i) ()) (() (Var 183 j) ()) (() (Var 183 k) ())] (Real 8 []) RowMajor ()) (RealBinOp (Cast (IntegerBinOp (IntegerBinOp (Var 183 i) Add (Var 183 j) (Integer 4 []) ()) Add (Var 183 k) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) Add (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ()) ())])])]) (= (ArrayItem (Var 183 newshape1) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 4096 (Integer 4 [])) ()) (= (Var 183 d) (ArrayReshape (Var 183 c) (Var 183 newshape1) (Real 8 [(() ())]) ()) ()) (DoLoop ((Var 183 l) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 4096 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 4095 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 183 block1)])] () Public .false. .false.), test_reshape_with_argument: (Function (SymbolTable 185 {a: (Variable 185 a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.), block: (Block (SymbolTable 199 {_lpython_floordiv: (ExternalSymbol 199 _lpython_floordiv 79 _lpython_floordiv lpython_builtin [] _lpython_floordiv Private), _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv: (ExternalSymbol 199 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 79 __lpython_overloaded_4___lpython_floordiv lpython_builtin [] __lpython_overloaded_4___lpython_floordiv Public)}) block [(= (Var 185 i) (Cast (Cast (RealBinOp (Cast (Var 185 l) IntegerToReal (Real 8 []) ()) Div (Cast (IntegerConstant 256 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 256.000000 (Real 8 []))) (Real 8 []) ()) RealToInteger (Integer 8 []) ()) IntegerToInteger (Integer 4 []) ()) ()) (= (Var 185 j) (FunctionCall 199 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 199 _lpython_floordiv [((IntegerBinOp (Var 185 l) Sub (IntegerBinOp (Var 185 i) Mul (IntegerConstant 256 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ())) ((IntegerConstant 16 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 185 k) (IntegerBinOp (IntegerBinOp (Var 185 l) Sub (IntegerBinOp (Var 185 i) Mul (IntegerConstant 256 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) Sub (IntegerBinOp (Var 185 j) Mul (IntegerConstant 16 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) ()) (= (ArrayItem (Var 185 d) [(() (Var 185 l) ())] (Real 8 []) RowMajor ()) (RealBinOp (Cast (IntegerBinOp (IntegerBinOp (Var 185 i) Add (Var 185 j) (Integer 4 []) ()) Add (Var 185 k) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) Add (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ()) ())]), d: (Variable 185 d [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4096 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 185 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 185 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 185 k [] Local () () Default (Integer 4 []) Source Public Required .false.), l: (Variable 185 l [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_reshape_with_argument (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [_lpython_floordiv@__lpython_overloaded_4___lpython_floordiv test_nd_to_1d _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv test_1d_to_nd] [] [(DoLoop ((Var 185 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop ((Var 185 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 185 a) [(() (Var 185 i) ()) (() (Var 185 j) ())] (Real 8 []) RowMajor ()) (RealBinOp (Cast (IntegerBinOp (Var 185 i) Add (Var 185 j) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) Add (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ()) ())])]) (SubroutineCall 202 test_nd_to_1d () [((Var 185 a))] ()) (DoLoop ((Var 185 l) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 4096 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 4095 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 185 block)]) (SubroutineCall 202 test_1d_to_nd () [((Var 185 d))] ())] () Public .false. .false.)}) _global_symbols [lpython_builtin] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 200 {_lpython_main_program: (ExternalSymbol 200 _lpython_main_program 202 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 200 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 202 {_lpython_main_program: (Function (SymbolTable 201 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [test_reshape_with_argument] [] [(SubroutineCall 202 test_reshape_with_argument () [] ())] () Public .false. .false.), test_1d_to_nd: (Function (SymbolTable 184 {a: (Variable 184 a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.), b: (Variable 184 b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) Source Public Required .false.), block: (Block (SymbolTable 191 {_lpython_floordiv: (ExternalSymbol 191 _lpython_floordiv 79 _lpython_floordiv lpython_builtin [] _lpython_floordiv Private), _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv: (ExternalSymbol 191 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 79 __lpython_overloaded_4___lpython_floordiv lpython_builtin [] __lpython_overloaded_4___lpython_floordiv Public)}) block [(= (Var 184 i) (FunctionCall 191 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 191 _lpython_floordiv [((Var 184 k)) ((IntegerConstant 16 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 184 j) (IntegerBinOp (Var 184 k) Sub (IntegerBinOp (Var 184 i) Mul (IntegerConstant 16 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) ()) (= (ArrayItem (Var 184 b) [(() (Var 184 k) ())] (Real 8 []) RowMajor ()) (RealBinOp (Cast (IntegerBinOp (Var 184 i) Add (Var 184 j) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) Add (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ()) ())]), c: (Variable 184 c [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.), d: (Variable 184 d [] InOut () () Default (Real 8 [(() ())]) Source Public Required .false.), eps: (Variable 184 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 184 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 184 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 184 k [] Local () () Default (Integer 4 []) Source Public Required .false.), l: (Variable 184 l [] Local () () Default (Integer 4 []) Source Public Required .false.), newshape: (Variable 184 newshape [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])))]) Source Public Required .false.), newshape1: (Variable 184 newshape1 [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])))]) Source Public Required .false.)}) test_1d_to_nd (FunctionType [(Real 8 [(() ())])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [_lpython_floordiv@__lpython_overloaded_4___lpython_floordiv _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv] [(Var 184 d)] [(= (Var 184 eps) (RealConstant 0.000000 (Real 8 [])) ()) (DoLoop () ((Var 184 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 256 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 255 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 184 block)]) (= (ArrayItem (Var 184 newshape) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 16 (Integer 4 [])) ()) (= (ArrayItem (Var 184 newshape) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 16 (Integer 4 [])) ()) (= (Var 184 a) (ArrayReshape (Var 184 b) (Var 184 newshape) (Real 8 [(() ())]) ()) ()) (DoLoop () ((Var 184 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 184 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (ArrayItem (Var 184 a) [(() (Var 184 i) ()) (() (Var 184 j) ())] (Real 8 []) RowMajor ()) Sub (Cast (IntegerBinOp (Var 184 i) Add (Var 184 j) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) Sub (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 184 eps) (Logical 4 []) ()) ())])]) (= (ArrayItem (Var 184 newshape1) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 16 (Integer 4 [])) ()) (= (ArrayItem (Var 184 newshape1) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 16 (Integer 4 [])) ()) (= (ArrayItem (Var 184 newshape1) [(() (IntegerConstant 2 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 16 (Integer 4 [])) ()) (= (Var 184 c) (ArrayReshape (Var 184 d) (Var 184 newshape1) (Real 8 [(() ())]) ()) ()) (DoLoop () ((Var 184 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 184 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 184 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (ArrayItem (Var 184 c) [(() (Var 184 i) ()) (() (Var 184 j) ()) (() (Var 184 k) ())] (Real 8 []) RowMajor ()) Sub (Cast (IntegerBinOp (IntegerBinOp (Var 184 i) Add (Var 184 j) (Integer 4 []) ()) Add (Var 184 k) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) Sub (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 184 eps) (Logical 4 []) ()) ())])])])] () Public .false. .false.), test_nd_to_1d: (Function (SymbolTable 183 {a: (Variable 183 a [] InOut () () Default (Real 8 [(() ()) (() ())]) Source Public Required .false.), b: (Variable 183 b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 256 (Integer 4 [])))]) Source Public Required .false.), block: (Block (SymbolTable 186 {_lpython_floordiv: (ExternalSymbol 186 _lpython_floordiv 79 _lpython_floordiv lpython_builtin [] _lpython_floordiv Private), _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv: (ExternalSymbol 186 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 79 __lpython_overloaded_4___lpython_floordiv lpython_builtin [] __lpython_overloaded_4___lpython_floordiv Public)}) block [(= (Var 183 i) (FunctionCall 186 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 186 _lpython_floordiv [((Var 183 k)) ((IntegerConstant 16 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 183 j) (IntegerBinOp (Var 183 k) Sub (IntegerBinOp (Var 183 i) Mul (IntegerConstant 16 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (ArrayItem (Var 183 b) [(() (Var 183 k) ())] (Real 8 []) RowMajor ()) Sub (Cast (IntegerBinOp (Var 183 i) Add (Var 183 j) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) Sub (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 183 eps) (Logical 4 []) ()) ())]), block1: (Block (SymbolTable 190 {_lpython_floordiv: (ExternalSymbol 190 _lpython_floordiv 79 _lpython_floordiv lpython_builtin [] _lpython_floordiv Private), _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv: (ExternalSymbol 190 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 79 __lpython_overloaded_4___lpython_floordiv lpython_builtin [] __lpython_overloaded_4___lpython_floordiv Public)}) block1 [(= (Var 183 i) (Cast (Cast (RealBinOp (Cast (Var 183 l) IntegerToReal (Real 8 []) ()) Div (Cast (IntegerConstant 256 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 256.000000 (Real 8 []))) (Real 8 []) ()) RealToInteger (Integer 8 []) ()) IntegerToInteger (Integer 4 []) ()) ()) (= (Var 183 j) (FunctionCall 190 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 190 _lpython_floordiv [((IntegerBinOp (Var 183 l) Sub (IntegerBinOp (Var 183 i) Mul (IntegerConstant 256 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ())) ((IntegerConstant 16 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 183 k) (IntegerBinOp (IntegerBinOp (Var 183 l) Sub (IntegerBinOp (Var 183 i) Mul (IntegerConstant 256 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) Sub (IntegerBinOp (Var 183 j) Mul (IntegerConstant 16 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) ()) (Assert (RealCompare (IntrinsicFunction Abs [(RealBinOp (RealBinOp (ArrayItem (Var 183 d) [(() (Var 183 l) ())] (Real 8 []) RowMajor ()) Sub (Cast (IntegerBinOp (IntegerBinOp (Var 183 i) Add (Var 183 j) (Integer 4 []) ()) Add (Var 183 k) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) (Real 8 []) ()) Sub (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ())] 0 (Real 8 []) ()) LtE (Var 183 eps) (Logical 4 []) ()) ())]), c: (Variable 183 c [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.), d: (Variable 183 d [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4096 (Integer 4 [])))]) Source Public Required .false.), eps: (Variable 183 eps [] Local () () Default (Real 8 []) Source Public Required .false.), i: (Variable 183 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 183 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 183 k [] Local () () Default (Integer 4 []) Source Public Required .false.), l: (Variable 183 l [] Local () () Default (Integer 4 []) Source Public Required .false.), newshape: (Variable 183 newshape [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.), newshape1: (Variable 183 newshape1 [] Local () () Default (Integer 4 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])))]) Source Public Required .false.)}) test_nd_to_1d (FunctionType [(Real 8 [(() ()) (() ())])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [_lpython_floordiv@__lpython_overloaded_4___lpython_floordiv _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv] [(Var 183 a)] [(= (Var 183 eps) (RealConstant 0.000000 (Real 8 [])) ()) (= (ArrayItem (Var 183 newshape) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 256 (Integer 4 [])) ()) (= (Var 183 b) (ArrayReshape (Var 183 a) (Var 183 newshape) (Real 8 [(() ())]) ()) ()) (DoLoop () ((Var 183 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 256 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 255 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 183 block)]) (DoLoop () ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 183 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 183 k) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 183 c) [(() (Var 183 i) ()) (() (Var 183 j) ()) (() (Var 183 k) ())] (Real 8 []) RowMajor ()) (RealBinOp (Cast (IntegerBinOp (IntegerBinOp (Var 183 i) Add (Var 183 j) (Integer 4 []) ()) Add (Var 183 k) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) Add (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ()) ())])])]) (= (ArrayItem (Var 183 newshape1) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Integer 4 []) RowMajor ()) (IntegerConstant 4096 (Integer 4 [])) ()) (= (Var 183 d) (ArrayReshape (Var 183 c) (Var 183 newshape1) (Real 8 [(() ())]) ()) ()) (DoLoop () ((Var 183 l) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 4096 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 4095 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 183 block1)])] () Public .false. .false.), test_reshape_with_argument: (Function (SymbolTable 185 {a: (Variable 185 a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 []))) ((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])))]) Source Public Required .false.), block: (Block (SymbolTable 199 {_lpython_floordiv: (ExternalSymbol 199 _lpython_floordiv 79 _lpython_floordiv lpython_builtin [] _lpython_floordiv Private), _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv: (ExternalSymbol 199 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 79 __lpython_overloaded_4___lpython_floordiv lpython_builtin [] __lpython_overloaded_4___lpython_floordiv Public)}) block [(= (Var 185 i) (Cast (Cast (RealBinOp (Cast (Var 185 l) IntegerToReal (Real 8 []) ()) Div (Cast (IntegerConstant 256 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 256.000000 (Real 8 []))) (Real 8 []) ()) RealToInteger (Integer 8 []) ()) IntegerToInteger (Integer 4 []) ()) ()) (= (Var 185 j) (FunctionCall 199 _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv 199 _lpython_floordiv [((IntegerBinOp (Var 185 l) Sub (IntegerBinOp (Var 185 i) Mul (IntegerConstant 256 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ())) ((IntegerConstant 16 (Integer 4 [])))] (Integer 4 []) () ()) ()) (= (Var 185 k) (IntegerBinOp (IntegerBinOp (Var 185 l) Sub (IntegerBinOp (Var 185 i) Mul (IntegerConstant 256 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) Sub (IntegerBinOp (Var 185 j) Mul (IntegerConstant 16 (Integer 4 [])) (Integer 4 []) ()) (Integer 4 []) ()) ()) (= (ArrayItem (Var 185 d) [(() (Var 185 l) ())] (Real 8 []) RowMajor ()) (RealBinOp (Cast (IntegerBinOp (IntegerBinOp (Var 185 i) Add (Var 185 j) (Integer 4 []) ()) Add (Var 185 k) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) Add (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ()) ())]), d: (Variable 185 d [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 4096 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 185 i [] Local () () Default (Integer 4 []) Source Public Required .false.), j: (Variable 185 j [] Local () () Default (Integer 4 []) Source Public Required .false.), k: (Variable 185 k [] Local () () Default (Integer 4 []) Source Public Required .false.), l: (Variable 185 l [] Local () () Default (Integer 4 []) Source Public Required .false.)}) test_reshape_with_argument (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [_lpython_floordiv@__lpython_overloaded_4___lpython_floordiv test_nd_to_1d _lpython_floordiv@__lpython_overloaded_4___lpython_floordiv test_1d_to_nd] [] [(DoLoop () ((Var 185 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(DoLoop () ((Var 185 j) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 16 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 15 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 185 a) [(() (Var 185 i) ()) (() (Var 185 j) ())] (Real 8 []) RowMajor ()) (RealBinOp (Cast (IntegerBinOp (Var 185 i) Add (Var 185 j) (Integer 4 []) ()) IntegerToReal (Real 8 []) ()) Add (RealConstant 0.500000 (Real 8 [])) (Real 8 []) ()) ())])]) (SubroutineCall 202 test_nd_to_1d () [((Var 185 a))] ()) (DoLoop () ((Var 185 l) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 4096 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 4095 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(BlockCall -1 185 block)]) (SubroutineCall 202 test_1d_to_nd () [((Var 185 d))] ())] () Public .false. .false.)}) _global_symbols [lpython_builtin] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 200 {_lpython_main_program: (ExternalSymbol 200 _lpython_main_program 202 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 200 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) diff --git a/tests/reference/asr-vec_01-66ac423.json b/tests/reference/asr-vec_01-66ac423.json index d716f8ff99..667d5607c8 100644 --- a/tests/reference/asr-vec_01-66ac423.json +++ b/tests/reference/asr-vec_01-66ac423.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "asr-vec_01-66ac423.stdout", - "stdout_hash": "b8d5980412a52485482e2f973845f637f1c8dc9f30cae7188c0e7861", + "stdout_hash": "7d787d16892be7842eddb242d3e5e68f3371d41f194010dadb8bf7dd", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-vec_01-66ac423.stdout b/tests/reference/asr-vec_01-66ac423.stdout index d1e2ecfe50..dad8df03bd 100644 --- a/tests/reference/asr-vec_01-66ac423.stdout +++ b/tests/reference/asr-vec_01-66ac423.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 189 {_lpython_main_program: (Function (SymbolTable 188 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [loop_vec] [] [(SubroutineCall 189 loop_vec () [] ())] () Public .false. .false.), loop_vec: (Function (SymbolTable 183 {a: (Variable 183 a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), b: (Variable 183 b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 183 i [] Local () () Default (Integer 4 []) Source Public Required .false.)}) loop_vec (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(DoLoop ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 9216 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9215 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 183 b) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) (RealConstant 5.000000 (Real 8 [])) ())]) (DoLoop ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 9216 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9215 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 183 a) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) (ArrayItem (Var 183 b) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) ())]) (DoLoop ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 9216 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9215 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (ArrayItem (Var 183 a) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) Eq (RealConstant 5.000000 (Real 8 [])) (Logical 4 []) ()) ())])] () Public .false. .false.)}) _global_symbols [] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 187 {_lpython_main_program: (ExternalSymbol 187 _lpython_main_program 189 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 187 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 189 {_lpython_main_program: (Function (SymbolTable 188 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [loop_vec] [] [(SubroutineCall 189 loop_vec () [] ())] () Public .false. .false.), loop_vec: (Function (SymbolTable 183 {a: (Variable 183 a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), b: (Variable 183 b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 183 i [] Local () () Default (Integer 4 []) Source Public Required .false.)}) loop_vec (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(DoLoop () ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 9216 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9215 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 183 b) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) (RealConstant 5.000000 (Real 8 [])) ())]) (DoLoop () ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 9216 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9215 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 183 a) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) (ArrayItem (Var 183 b) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) ())]) (DoLoop () ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 9216 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9215 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (ArrayItem (Var 183 a) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) Eq (RealConstant 5.000000 (Real 8 [])) (Logical 4 []) ()) ())])] () Public .false. .false.)}) _global_symbols [] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 187 {_lpython_main_program: (ExternalSymbol 187 _lpython_main_program 189 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 187 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) diff --git a/tests/reference/pass_loop_vectorise-vec_01-be9985e.json b/tests/reference/pass_loop_vectorise-vec_01-be9985e.json index e10ae2ee63..a59c177d47 100644 --- a/tests/reference/pass_loop_vectorise-vec_01-be9985e.json +++ b/tests/reference/pass_loop_vectorise-vec_01-be9985e.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "pass_loop_vectorise-vec_01-be9985e.stdout", - "stdout_hash": "899d52d4e331cac3becd88e8515fb5521ace18e3940f7d9e0cba3e90", + "stdout_hash": "4a150f946c886254484181d91bc6b18c96693d6d228cbbba7fdc789c", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/pass_loop_vectorise-vec_01-be9985e.stdout b/tests/reference/pass_loop_vectorise-vec_01-be9985e.stdout index bd45eac3d1..ffbdbcebf4 100644 --- a/tests/reference/pass_loop_vectorise-vec_01-be9985e.stdout +++ b/tests/reference/pass_loop_vectorise-vec_01-be9985e.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 189 {_lpython_main_program: (Function (SymbolTable 188 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [loop_vec] [] [(SubroutineCall 189 loop_vec () [] ())] () Public .false. .false.), loop_vec: (Function (SymbolTable 183 {a: (Variable 183 a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), b: (Variable 183 b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 183 i [] Local () () Default (Integer 4 []) Source Public Required .false.), vector_copy_f64f64i32@IntrinsicOptimization: (Function (SymbolTable 190 {__1_k: (Variable 190 __1_k [] Local () () Default (Integer 4 []) Source Public Required .false.), arg0: (Variable 190 arg0 [] In () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), arg1: (Variable 190 arg1 [] In () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), arg2: (Variable 190 arg2 [] In () () Default (Integer 4 []) Source Public Required .false.), arg3: (Variable 190 arg3 [] In () () Default (Integer 4 []) Source Public Required .false.), arg4: (Variable 190 arg4 [] In () () Default (Integer 4 []) Source Public Required .false.), arg5: (Variable 190 arg5 [] In () () Default (Integer 4 []) Source Public Required .false.)}) vector_copy_f64f64i32@IntrinsicOptimization (FunctionType [(Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) (Integer 4 []) (Integer 4 []) (Integer 4 []) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 190 arg0) (Var 190 arg1) (Var 190 arg2) (Var 190 arg3) (Var 190 arg4) (Var 190 arg5)] [(= (Var 190 __1_k) (IntegerBinOp (Var 190 arg2) Sub (Var 190 arg4) (Integer 4 []) ()) ()) (WhileLoop (IntegerCompare (IntegerBinOp (Var 190 __1_k) Add (Var 190 arg4) (Integer 4 []) ()) Lt (Var 190 arg3) (Logical 4 []) ()) [(= (Var 190 __1_k) (IntegerBinOp (Var 190 __1_k) Add (Var 190 arg4) (Integer 4 []) ()) ()) (= (ArrayItem (Var 190 arg0) [(() (Var 190 __1_k) ())] (Real 8 []) RowMajor ()) (ArrayItem (Var 190 arg1) [(() (Var 190 __1_k) ())] (Real 8 []) RowMajor ()) ())])] () Public .false. .false.)}) loop_vec (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [vector_copy_f64f64i32@IntrinsicOptimization] [] [(DoLoop ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 9216 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9215 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 183 b) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) (RealConstant 5.000000 (Real 8 [])) ())]) (DoLoop ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1151 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) [(SubroutineCall 183 vector_copy_f64f64i32@IntrinsicOptimization () [((Var 183 a)) ((Var 183 b)) ((IntegerBinOp (Var 183 i) Mul (IntegerConstant 8 (Integer 4 [])) (Integer 4 []) ())) ((IntegerBinOp (IntegerBinOp (Var 183 i) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) Mul (IntegerConstant 8 (Integer 4 [])) (Integer 4 []) ())) ((IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 8 (Integer 4 [])))] ())]) (DoLoop ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 9216 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9215 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (ArrayItem (Var 183 a) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) Eq (RealConstant 5.000000 (Real 8 [])) (Logical 4 []) ()) ())])] () Public .false. .false.)}) _global_symbols [] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 187 {_lpython_main_program: (ExternalSymbol 187 _lpython_main_program 189 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 187 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 189 {_lpython_main_program: (Function (SymbolTable 188 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [loop_vec] [] [(SubroutineCall 189 loop_vec () [] ())] () Public .false. .false.), loop_vec: (Function (SymbolTable 183 {a: (Variable 183 a [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), b: (Variable 183 b [] Local () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), i: (Variable 183 i [] Local () () Default (Integer 4 []) Source Public Required .false.), vector_copy_f64f64i32@IntrinsicOptimization: (Function (SymbolTable 190 {__1_k: (Variable 190 __1_k [] Local () () Default (Integer 4 []) Source Public Required .false.), arg0: (Variable 190 arg0 [] In () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), arg1: (Variable 190 arg1 [] In () () Default (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) Source Public Required .false.), arg2: (Variable 190 arg2 [] In () () Default (Integer 4 []) Source Public Required .false.), arg3: (Variable 190 arg3 [] In () () Default (Integer 4 []) Source Public Required .false.), arg4: (Variable 190 arg4 [] In () () Default (Integer 4 []) Source Public Required .false.), arg5: (Variable 190 arg5 [] In () () Default (Integer 4 []) Source Public Required .false.)}) vector_copy_f64f64i32@IntrinsicOptimization (FunctionType [(Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) (Real 8 [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 9216 (Integer 4 [])))]) (Integer 4 []) (Integer 4 []) (Integer 4 []) (Integer 4 [])] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 190 arg0) (Var 190 arg1) (Var 190 arg2) (Var 190 arg3) (Var 190 arg4) (Var 190 arg5)] [(= (Var 190 __1_k) (IntegerBinOp (Var 190 arg2) Sub (Var 190 arg4) (Integer 4 []) ()) ()) (WhileLoop () (IntegerCompare (IntegerBinOp (Var 190 __1_k) Add (Var 190 arg4) (Integer 4 []) ()) Lt (Var 190 arg3) (Logical 4 []) ()) [(= (Var 190 __1_k) (IntegerBinOp (Var 190 __1_k) Add (Var 190 arg4) (Integer 4 []) ()) ()) (= (ArrayItem (Var 190 arg0) [(() (Var 190 __1_k) ())] (Real 8 []) RowMajor ()) (ArrayItem (Var 190 arg1) [(() (Var 190 __1_k) ())] (Real 8 []) RowMajor ()) ())])] () Public .false. .false.)}) loop_vec (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [vector_copy_f64f64i32@IntrinsicOptimization] [] [(DoLoop () ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 9216 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9215 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(= (ArrayItem (Var 183 b) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) (RealConstant 5.000000 (Real 8 [])) ())]) (DoLoop () ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1151 (Integer 4 [])) (IntegerConstant 1 (Integer 4 []))) [(SubroutineCall 183 vector_copy_f64f64i32@IntrinsicOptimization () [((Var 183 a)) ((Var 183 b)) ((IntegerBinOp (Var 183 i) Mul (IntegerConstant 8 (Integer 4 [])) (Integer 4 []) ())) ((IntegerBinOp (IntegerBinOp (Var 183 i) Add (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) Mul (IntegerConstant 8 (Integer 4 [])) (Integer 4 []) ())) ((IntegerConstant 1 (Integer 4 []))) ((IntegerConstant 8 (Integer 4 [])))] ())]) (DoLoop () ((Var 183 i) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (IntegerConstant 9216 (Integer 4 [])) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant 9215 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))) [(Assert (RealCompare (ArrayItem (Var 183 a) [(() (Var 183 i) ())] (Real 8 []) RowMajor ()) Eq (RealConstant 5.000000 (Real 8 [])) (Logical 4 []) ()) ())])] () Public .false. .false.)}) _global_symbols [] .false. .false.), lpython_builtin: (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable 187 {_lpython_main_program: (ExternalSymbol 187 _lpython_main_program 189 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 187 _lpython_main_program () [] ())]), numpy: (Module (SymbolTable 3 {__lpython_overloaded_0__arccos: (Function (SymbolTable 41 {_lpython_return_variable: (Variable 41 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 41 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacos] [(Var 41 x)] [(= (Var 41 _lpython_return_variable) (FunctionCall 3 _lfortran_dacos () [((Var 41 x))] (Real 8 []) () ()) ()) (Return)] (Var 41 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arccosh: (Function (SymbolTable 65 {_lpython_return_variable: (Variable 65 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 65 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arccosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dacosh] [(Var 65 x)] [(= (Var 65 _lpython_return_variable) (FunctionCall 3 _lfortran_dacosh () [((Var 65 x))] (Real 8 []) () ()) ()) (Return)] (Var 65 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsin: (Function (SymbolTable 37 {_lpython_return_variable: (Variable 37 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 37 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasin] [(Var 37 x)] [(= (Var 37 _lpython_return_variable) (FunctionCall 3 _lfortran_dasin () [((Var 37 x))] (Real 8 []) () ()) ()) (Return)] (Var 37 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arcsinh: (Function (SymbolTable 61 {_lpython_return_variable: (Variable 61 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 61 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arcsinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dasinh] [(Var 61 x)] [(= (Var 61 _lpython_return_variable) (FunctionCall 3 _lfortran_dasinh () [((Var 61 x))] (Real 8 []) () ()) ()) (Return)] (Var 61 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctan: (Function (SymbolTable 53 {_lpython_return_variable: (Variable 53 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 53 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datan] [(Var 53 x)] [(= (Var 53 _lpython_return_variable) (FunctionCall 3 _lfortran_datan () [((Var 53 x))] (Real 8 []) () ()) ()) (Return)] (Var 53 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__arctanh: (Function (SymbolTable 69 {_lpython_return_variable: (Variable 69 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 69 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__arctanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_datanh] [(Var 69 x)] [(= (Var 69 _lpython_return_variable) (FunctionCall 3 _lfortran_datanh () [((Var 69 x))] (Real 8 []) () ()) ()) (Return)] (Var 69 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__ceil: (Function (SymbolTable 76 {_lpython_return_variable: (Variable 76 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 76 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 76 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__ceil (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 76 x)] [(= (Var 76 result) (Cast (Var 76 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 76 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 76 x) Eq (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 76 _lpython_return_variable) (Cast (Var 76 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 76 _lpython_return_variable) (Cast (IntegerBinOp (Var 76 result) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 76 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cos: (Function (SymbolTable 9 {_lpython_return_variable: (Variable 9 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 9 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cos (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcos] [(Var 9 x)] [(= (Var 9 _lpython_return_variable) (FunctionCall 3 _lfortran_dcos () [((Var 9 x))] (Real 8 []) () ()) ()) (Return)] (Var 9 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__cosh: (Function (SymbolTable 23 {_lpython_return_variable: (Variable 23 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 23 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__cosh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dcosh] [(Var 23 x)] [(= (Var 23 _lpython_return_variable) (FunctionCall 3 _lfortran_dcosh () [((Var 23 x))] (Real 8 []) () ()) ()) (Return)] (Var 23 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__degrees: (Function (SymbolTable 56 {_lpython_return_variable: (Variable 56 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 56 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__degrees (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 56 x)] [(= (Var 56 _lpython_return_variable) (RealBinOp (RealBinOp (Var 56 x) Mul (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) Div (Var 3 pi_64) (Real 8 []) ()) ()) (Return)] (Var 56 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__exp: (Function (SymbolTable 49 {_lpython_return_variable: (Variable 49 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 49 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__exp (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dexp] [(Var 49 x)] [(= (Var 49 _lpython_return_variable) (FunctionCall 3 _lfortran_dexp () [((Var 49 x))] (Real 8 []) () ()) ()) (Return)] (Var 49 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__floor: (Function (SymbolTable 74 {_lpython_return_variable: (Variable 74 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), result: (Variable 74 result [] Local () () Default (Integer 8 []) Source Public Required .false.), x: (Variable 74 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__floor (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 74 x)] [(= (Var 74 result) (Cast (Var 74 x) RealToInteger (Integer 8 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 74 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 0.000000 (Real 8 []))) (Logical 4 []) ()) Or (RealCompare (Var 74 x) Eq (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 74 _lpython_return_variable) (Cast (Var 74 result) IntegerToReal (Real 8 []) ()) ()) (Return)] []) (= (Var 74 _lpython_return_variable) (Cast (IntegerBinOp (Var 74 result) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 1 (Integer 8 []))) (Integer 8 []) ()) IntegerToReal (Real 8 []) ()) ()) (Return)] (Var 74 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log: (Function (SymbolTable 27 {_lpython_return_variable: (Variable 27 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 27 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog] [(Var 27 x)] [(= (Var 27 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog () [((Var 27 x))] (Real 8 []) () ()) ()) (Return)] (Var 27 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log10: (Function (SymbolTable 31 {_lpython_return_variable: (Variable 31 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 31 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log10 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog10] [(Var 31 x)] [(= (Var 31 _lpython_return_variable) (FunctionCall 3 _lfortran_dlog10 () [((Var 31 x))] (Real 8 []) () ()) ()) (Return)] (Var 31 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__log2: (Function (SymbolTable 34 {_lpython_return_variable: (Variable 34 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 34 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__log2 (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dlog _lfortran_dlog] [(Var 34 x)] [(= (Var 34 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_dlog () [((Var 34 x))] (Real 8 []) () ()) Div (FunctionCall 3 _lfortran_dlog () [((RealConstant 2.000000 (Real 8 [])))] (Real 8 []) () ()) (Real 8 []) ()) ()) (Return)] (Var 34 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__mod: (Function (SymbolTable 72 {_lpython_return_variable: (Variable 72 _lpython_return_variable [] ReturnVar () () Default (Integer 8 []) Source Public Required .false.), _mod: (ExternalSymbol 72 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_4___mod: (ExternalSymbol 72 _mod@__lpython_overloaded_4___mod 79 __lpython_overloaded_4___mod lpython_builtin [] __lpython_overloaded_4___mod Public), x1: (Variable 72 x1 [] In () () Default (Integer 8 []) Source Public Required .false.), x2: (Variable 72 x2 [] In () () Default (Integer 8 []) Source Public Required .false.)}) __lpython_overloaded_0__mod (FunctionType [(Integer 8 []) (Integer 8 [])] (Integer 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_4___mod] [(Var 72 x1) (Var 72 x2)] [(If (IntegerCompare (Var 72 x2) Eq (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) (Logical 4 []) ()) [(= (Var 72 _lpython_return_variable) (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToInteger (Integer 8 []) (IntegerConstant 0 (Integer 8 []))) ()) (Return)] []) (= (Var 72 _lpython_return_variable) (FunctionCall 72 _mod@__lpython_overloaded_4___mod 72 _mod [((Var 72 x1)) ((Var 72 x2))] (Integer 8 []) () ()) ()) (Return)] (Var 72 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__radians: (Function (SymbolTable 58 {_lpython_return_variable: (Variable 58 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 58 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__radians (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 58 x)] [(= (Var 58 _lpython_return_variable) (RealBinOp (RealBinOp (Var 58 x) Mul (Var 3 pi_64) (Real 8 []) ()) Div (RealConstant 180.000000 (Real 8 [])) (Real 8 []) ()) ()) (Return)] (Var 58 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sin: (Function (SymbolTable 5 {_lpython_return_variable: (Variable 5 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 5 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sin (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsin] [(Var 5 x)] [(= (Var 5 _lpython_return_variable) (FunctionCall 3 _lfortran_dsin () [((Var 5 x))] (Real 8 []) () ()) ()) (Return)] (Var 5 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sinh: (Function (SymbolTable 19 {_lpython_return_variable: (Variable 19 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 19 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sinh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dsinh] [(Var 19 x)] [(= (Var 19 _lpython_return_variable) (FunctionCall 3 _lfortran_dsinh () [((Var 19 x))] (Real 8 []) () ()) ()) (Return)] (Var 19 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__sqrt: (Function (SymbolTable 12 {_lpython_return_variable: (Variable 12 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 12 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__sqrt (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 12 x)] [(= (Var 12 _lpython_return_variable) (RealBinOp (Var 12 x) Pow (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) (Real 8 []) ()) ()) (Return)] (Var 12 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tan: (Function (SymbolTable 15 {_lpython_return_variable: (Variable 15 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 15 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tan (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtan] [(Var 15 x)] [(= (Var 15 _lpython_return_variable) (FunctionCall 3 _lfortran_dtan () [((Var 15 x))] (Real 8 []) () ()) ()) (Return)] (Var 15 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_0__tanh: (Function (SymbolTable 45 {_lpython_return_variable: (Variable 45 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) Source Public Required .false.), x: (Variable 45 x [] In () () Default (Real 8 []) Source Public Required .false.)}) __lpython_overloaded_0__tanh (FunctionType [(Real 8 [])] (Real 8 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_dtanh] [(Var 45 x)] [(= (Var 45 _lpython_return_variable) (FunctionCall 3 _lfortran_dtanh () [((Var 45 x))] (Real 8 []) () ()) ()) (Return)] (Var 45 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccos: (Function (SymbolTable 43 {_lpython_return_variable: (Variable 43 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 43 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacos] [(Var 43 x)] [(= (Var 43 _lpython_return_variable) (FunctionCall 3 _lfortran_sacos () [((Var 43 x))] (Real 4 []) () ()) ()) (Return)] (Var 43 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arccosh: (Function (SymbolTable 67 {_lpython_return_variable: (Variable 67 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 67 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arccosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sacosh] [(Var 67 x)] [(= (Var 67 _lpython_return_variable) (FunctionCall 3 _lfortran_sacosh () [((Var 67 x))] (Real 4 []) () ()) ()) (Return)] (Var 67 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsin: (Function (SymbolTable 39 {_lpython_return_variable: (Variable 39 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 39 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasin] [(Var 39 x)] [(= (Var 39 _lpython_return_variable) (FunctionCall 3 _lfortran_sasin () [((Var 39 x))] (Real 4 []) () ()) ()) (Return)] (Var 39 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arcsinh: (Function (SymbolTable 63 {_lpython_return_variable: (Variable 63 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 63 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arcsinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sasinh] [(Var 63 x)] [(= (Var 63 _lpython_return_variable) (FunctionCall 3 _lfortran_sasinh () [((Var 63 x))] (Real 4 []) () ()) ()) (Return)] (Var 63 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctan: (Function (SymbolTable 55 {_lpython_return_variable: (Variable 55 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 55 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satan] [(Var 55 x)] [(= (Var 55 _lpython_return_variable) (FunctionCall 3 _lfortran_satan () [((Var 55 x))] (Real 4 []) () ()) ()) (Return)] (Var 55 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__arctanh: (Function (SymbolTable 71 {_lpython_return_variable: (Variable 71 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 71 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__arctanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_satanh] [(Var 71 x)] [(= (Var 71 _lpython_return_variable) (FunctionCall 3 _lfortran_satanh () [((Var 71 x))] (Real 4 []) () ()) ()) (Return)] (Var 71 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__ceil: (Function (SymbolTable 77 {_lpython_return_variable: (Variable 77 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 77 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 77 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__ceil (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 77 x)] [(= (Var 77 resultf) (Cast (Cast (Var 77 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 77 x) LtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 77 x) Eq (Var 77 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 77 _lpython_return_variable) (Var 77 resultf) ()) (Return)] []) (= (Var 77 _lpython_return_variable) (RealBinOp (Var 77 resultf) Add (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 77 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cos: (Function (SymbolTable 11 {_lpython_return_variable: (Variable 11 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 11 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cos (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scos] [(Var 11 x)] [(= (Var 11 _lpython_return_variable) (FunctionCall 3 _lfortran_scos () [((Var 11 x))] (Real 4 []) () ()) ()) (Return)] (Var 11 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__cosh: (Function (SymbolTable 25 {_lpython_return_variable: (Variable 25 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 25 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__cosh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_scosh] [(Var 25 x)] [(= (Var 25 _lpython_return_variable) (FunctionCall 3 _lfortran_scosh () [((Var 25 x))] (Real 4 []) () ()) ()) (Return)] (Var 25 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__degrees: (Function (SymbolTable 57 {_lpython_return_variable: (Variable 57 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 57 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__degrees (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 57 x)] [(= (Var 57 _lpython_return_variable) (RealBinOp (Var 57 x) Mul (RealBinOp (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) Div (Var 3 pi_32) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 57 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__exp: (Function (SymbolTable 51 {_lpython_return_variable: (Variable 51 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 51 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__exp (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_sexp] [(Var 51 x)] [(= (Var 51 _lpython_return_variable) (FunctionCall 3 _lfortran_sexp () [((Var 51 x))] (Real 4 []) () ()) ()) (Return)] (Var 51 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__floor: (Function (SymbolTable 75 {_lpython_return_variable: (Variable 75 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), resultf: (Variable 75 resultf [] Local () () Default (Real 4 []) Source Public Required .false.), x: (Variable 75 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__floor (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 75 x)] [(= (Var 75 resultf) (Cast (Cast (Var 75 x) RealToInteger (Integer 4 []) ()) IntegerToReal (Real 4 []) ()) ()) (If (LogicalBinOp (RealCompare (Var 75 x) GtE (Cast (IntegerConstant 0 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 0.000000 (Real 4 []))) (Logical 4 []) ()) Or (RealCompare (Var 75 x) Eq (Var 75 resultf) (Logical 4 []) ()) (Logical 4 []) ()) [(= (Var 75 _lpython_return_variable) (Var 75 resultf) ()) (Return)] []) (= (Var 75 _lpython_return_variable) (RealBinOp (Var 75 resultf) Sub (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 1.000000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 75 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log: (Function (SymbolTable 29 {_lpython_return_variable: (Variable 29 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 29 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog] [(Var 29 x)] [(= (Var 29 _lpython_return_variable) (FunctionCall 3 _lfortran_slog () [((Var 29 x))] (Real 4 []) () ()) ()) (Return)] (Var 29 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log10: (Function (SymbolTable 33 {_lpython_return_variable: (Variable 33 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 33 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log10 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog10] [(Var 33 x)] [(= (Var 33 _lpython_return_variable) (FunctionCall 3 _lfortran_slog10 () [((Var 33 x))] (Real 4 []) () ()) ()) (Return)] (Var 33 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__log2: (Function (SymbolTable 35 {_lpython_return_variable: (Variable 35 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 35 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__log2 (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_slog _lfortran_slog] [(Var 35 x)] [(= (Var 35 _lpython_return_variable) (RealBinOp (FunctionCall 3 _lfortran_slog () [((Var 35 x))] (Real 4 []) () ()) Div (FunctionCall 3 _lfortran_slog () [((Cast (RealConstant 2.000000 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 2.000000 (Real 4 []))))] (Real 4 []) () ()) (Real 4 []) ()) ()) (Return)] (Var 35 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__mod: (Function (SymbolTable 73 {_lpython_return_variable: (Variable 73 _lpython_return_variable [] ReturnVar () () Default (Integer 4 []) Source Public Required .false.), _mod: (ExternalSymbol 73 _mod 79 _mod lpython_builtin [] _mod Private), _mod@__lpython_overloaded_2___mod: (ExternalSymbol 73 _mod@__lpython_overloaded_2___mod 79 __lpython_overloaded_2___mod lpython_builtin [] __lpython_overloaded_2___mod Public), x1: (Variable 73 x1 [] In () () Default (Integer 4 []) Source Public Required .false.), x2: (Variable 73 x2 [] In () () Default (Integer 4 []) Source Public Required .false.)}) __lpython_overloaded_1__mod (FunctionType [(Integer 4 []) (Integer 4 [])] (Integer 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_mod@__lpython_overloaded_2___mod] [(Var 73 x1) (Var 73 x2)] [(If (IntegerCompare (Var 73 x2) Eq (IntegerConstant 0 (Integer 4 [])) (Logical 4 []) ()) [(= (Var 73 _lpython_return_variable) (IntegerConstant 0 (Integer 4 [])) ()) (Return)] []) (= (Var 73 _lpython_return_variable) (FunctionCall 73 _mod@__lpython_overloaded_2___mod 73 _mod [((Var 73 x1)) ((Var 73 x2))] (Integer 4 []) () ()) ()) (Return)] (Var 73 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__radians: (Function (SymbolTable 59 {_lpython_return_variable: (Variable 59 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 59 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__radians (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 59 x)] [(= (Var 59 _lpython_return_variable) (RealBinOp (Var 59 x) Mul (RealBinOp (Var 3 pi_32) Div (Cast (IntegerConstant 180 (Integer 4 [])) IntegerToReal (Real 4 []) (RealConstant 180.000000 (Real 4 []))) (Real 4 []) ()) (Real 4 []) ()) ()) (Return)] (Var 59 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sin: (Function (SymbolTable 7 {_lpython_return_variable: (Variable 7 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 7 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sin (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssin] [(Var 7 x)] [(= (Var 7 _lpython_return_variable) (FunctionCall 3 _lfortran_ssin () [((Var 7 x))] (Real 4 []) () ()) ()) (Return)] (Var 7 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sinh: (Function (SymbolTable 21 {_lpython_return_variable: (Variable 21 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 21 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sinh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_ssinh] [(Var 21 x)] [(= (Var 21 _lpython_return_variable) (FunctionCall 3 _lfortran_ssinh () [((Var 21 x))] (Real 4 []) () ()) ()) (Return)] (Var 21 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__sqrt: (Function (SymbolTable 13 {_lpython_return_variable: (Variable 13 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 13 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__sqrt (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [] [(Var 13 x)] [(= (Var 13 _lpython_return_variable) (RealBinOp (Var 13 x) Pow (Cast (RealBinOp (Cast (IntegerConstant 1 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 1.000000 (Real 8 []))) Div (Cast (IntegerConstant 2 (Integer 4 [])) IntegerToReal (Real 8 []) (RealConstant 2.000000 (Real 8 []))) (Real 8 []) (RealConstant 0.500000 (Real 8 []))) RealToReal (Real 4 []) (RealConstant 0.500000 (Real 4 []))) (Real 4 []) ()) ()) (Return)] (Var 13 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tan: (Function (SymbolTable 17 {_lpython_return_variable: (Variable 17 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 17 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tan (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stan] [(Var 17 x)] [(= (Var 17 _lpython_return_variable) (FunctionCall 3 _lfortran_stan () [((Var 17 x))] (Real 4 []) () ()) ()) (Return)] (Var 17 _lpython_return_variable) Public .false. .false.), __lpython_overloaded_1__tanh: (Function (SymbolTable 47 {_lpython_return_variable: (Variable 47 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) Source Public Required .false.), x: (Variable 47 x [] In () () Default (Real 4 []) Source Public Required .false.)}) __lpython_overloaded_1__tanh (FunctionType [(Real 4 [])] (Real 4 []) Source Implementation () .true. .false. .false. .false. .false. [] [] .false.) [_lfortran_stanh] [(Var 47 x)] [(= (Var 47 _lpython_return_variable) (FunctionCall 3 _lfortran_stanh () [((Var 47 x))] (Real 4 []) () ()) ()) (Return)] (Var 47 _lpython_return_variable) Public .false. .false.), _lfortran_dacos: (Function (SymbolTable 40 {_lpython_return_variable: (Variable 40 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 40 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 40 x)] [] (Var 40 _lpython_return_variable) Public .false. .false.), _lfortran_dacosh: (Function (SymbolTable 64 {_lpython_return_variable: (Variable 64 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 64 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dacosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 64 x)] [] (Var 64 _lpython_return_variable) Public .false. .false.), _lfortran_dasin: (Function (SymbolTable 36 {_lpython_return_variable: (Variable 36 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 36 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 36 x)] [] (Var 36 _lpython_return_variable) Public .false. .false.), _lfortran_dasinh: (Function (SymbolTable 60 {_lpython_return_variable: (Variable 60 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 60 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dasinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 60 x)] [] (Var 60 _lpython_return_variable) Public .false. .false.), _lfortran_datan: (Function (SymbolTable 52 {_lpython_return_variable: (Variable 52 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 52 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 52 x)] [] (Var 52 _lpython_return_variable) Public .false. .false.), _lfortran_datanh: (Function (SymbolTable 68 {_lpython_return_variable: (Variable 68 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 68 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_datanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 68 x)] [] (Var 68 _lpython_return_variable) Public .false. .false.), _lfortran_dcos: (Function (SymbolTable 8 {_lpython_return_variable: (Variable 8 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 8 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcos (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 8 x)] [] (Var 8 _lpython_return_variable) Public .false. .false.), _lfortran_dcosh: (Function (SymbolTable 22 {_lpython_return_variable: (Variable 22 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 22 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dcosh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 22 x)] [] (Var 22 _lpython_return_variable) Public .false. .false.), _lfortran_dexp: (Function (SymbolTable 48 {_lpython_return_variable: (Variable 48 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 48 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dexp (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 48 x)] [] (Var 48 _lpython_return_variable) Public .false. .false.), _lfortran_dlog: (Function (SymbolTable 26 {_lpython_return_variable: (Variable 26 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 26 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 26 x)] [] (Var 26 _lpython_return_variable) Public .false. .false.), _lfortran_dlog10: (Function (SymbolTable 30 {_lpython_return_variable: (Variable 30 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 30 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dlog10 (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 30 x)] [] (Var 30 _lpython_return_variable) Public .false. .false.), _lfortran_dsin: (Function (SymbolTable 4 {_lpython_return_variable: (Variable 4 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 4 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsin (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 4 x)] [] (Var 4 _lpython_return_variable) Public .false. .false.), _lfortran_dsinh: (Function (SymbolTable 18 {_lpython_return_variable: (Variable 18 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 18 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dsinh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 18 x)] [] (Var 18 _lpython_return_variable) Public .false. .false.), _lfortran_dtan: (Function (SymbolTable 14 {_lpython_return_variable: (Variable 14 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 14 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtan (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 14 x)] [] (Var 14 _lpython_return_variable) Public .false. .false.), _lfortran_dtanh: (Function (SymbolTable 44 {_lpython_return_variable: (Variable 44 _lpython_return_variable [] ReturnVar () () Default (Real 8 []) BindC Public Required .false.), x: (Variable 44 x [] In () () Default (Real 8 []) BindC Public Required .true.)}) _lfortran_dtanh (FunctionType [(Real 8 [])] (Real 8 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 44 x)] [] (Var 44 _lpython_return_variable) Public .false. .false.), _lfortran_sacos: (Function (SymbolTable 42 {_lpython_return_variable: (Variable 42 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 42 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 42 x)] [] (Var 42 _lpython_return_variable) Public .false. .false.), _lfortran_sacosh: (Function (SymbolTable 66 {_lpython_return_variable: (Variable 66 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 66 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sacosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 66 x)] [] (Var 66 _lpython_return_variable) Public .false. .false.), _lfortran_sasin: (Function (SymbolTable 38 {_lpython_return_variable: (Variable 38 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 38 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 38 x)] [] (Var 38 _lpython_return_variable) Public .false. .false.), _lfortran_sasinh: (Function (SymbolTable 62 {_lpython_return_variable: (Variable 62 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 62 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sasinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 62 x)] [] (Var 62 _lpython_return_variable) Public .false. .false.), _lfortran_satan: (Function (SymbolTable 54 {_lpython_return_variable: (Variable 54 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 54 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 54 x)] [] (Var 54 _lpython_return_variable) Public .false. .false.), _lfortran_satanh: (Function (SymbolTable 70 {_lpython_return_variable: (Variable 70 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 70 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_satanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 70 x)] [] (Var 70 _lpython_return_variable) Public .false. .false.), _lfortran_scos: (Function (SymbolTable 10 {_lpython_return_variable: (Variable 10 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 10 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scos (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 10 x)] [] (Var 10 _lpython_return_variable) Public .false. .false.), _lfortran_scosh: (Function (SymbolTable 24 {_lpython_return_variable: (Variable 24 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 24 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_scosh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 24 x)] [] (Var 24 _lpython_return_variable) Public .false. .false.), _lfortran_sexp: (Function (SymbolTable 50 {_lpython_return_variable: (Variable 50 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 50 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_sexp (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 50 x)] [] (Var 50 _lpython_return_variable) Public .false. .false.), _lfortran_slog: (Function (SymbolTable 28 {_lpython_return_variable: (Variable 28 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 28 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 28 x)] [] (Var 28 _lpython_return_variable) Public .false. .false.), _lfortran_slog10: (Function (SymbolTable 32 {_lpython_return_variable: (Variable 32 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 32 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_slog10 (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 32 x)] [] (Var 32 _lpython_return_variable) Public .false. .false.), _lfortran_ssin: (Function (SymbolTable 6 {_lpython_return_variable: (Variable 6 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 6 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssin (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 6 x)] [] (Var 6 _lpython_return_variable) Public .false. .false.), _lfortran_ssinh: (Function (SymbolTable 20 {_lpython_return_variable: (Variable 20 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 20 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_ssinh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 20 x)] [] (Var 20 _lpython_return_variable) Public .false. .false.), _lfortran_stan: (Function (SymbolTable 16 {_lpython_return_variable: (Variable 16 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 16 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stan (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 16 x)] [] (Var 16 _lpython_return_variable) Public .false. .false.), _lfortran_stanh: (Function (SymbolTable 46 {_lpython_return_variable: (Variable 46 _lpython_return_variable [] ReturnVar () () Default (Real 4 []) BindC Public Required .false.), x: (Variable 46 x [] In () () Default (Real 4 []) BindC Public Required .true.)}) _lfortran_stanh (FunctionType [(Real 4 [])] (Real 4 []) BindC Interface () .false. .false. .false. .false. .false. [] [] .false.) [] [(Var 46 x)] [] (Var 46 _lpython_return_variable) Public .false. .false.), arccos: (GenericProcedure 3 arccos [3 __lpython_overloaded_0__arccos 3 __lpython_overloaded_1__arccos] Public), arccosh: (GenericProcedure 3 arccosh [3 __lpython_overloaded_0__arccosh 3 __lpython_overloaded_1__arccosh] Public), arcsin: (GenericProcedure 3 arcsin [3 __lpython_overloaded_0__arcsin 3 __lpython_overloaded_1__arcsin] Public), arcsinh: (GenericProcedure 3 arcsinh [3 __lpython_overloaded_0__arcsinh 3 __lpython_overloaded_1__arcsinh] Public), arctan: (GenericProcedure 3 arctan [3 __lpython_overloaded_0__arctan 3 __lpython_overloaded_1__arctan] Public), arctanh: (GenericProcedure 3 arctanh [3 __lpython_overloaded_0__arctanh 3 __lpython_overloaded_1__arctanh] Public), ceil: (GenericProcedure 3 ceil [3 __lpython_overloaded_0__ceil 3 __lpython_overloaded_1__ceil] Public), cos: (GenericProcedure 3 cos [3 __lpython_overloaded_0__cos 3 __lpython_overloaded_1__cos] Public), cosh: (GenericProcedure 3 cosh [3 __lpython_overloaded_0__cosh 3 __lpython_overloaded_1__cosh] Public), degrees: (GenericProcedure 3 degrees [3 __lpython_overloaded_0__degrees 3 __lpython_overloaded_1__degrees] Public), exp: (GenericProcedure 3 exp [3 __lpython_overloaded_0__exp 3 __lpython_overloaded_1__exp] Public), floor: (GenericProcedure 3 floor [3 __lpython_overloaded_0__floor 3 __lpython_overloaded_1__floor] Public), log: (GenericProcedure 3 log [3 __lpython_overloaded_0__log 3 __lpython_overloaded_1__log] Public), log10: (GenericProcedure 3 log10 [3 __lpython_overloaded_0__log10 3 __lpython_overloaded_1__log10] Public), log2: (GenericProcedure 3 log2 [3 __lpython_overloaded_0__log2 3 __lpython_overloaded_1__log2] Public), mod: (GenericProcedure 3 mod [3 __lpython_overloaded_0__mod 3 __lpython_overloaded_1__mod] Public), pi_32: (Variable 3 pi_32 [] Local (Cast (RealConstant 3.141593 (Real 8 [])) RealToReal (Real 4 []) (RealConstant 3.141593 (Real 4 []))) (RealConstant 3.141593 (Real 4 [])) Default (Real 4 []) Source Public Required .false.), pi_64: (Variable 3 pi_64 [] Local (RealConstant 3.141593 (Real 8 [])) (RealConstant 3.141593 (Real 8 [])) Default (Real 8 []) Source Public Required .false.), radians: (GenericProcedure 3 radians [3 __lpython_overloaded_0__radians 3 __lpython_overloaded_1__radians] Public), sin: (GenericProcedure 3 sin [3 __lpython_overloaded_0__sin 3 __lpython_overloaded_1__sin] Public), sinh: (GenericProcedure 3 sinh [3 __lpython_overloaded_0__sinh 3 __lpython_overloaded_1__sinh] Public), sqrt: (GenericProcedure 3 sqrt [3 __lpython_overloaded_0__sqrt 3 __lpython_overloaded_1__sqrt] Public), tan: (GenericProcedure 3 tan [3 __lpython_overloaded_0__tan 3 __lpython_overloaded_1__tan] Public), tanh: (GenericProcedure 3 tanh [3 __lpython_overloaded_0__tanh 3 __lpython_overloaded_1__tanh] Public)}) numpy [lpython_builtin lpython_builtin] .false. .false.)}) []) diff --git a/tests/reference/pass_print_list_tuple-print_02-09600eb.json b/tests/reference/pass_print_list_tuple-print_02-09600eb.json index 9ec9a44227..97f992427e 100644 --- a/tests/reference/pass_print_list_tuple-print_02-09600eb.json +++ b/tests/reference/pass_print_list_tuple-print_02-09600eb.json @@ -6,7 +6,7 @@ "outfile": null, "outfile_hash": null, "stdout": "pass_print_list_tuple-print_02-09600eb.stdout", - "stdout_hash": "a3599b86838c70fe81fcf2efa2605ff645afcd0d21d6af8601ab50ac", + "stdout_hash": "26debb31537e40272c86f651f09f797ea25af2c20f7273135d6ccac0", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/pass_print_list_tuple-print_02-09600eb.stdout b/tests/reference/pass_print_list_tuple-print_02-09600eb.stdout index aafb3f71a5..b2508caa08 100644 --- a/tests/reference/pass_print_list_tuple-print_02-09600eb.stdout +++ b/tests/reference/pass_print_list_tuple-print_02-09600eb.stdout @@ -1 +1 @@ -(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 9 {_lpython_main_program: (Function (SymbolTable 8 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [check] [] [(SubroutineCall 9 check () [] ())] () Public .false. .false.), check: (Function (SymbolTable 6 {}) check (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [f test_nested_lists test_nested_lists2 test_print_list_tuple] [] [(SubroutineCall 9 f () [] ()) (SubroutineCall 9 test_nested_lists () [] ()) (SubroutineCall 9 test_nested_lists2 () [] ()) (SubroutineCall 9 test_print_list_tuple () [] ())] () Public .false. .false.), f: (Function (SymbolTable 2 {__list_iterator: (Variable 2 __list_iterator [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator1: (Variable 2 __list_iterator1 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator10: (Variable 2 __list_iterator10 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator11: (Variable 2 __list_iterator11 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator12: (Variable 2 __list_iterator12 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator13: (Variable 2 __list_iterator13 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator14: (Variable 2 __list_iterator14 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator15: (Variable 2 __list_iterator15 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator16: (Variable 2 __list_iterator16 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator17: (Variable 2 __list_iterator17 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator18: (Variable 2 __list_iterator18 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator2: (Variable 2 __list_iterator2 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator3: (Variable 2 __list_iterator3 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator4: (Variable 2 __list_iterator4 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator5: (Variable 2 __list_iterator5 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator6: (Variable 2 __list_iterator6 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator7: (Variable 2 __list_iterator7 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator8: (Variable 2 __list_iterator8 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator9: (Variable 2 __list_iterator9 [] Local () () Default (Integer 4 []) Source Public Required .false.), a: (Variable 2 a [] Local () () Default (List (Character 1 -2 () [])) Source Public Required .false.), b: (Variable 2 b [] Local () () Default (List (Integer 4 [])) Source Public Required .false.), c: (Variable 2 c [] Local () () Default (List (Real 8 [])) Source Public Required .false.), d: (Variable 2 d [] Local () () Default (List (Integer 4 [])) Source Public Required .false.)}) f (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 a) (ListConstant [(StringConstant "ab" (Character 1 2 () [])) (StringConstant "abc" (Character 1 3 () [])) (StringConstant "abcd" (Character 1 4 () []))] (List (Character 1 2 () []))) ()) (= (Var 2 b) (ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (List (Integer 4 []))) ()) (= (Var 2 c) (ListConstant [(RealConstant 1.230000 (Real 8 [])) (RealConstant 324.300000 (Real 8 [])) (RealConstant 56.431000 (Real 8 [])) (RealConstant 90.500000 (Real 8 [])) (RealConstant 34.100000 (Real 8 []))] (List (Real 8 []))) ()) (= (Var 2 d) (ListConstant [] (List (Integer 4 []))) ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator1) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 b) (Var 2 __list_iterator1) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator1) Lt (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator2) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 c) (Var 2 __list_iterator2) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator2) Lt (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator3) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 d) (Var 2 __list_iterator3) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator3) Lt (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator4) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator4) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator4) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator5) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator5) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator5) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator6) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 b) (Var 2 __list_iterator6) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator6) Lt (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator7) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 c) (Var 2 __list_iterator7) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator7) Lt (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator8) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 d) (Var 2 __list_iterator8) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator8) Lt (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator9) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator9) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator9) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator10) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator10) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator10) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(IntegerConstant 1 (Integer 4 []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator11) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 b) (Var 2 __list_iterator11) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator11) Lt (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator12) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 c) (Var 2 __list_iterator12) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator12) Lt (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(RealConstant 1.100000 (Real 8 []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator13) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 d) (Var 2 __list_iterator13) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator13) Lt (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator14) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListConstant [(IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])) (IntegerConstant 0 (Integer 4 []))] (List (Integer 4 []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListConstant [(IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])) (IntegerConstant 0 (Integer 4 []))] (List (Integer 4 []))) (Var 2 __list_iterator14) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator14) Lt (IntegerBinOp (ListLen (ListConstant [(IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])) (IntegerConstant 0 (Integer 4 []))] (List (Integer 4 []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator15) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListConstant [(StringConstant "a" (Character 1 1 () [])) (StringConstant "b" (Character 1 1 () [])) (StringConstant "c" (Character 1 1 () [])) (StringConstant "d" (Character 1 1 () [])) (StringConstant "e" (Character 1 1 () [])) (StringConstant "f" (Character 1 1 () []))] (List (Character 1 1 () []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (ListConstant [(StringConstant "a" (Character 1 1 () [])) (StringConstant "b" (Character 1 1 () [])) (StringConstant "c" (Character 1 1 () [])) (StringConstant "d" (Character 1 1 () [])) (StringConstant "e" (Character 1 1 () [])) (StringConstant "f" (Character 1 1 () []))] (List (Character 1 1 () []))) (Var 2 __list_iterator15) (Character 1 1 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator15) Lt (IntegerBinOp (ListLen (ListConstant [(StringConstant "a" (Character 1 1 () [])) (StringConstant "b" (Character 1 1 () [])) (StringConstant "c" (Character 1 1 () [])) (StringConstant "d" (Character 1 1 () [])) (StringConstant "e" (Character 1 1 () [])) (StringConstant "f" (Character 1 1 () []))] (List (Character 1 1 () []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator16) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (List (Integer 4 []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (List (Integer 4 []))) (Var 2 __list_iterator16) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator16) Lt (IntegerBinOp (ListLen (ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (List (Integer 4 []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator17) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator17) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator17) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 2 __list_iterator18) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 c) (Var 2 __list_iterator18) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator18) Lt (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ())] () Public .false. .false.), test_nested_lists: (Function (SymbolTable 3 {__list_iterator: (Variable 3 __list_iterator [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator1: (Variable 3 __list_iterator1 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator10: (Variable 3 __list_iterator10 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator11: (Variable 3 __list_iterator11 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator2: (Variable 3 __list_iterator2 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator3: (Variable 3 __list_iterator3 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator4: (Variable 3 __list_iterator4 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator5: (Variable 3 __list_iterator5 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator6: (Variable 3 __list_iterator6 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator7: (Variable 3 __list_iterator7 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator8: (Variable 3 __list_iterator8 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator9: (Variable 3 __list_iterator9 [] Local () () Default (Integer 4 []) Source Public Required .false.), w: (Variable 3 w [] Local () () Default (List (List (List (List (List (Real 8 [])))))) Source Public Required .false.), x: (Variable 3 x [] Local () () Default (List (List (List (Integer 4 [])))) Source Public Required .false.), y: (Variable 3 y [] Local () () Default (List (List (Real 8 []))) Source Public Required .false.), z: (Variable 3 z [] Local () () Default (List (List (Character 1 -2 () []))) Source Public Required .false.)}) test_nested_lists (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 3 w) (ListConstant [(ListConstant [(ListConstant [(ListConstant [(ListConstant [(RealConstant 2.130000 (Real 8 [])) (RealUnaryMinus (RealConstant 98.170000 (Real 8 [])) (Real 8 []) (RealConstant -98.170000 (Real 8 [])))] (List (Real 8 [])))] (List (List (Real 8 []))))] (List (List (List (Real 8 []))))) (ListConstant [(ListConstant [(ListConstant [(RealConstant 1.110000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 []))))] (List (List (List (Real 8 [])))))] (List (List (List (List (Real 8 []))))))] (List (List (List (List (List (Real 8 []))))))) ()) (= (Var 3 x) (ListConstant [(ListConstant [(ListConstant [(IntegerConstant 3 (Integer 4 [])) (IntegerUnaryMinus (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant -1 (Integer 4 [])))] (List (Integer 4 []))) (ListConstant [(IntegerUnaryMinus (IntegerConstant 2 (Integer 4 [])) (Integer 4 []) (IntegerConstant -2 (Integer 4 []))) (IntegerConstant 5 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 5 (Integer 4 []))] (List (Integer 4 [])))] (List (List (Integer 4 [])))) (ListConstant [(ListConstant [(IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 2 (Integer 4 [])) (IntegerUnaryMinus (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) (IntegerConstant -5 (Integer 4 [])))] (List (Integer 4 []))) (ListConstant [(IntegerUnaryMinus (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) (IntegerConstant -5 (Integer 4 [])))] (List (Integer 4 [])))] (List (List (Integer 4 []))))] (List (List (List (Integer 4 []))))) ()) (= (Var 3 y) (ListConstant [(ListConstant [(RealConstant 3.140000 (Real 8 [])) (RealUnaryMinus (RealConstant 1.001200 (Real 8 [])) (Real 8 []) (RealConstant -1.001200 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 2.380000 (Real 8 [])) (Real 8 []) (RealConstant -2.380000 (Real 8 []))) (RealConstant 5.510000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 [])))) ()) (= (Var 3 z) (ListConstant [(ListConstant [(StringConstant "bat" (Character 1 3 () [])) (StringConstant "ball" (Character 1 4 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "cat" (Character 1 3 () [])) (StringConstant "dog" (Character 1 3 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "c" (Character 1 1 () [])) (StringConstant "c++" (Character 1 3 () [])) (StringConstant "java" (Character 1 4 () [])) (StringConstant "python" (Character 1 6 () []))] (List (Character 1 1 () [])))] (List (List (Character 1 3 () [])))) ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 3 w) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator1) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator2) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator3) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Var 3 __list_iterator2) (List (List (Real 8 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator4) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Var 3 __list_iterator2) (List (List (Real 8 []))) ()) (Var 3 __list_iterator3) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListItem (ListItem (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Var 3 __list_iterator2) (List (List (Real 8 []))) ()) (Var 3 __list_iterator3) (List (Real 8 [])) ()) (Var 3 __list_iterator4) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator4) Lt (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Var 3 __list_iterator2) (List (List (Real 8 []))) ()) (Var 3 __list_iterator3) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator3) Lt (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Var 3 __list_iterator2) (List (List (Real 8 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator2) Lt (IntegerBinOp (ListLen (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator1) Lt (IntegerBinOp (ListLen (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator) Lt (IntegerBinOp (ListLen (Var 3 w) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator5) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 3 x) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator6) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 3 x) (Var 3 __list_iterator5) (List (List (Integer 4 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator7) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (Var 3 x) (Var 3 __list_iterator5) (List (List (Integer 4 []))) ()) (Var 3 __list_iterator6) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListItem (ListItem (Var 3 x) (Var 3 __list_iterator5) (List (List (Integer 4 []))) ()) (Var 3 __list_iterator6) (List (Integer 4 [])) ()) (Var 3 __list_iterator7) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator7) Lt (IntegerBinOp (ListLen (ListItem (ListItem (Var 3 x) (Var 3 __list_iterator5) (List (List (Integer 4 []))) ()) (Var 3 __list_iterator6) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator6) Lt (IntegerBinOp (ListLen (ListItem (Var 3 x) (Var 3 __list_iterator5) (List (List (Integer 4 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator5) Lt (IntegerBinOp (ListLen (Var 3 x) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator8) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 3 y) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator9) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 3 y) (Var 3 __list_iterator8) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListItem (Var 3 y) (Var 3 __list_iterator8) (List (Real 8 [])) ()) (Var 3 __list_iterator9) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator9) Lt (IntegerBinOp (ListLen (ListItem (Var 3 y) (Var 3 __list_iterator8) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator8) Lt (IntegerBinOp (ListLen (Var 3 y) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator10) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 3 z) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 3 __list_iterator11) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 3 z) (Var 3 __list_iterator10) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (ListItem (Var 3 z) (Var 3 __list_iterator10) (List (Character 1 -2 () [])) ()) (Var 3 __list_iterator11) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator11) Lt (IntegerBinOp (ListLen (ListItem (Var 3 z) (Var 3 __list_iterator10) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator10) Lt (IntegerBinOp (ListLen (Var 3 z) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ())] () Public .false. .false.), test_nested_lists2: (Function (SymbolTable 5 {__list_iterator: (Variable 5 __list_iterator [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator1: (Variable 5 __list_iterator1 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator2: (Variable 5 __list_iterator2 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator3: (Variable 5 __list_iterator3 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator4: (Variable 5 __list_iterator4 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator5: (Variable 5 __list_iterator5 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator6: (Variable 5 __list_iterator6 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator7: (Variable 5 __list_iterator7 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator8: (Variable 5 __list_iterator8 [] Local () () Default (Integer 4 []) Source Public Required .false.), p: (Variable 5 p [] Local () () Default (List (List (Integer 4 []))) Source Public Required .false.), q: (Variable 5 q [] Local () () Default (List (List (List (List (Real 8 []))))) Source Public Required .false.), r: (Variable 5 r [] Local () () Default (List (List (List (Character 1 -2 () [])))) Source Public Required .false.)}) test_nested_lists2 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 5 p) (ListConstant [(ListConstant [(IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])) (IntegerConstant 5 (Integer 4 [])) (IntegerConstant 6 (Integer 4 [])) (IntegerConstant 7 (Integer 4 [])) (IntegerConstant 8 (Integer 4 [])) (IntegerConstant 9 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 10 (Integer 4 [])) (IntegerConstant 11 (Integer 4 [])) (IntegerConstant 12 (Integer 4 [])) (IntegerConstant 13 (Integer 4 [])) (IntegerConstant 14 (Integer 4 [])) (IntegerConstant 15 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])) (IntegerConstant 17 (Integer 4 [])) (IntegerConstant 18 (Integer 4 [])) (IntegerConstant 19 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 20 (Integer 4 [])) (IntegerConstant 21 (Integer 4 [])) (IntegerConstant 22 (Integer 4 [])) (IntegerConstant 23 (Integer 4 [])) (IntegerConstant 24 (Integer 4 [])) (IntegerConstant 25 (Integer 4 [])) (IntegerConstant 26 (Integer 4 [])) (IntegerConstant 27 (Integer 4 [])) (IntegerConstant 28 (Integer 4 [])) (IntegerConstant 29 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 30 (Integer 4 [])) (IntegerConstant 31 (Integer 4 [])) (IntegerConstant 32 (Integer 4 [])) (IntegerConstant 33 (Integer 4 [])) (IntegerConstant 34 (Integer 4 [])) (IntegerConstant 35 (Integer 4 [])) (IntegerConstant 36 (Integer 4 [])) (IntegerConstant 37 (Integer 4 [])) (IntegerConstant 38 (Integer 4 [])) (IntegerConstant 39 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 40 (Integer 4 [])) (IntegerConstant 41 (Integer 4 [])) (IntegerConstant 42 (Integer 4 [])) (IntegerConstant 43 (Integer 4 [])) (IntegerConstant 44 (Integer 4 [])) (IntegerConstant 45 (Integer 4 [])) (IntegerConstant 46 (Integer 4 [])) (IntegerConstant 47 (Integer 4 [])) (IntegerConstant 48 (Integer 4 [])) (IntegerConstant 49 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 50 (Integer 4 [])) (IntegerConstant 51 (Integer 4 [])) (IntegerConstant 52 (Integer 4 [])) (IntegerConstant 53 (Integer 4 [])) (IntegerConstant 54 (Integer 4 [])) (IntegerConstant 55 (Integer 4 [])) (IntegerConstant 56 (Integer 4 [])) (IntegerConstant 57 (Integer 4 [])) (IntegerConstant 58 (Integer 4 [])) (IntegerConstant 59 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 60 (Integer 4 [])) (IntegerConstant 61 (Integer 4 [])) (IntegerConstant 62 (Integer 4 [])) (IntegerConstant 63 (Integer 4 [])) (IntegerConstant 64 (Integer 4 [])) (IntegerConstant 65 (Integer 4 [])) (IntegerConstant 66 (Integer 4 [])) (IntegerConstant 67 (Integer 4 [])) (IntegerConstant 68 (Integer 4 [])) (IntegerConstant 69 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 70 (Integer 4 [])) (IntegerConstant 71 (Integer 4 [])) (IntegerConstant 72 (Integer 4 [])) (IntegerConstant 73 (Integer 4 [])) (IntegerConstant 74 (Integer 4 [])) (IntegerConstant 75 (Integer 4 [])) (IntegerConstant 76 (Integer 4 [])) (IntegerConstant 77 (Integer 4 [])) (IntegerConstant 78 (Integer 4 [])) (IntegerConstant 79 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 80 (Integer 4 [])) (IntegerConstant 81 (Integer 4 [])) (IntegerConstant 82 (Integer 4 [])) (IntegerConstant 83 (Integer 4 [])) (IntegerConstant 84 (Integer 4 [])) (IntegerConstant 85 (Integer 4 [])) (IntegerConstant 86 (Integer 4 [])) (IntegerConstant 87 (Integer 4 [])) (IntegerConstant 88 (Integer 4 [])) (IntegerConstant 89 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 90 (Integer 4 [])) (IntegerConstant 91 (Integer 4 [])) (IntegerConstant 92 (Integer 4 [])) (IntegerConstant 93 (Integer 4 [])) (IntegerConstant 94 (Integer 4 [])) (IntegerConstant 95 (Integer 4 [])) (IntegerConstant 96 (Integer 4 [])) (IntegerConstant 97 (Integer 4 [])) (IntegerConstant 98 (Integer 4 [])) (IntegerConstant 99 (Integer 4 []))] (List (Integer 4 [])))] (List (List (Integer 4 [])))) ()) (= (Var 5 q) (ListConstant [(ListConstant [(ListConstant [(ListConstant [(RealConstant 74.550000 (Real 8 [])) (RealUnaryMinus (RealConstant 77.640000 (Real 8 [])) (Real 8 []) (RealConstant -77.640000 (Real 8 []))) (RealConstant 52.350000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 78.250000 (Real 8 [])) (Real 8 []) (RealConstant -78.250000 (Real 8 []))) (RealUnaryMinus (RealConstant 19.240000 (Real 8 [])) (Real 8 []) (RealConstant -19.240000 (Real 8 []))) (RealConstant 81.380000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 7.860000 (Real 8 [])) (RealConstant 12.110000 (Real 8 [])) (RealConstant 27.500000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealUnaryMinus (RealConstant 98.930000 (Real 8 [])) (Real 8 []) (RealConstant -98.930000 (Real 8 []))) (RealUnaryMinus (RealConstant 79.620000 (Real 8 [])) (Real 8 []) (RealConstant -79.620000 (Real 8 []))) (RealUnaryMinus (RealConstant 73.760000 (Real 8 [])) (Real 8 []) (RealConstant -73.760000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealConstant 42.050000 (Real 8 [])) (RealUnaryMinus (RealConstant 90.290000 (Real 8 [])) (Real 8 []) (RealConstant -90.290000 (Real 8 []))) (RealConstant 69.950000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 59.320000 (Real 8 [])) (RealUnaryMinus (RealConstant 70.780000 (Real 8 [])) (Real 8 []) (RealConstant -70.780000 (Real 8 []))) (RealUnaryMinus (RealConstant 53.220000 (Real 8 [])) (Real 8 []) (RealConstant -53.220000 (Real 8 [])))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealConstant 53.520000 (Real 8 [])) (RealUnaryMinus (RealConstant 93.880000 (Real 8 [])) (Real 8 []) (RealConstant -93.880000 (Real 8 []))) (RealConstant 49.650000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 2.180000 (Real 8 [])) (RealConstant 19.910000 (Real 8 [])) (RealConstant 69.240000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 78.510000 (Real 8 [])) (RealConstant 89.690000 (Real 8 [])) (RealUnaryMinus (RealConstant 86.680000 (Real 8 [])) (Real 8 []) (RealConstant -86.680000 (Real 8 [])))] (List (Real 8 [])))] (List (List (Real 8 []))))] (List (List (List (Real 8 []))))) (ListConstant [(ListConstant [(ListConstant [(RealUnaryMinus (RealConstant 92.480000 (Real 8 [])) (Real 8 []) (RealConstant -92.480000 (Real 8 []))) (RealUnaryMinus (RealConstant 80.750000 (Real 8 [])) (Real 8 []) (RealConstant -80.750000 (Real 8 []))) (RealUnaryMinus (RealConstant 27.760000 (Real 8 [])) (Real 8 []) (RealConstant -27.760000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 13.350000 (Real 8 [])) (Real 8 []) (RealConstant -13.350000 (Real 8 []))) (RealConstant 12.280000 (Real 8 [])) (RealConstant 79.610000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 48.480000 (Real 8 [])) (RealUnaryMinus (RealConstant 10.490000 (Real 8 [])) (Real 8 []) (RealConstant -10.490000 (Real 8 []))) (RealConstant 41.100000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealConstant 20.330000 (Real 8 [])) (RealConstant 14.520000 (Real 8 [])) (RealConstant 82.560000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 57.760000 (Real 8 [])) (Real 8 []) (RealConstant -57.760000 (Real 8 []))) (RealConstant 76.030000 (Real 8 [])) (RealConstant 67.330000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 21.500000 (Real 8 [])) (Real 8 []) (RealConstant -21.500000 (Real 8 []))) (RealUnaryMinus (RealConstant 11.920000 (Real 8 [])) (Real 8 []) (RealConstant -11.920000 (Real 8 []))) (RealUnaryMinus (RealConstant 31.840000 (Real 8 [])) (Real 8 []) (RealConstant -31.840000 (Real 8 [])))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealConstant 9.650000 (Real 8 [])) (RealConstant 11.150000 (Real 8 [])) (RealUnaryMinus (RealConstant 36.580000 (Real 8 [])) (Real 8 []) (RealConstant -36.580000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealConstant 56.550000 (Real 8 [])) (RealUnaryMinus (RealConstant 70.850000 (Real 8 [])) (Real 8 []) (RealConstant -70.850000 (Real 8 []))) (RealUnaryMinus (RealConstant 50.670000 (Real 8 [])) (Real 8 []) (RealConstant -50.670000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealConstant 94.630000 (Real 8 [])) (RealConstant 25.680000 (Real 8 [])) (RealConstant 89.300000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 []))))] (List (List (List (Real 8 []))))) (ListConstant [(ListConstant [(ListConstant [(RealConstant 28.530000 (Real 8 [])) (RealConstant 71.220000 (Real 8 [])) (RealConstant 71.870000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 58.390000 (Real 8 [])) (Real 8 []) (RealConstant -58.390000 (Real 8 []))) (RealUnaryMinus (RealConstant 6.960000 (Real 8 [])) (Real 8 []) (RealConstant -6.960000 (Real 8 []))) (RealConstant 42.980000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 8.950000 (Real 8 [])) (Real 8 []) (RealConstant -8.950000 (Real 8 []))) (RealUnaryMinus (RealConstant 75.090000 (Real 8 [])) (Real 8 []) (RealConstant -75.090000 (Real 8 []))) (RealConstant 37.960000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealUnaryMinus (RealConstant 31.750000 (Real 8 [])) (Real 8 []) (RealConstant -31.750000 (Real 8 []))) (RealConstant 67.330000 (Real 8 [])) (RealConstant 58.170000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 64.010000 (Real 8 [])) (Real 8 []) (RealConstant -64.010000 (Real 8 []))) (RealUnaryMinus (RealConstant 9.220000 (Real 8 [])) (Real 8 []) (RealConstant -9.220000 (Real 8 []))) (RealConstant 9.590000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 15.710000 (Real 8 [])) (RealConstant 82.360000 (Real 8 [])) (RealConstant 51.180000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealUnaryMinus (RealConstant 100.290000 (Real 8 [])) (Real 8 []) (RealConstant -100.290000 (Real 8 []))) (RealUnaryMinus (RealConstant 32.720000 (Real 8 [])) (Real 8 []) (RealConstant -32.720000 (Real 8 []))) (RealUnaryMinus (RealConstant 54.940000 (Real 8 [])) (Real 8 []) (RealConstant -54.940000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 0.320000 (Real 8 [])) (Real 8 []) (RealConstant -0.320000 (Real 8 []))) (RealConstant 68.810000 (Real 8 [])) (RealUnaryMinus (RealConstant 55.090000 (Real 8 [])) (Real 8 []) (RealConstant -55.090000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealConstant 97.280000 (Real 8 [])) (RealUnaryMinus (RealConstant 28.200000 (Real 8 [])) (Real 8 []) (RealConstant -28.200000 (Real 8 []))) (RealUnaryMinus (RealConstant 62.610000 (Real 8 [])) (Real 8 []) (RealConstant -62.610000 (Real 8 [])))] (List (Real 8 [])))] (List (List (Real 8 []))))] (List (List (List (Real 8 [])))))] (List (List (List (List (Real 8 [])))))) ()) (= (Var 5 r) (ListConstant [(ListConstant [(ListConstant [(StringConstant "Io" (Character 1 2 () [])) (StringConstant "tl" (Character 1 2 () [])) (StringConstant "bLvjV" (Character 1 5 () [])) (StringConstant "wjFKQ" (Character 1 5 () [])) (StringConstant "lY2" (Character 1 3 () []))] (List (Character 1 2 () []))) (ListConstant [(StringConstant "Be2l6bqE" (Character 1 8 () [])) (StringConstant "pQER3utIXA" (Character 1 10 () [])) (StringConstant "llZBJj5Cdu" (Character 1 10 () [])) (StringConstant "C8" (Character 1 2 () [])) (StringConstant "gwTr77PdYR" (Character 1 10 () []))] (List (Character 1 8 () []))) (ListConstant [(StringConstant "4M6L" (Character 1 4 () [])) (StringConstant "ktPdowqERy" (Character 1 10 () [])) (StringConstant "KSifqTkR" (Character 1 8 () [])) (StringConstant "ZE2p1N78f1" (Character 1 10 () [])) (StringConstant "Mi5e87Xw" (Character 1 8 () []))] (List (Character 1 4 () []))) (ListConstant [(StringConstant "uwfzqDq9g" (Character 1 9 () [])) (StringConstant "QaM1s" (Character 1 5 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "LB" (Character 1 2 () []))] (List (Character 1 9 () []))) (ListConstant [(StringConstant "OJFRY6k" (Character 1 7 () [])) (StringConstant "iz7Oie" (Character 1 6 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "LUYLF" (Character 1 5 () [])) (StringConstant "JBND5FuV7l" (Character 1 10 () []))] (List (Character 1 7 () [])))] (List (List (Character 1 2 () [])))) (ListConstant [(ListConstant [(StringConstant "m" (Character 1 1 () [])) (StringConstant "WIQBQfV" (Character 1 7 () [])) (StringConstant "jxjDrqxu" (Character 1 8 () [])) (StringConstant "kea" (Character 1 3 () [])) (StringConstant "mu" (Character 1 2 () []))] (List (Character 1 1 () []))) (ListConstant [(StringConstant "" (Character 1 0 () [])) (StringConstant "GI8aOwLMe" (Character 1 9 () [])) (StringConstant "Y5m8" (Character 1 4 () [])) (StringConstant "a02Rz" (Character 1 5 () [])) (StringConstant "xNKCJ" (Character 1 5 () []))] (List (Character 1 0 () []))) (ListConstant [(StringConstant "LzkhyiJQHP" (Character 1 10 () [])) (StringConstant "uzc3xyoXL" (Character 1 9 () [])) (StringConstant "sKGnYfpRy" (Character 1 9 () [])) (StringConstant "7x" (Character 1 2 () [])) (StringConstant "WTVKrnPO" (Character 1 8 () []))] (List (Character 1 10 () []))) (ListConstant [(StringConstant "TZa6" (Character 1 4 () [])) (StringConstant "GXRuyRX" (Character 1 7 () [])) (StringConstant "R" (Character 1 1 () [])) (StringConstant "JQxS" (Character 1 4 () [])) (StringConstant "OH" (Character 1 2 () []))] (List (Character 1 4 () []))) (ListConstant [(StringConstant "bSVJZ1OQ" (Character 1 8 () [])) (StringConstant "M" (Character 1 1 () [])) (StringConstant "I9omlF" (Character 1 6 () [])) (StringConstant "x7FR" (Character 1 4 () [])) (StringConstant "XtpL" (Character 1 4 () []))] (List (Character 1 8 () [])))] (List (List (Character 1 1 () [])))) (ListConstant [(ListConstant [(StringConstant "DKOpK" (Character 1 5 () [])) (StringConstant "eg8Nz" (Character 1 5 () [])) (StringConstant "ru" (Character 1 2 () [])) (StringConstant "Sj" (Character 1 2 () [])) (StringConstant "YUDxyI" (Character 1 6 () []))] (List (Character 1 5 () []))) (ListConstant [(StringConstant "Q5uyhvp" (Character 1 7 () [])) (StringConstant "Ydx" (Character 1 3 () [])) (StringConstant "p" (Character 1 1 () [])) (StringConstant "DLM5RX" (Character 1 6 () [])) (StringConstant "pwOujxCO" (Character 1 8 () []))] (List (Character 1 7 () []))) (ListConstant [(StringConstant "s5GOWnNJV" (Character 1 9 () [])) (StringConstant "af" (Character 1 2 () [])) (StringConstant "KAkD" (Character 1 4 () [])) (StringConstant "4IIZK" (Character 1 5 () [])) (StringConstant "JQK040x" (Character 1 7 () []))] (List (Character 1 9 () []))) (ListConstant [(StringConstant "9vF" (Character 1 3 () [])) (StringConstant "9pc7R8v" (Character 1 7 () [])) (StringConstant "nDReIU7" (Character 1 7 () [])) (StringConstant "K" (Character 1 1 () [])) (StringConstant "btn" (Character 1 3 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "" (Character 1 0 () [])) (StringConstant "wVeivkdi" (Character 1 8 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "C" (Character 1 1 () []))] (List (Character 1 0 () [])))] (List (List (Character 1 5 () [])))) (ListConstant [(ListConstant [(StringConstant "vNTtcRXD" (Character 1 8 () [])) (StringConstant "rsi" (Character 1 3 () [])) (StringConstant "YsoF7mZD" (Character 1 8 () [])) (StringConstant "VrPXU50rgA" (Character 1 10 () [])) (StringConstant "mG7zqN0G" (Character 1 8 () []))] (List (Character 1 8 () []))) (ListConstant [(StringConstant "la7cJ" (Character 1 5 () [])) (StringConstant "M5rLJ8Go" (Character 1 8 () [])) (StringConstant "gb" (Character 1 2 () [])) (StringConstant "FjKwYZ7E" (Character 1 8 () [])) (StringConstant "uSPD" (Character 1 4 () []))] (List (Character 1 5 () []))) (ListConstant [(StringConstant "" (Character 1 0 () [])) (StringConstant "oOa79jWcMx" (Character 1 10 () [])) (StringConstant "yyAYZZ" (Character 1 6 () [])) (StringConstant "wbvggXm" (Character 1 7 () [])) (StringConstant "aE3BkCL4" (Character 1 8 () []))] (List (Character 1 0 () []))) (ListConstant [(StringConstant "RdP" (Character 1 3 () [])) (StringConstant "Hwc0x9RZ" (Character 1 8 () [])) (StringConstant "sy" (Character 1 2 () [])) (StringConstant "9" (Character 1 1 () [])) (StringConstant "W1d9xA2BXe" (Character 1 10 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "A" (Character 1 1 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "QnK" (Character 1 3 () [])) (StringConstant "N5tzN" (Character 1 5 () [])) (StringConstant "ou7Lp" (Character 1 5 () []))] (List (Character 1 1 () [])))] (List (List (Character 1 8 () [])))) (ListConstant [(ListConstant [(StringConstant "DL68rDF" (Character 1 7 () [])) (StringConstant "v" (Character 1 1 () [])) (StringConstant "kQ3Mxm" (Character 1 6 () [])) (StringConstant "g" (Character 1 1 () [])) (StringConstant "6KTeF4Eo" (Character 1 8 () []))] (List (Character 1 7 () []))) (ListConstant [(StringConstant "Hx9" (Character 1 3 () [])) (StringConstant "Y1IzQm85Z4" (Character 1 10 () [])) (StringConstant "3D8" (Character 1 3 () [])) (StringConstant "ZLZ5" (Character 1 4 () [])) (StringConstant "rWn" (Character 1 3 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "LtT" (Character 1 3 () [])) (StringConstant "Dh5B" (Character 1 4 () [])) (StringConstant "M" (Character 1 1 () [])) (StringConstant "F" (Character 1 1 () [])) (StringConstant "QTARbY" (Character 1 6 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "Sh" (Character 1 2 () [])) (StringConstant "WL" (Character 1 2 () [])) (StringConstant "yvAfWvZSx1" (Character 1 10 () [])) (StringConstant "90yx" (Character 1 4 () [])) (StringConstant "v" (Character 1 1 () []))] (List (Character 1 2 () []))) (ListConstant [(StringConstant "" (Character 1 0 () [])) (StringConstant "7IBW" (Character 1 4 () [])) (StringConstant "nI" (Character 1 2 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "6Cbp5c8RT" (Character 1 9 () []))] (List (Character 1 0 () [])))] (List (List (Character 1 7 () []))))] (List (List (List (Character 1 2 () []))))) ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 5 __list_iterator) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 5 p) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 5 __list_iterator1) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 5 p) (Var 5 __list_iterator) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListItem (Var 5 p) (Var 5 __list_iterator) (List (Integer 4 [])) ()) (Var 5 __list_iterator1) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator1) Lt (IntegerBinOp (ListLen (ListItem (Var 5 p) (Var 5 __list_iterator) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator) Lt (IntegerBinOp (ListLen (Var 5 p) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 5 __list_iterator2) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 5 q) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 5 __list_iterator3) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 5 __list_iterator4) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Var 5 __list_iterator3) (List (List (Real 8 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 5 __list_iterator5) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Var 5 __list_iterator3) (List (List (Real 8 []))) ()) (Var 5 __list_iterator4) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListItem (ListItem (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Var 5 __list_iterator3) (List (List (Real 8 []))) ()) (Var 5 __list_iterator4) (List (Real 8 [])) ()) (Var 5 __list_iterator5) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator5) Lt (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Var 5 __list_iterator3) (List (List (Real 8 []))) ()) (Var 5 __list_iterator4) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator4) Lt (IntegerBinOp (ListLen (ListItem (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Var 5 __list_iterator3) (List (List (Real 8 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator3) Lt (IntegerBinOp (ListLen (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator2) Lt (IntegerBinOp (ListLen (Var 5 q) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 5 __list_iterator6) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 5 r) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 5 __list_iterator7) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 5 r) (Var 5 __list_iterator6) (List (List (Character 1 -2 () []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 5 __list_iterator8) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (Var 5 r) (Var 5 __list_iterator6) (List (List (Character 1 -2 () []))) ()) (Var 5 __list_iterator7) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (ListItem (ListItem (Var 5 r) (Var 5 __list_iterator6) (List (List (Character 1 -2 () []))) ()) (Var 5 __list_iterator7) (List (Character 1 -2 () [])) ()) (Var 5 __list_iterator8) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator8) Lt (IntegerBinOp (ListLen (ListItem (ListItem (Var 5 r) (Var 5 __list_iterator6) (List (List (Character 1 -2 () []))) ()) (Var 5 __list_iterator7) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator7) Lt (IntegerBinOp (ListLen (ListItem (Var 5 r) (Var 5 __list_iterator6) (List (List (Character 1 -2 () []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator6) Lt (IntegerBinOp (ListLen (Var 5 r) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ())] () Public .false. .false.), test_print_list_tuple: (Function (SymbolTable 4 {__list_iterator: (Variable 4 __list_iterator [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator1: (Variable 4 __list_iterator1 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator2: (Variable 4 __list_iterator2 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator3: (Variable 4 __list_iterator3 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator4: (Variable 4 __list_iterator4 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator5: (Variable 4 __list_iterator5 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator6: (Variable 4 __list_iterator6 [] Local () () Default (Integer 4 []) Source Public Required .false.), a: (Variable 4 a [] Local () () Default (List (Tuple [(Integer 4 []) (Integer 4 [])])) Source Public Required .false.), b: (Variable 4 b [] Local () () Default (Tuple [(List (Character 1 -2 () [])) (List (Integer 4 [])) (Real 8 [])]) Source Public Required .false.), b1: (Variable 4 b1 [] Local () () Default (List (Character 1 -2 () [])) Source Public Required .false.), b2: (Variable 4 b2 [] Local () () Default (List (Integer 4 [])) Source Public Required .false.), c: (Variable 4 c [] Local () () Default (List (List (Tuple [(Integer 4 []) (Character 1 -2 () [])]))) Source Public Required .false.)}) test_print_list_tuple (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 4 a) (ListConstant [(TupleConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 [])])) (TupleConstant [(IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 [])])) (TupleConstant [(IntegerConstant 5 (Integer 4 [])) (IntegerConstant 6 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 [])]))] (List (Tuple [(Integer 4 []) (Integer 4 [])]))) ()) (= (Var 4 c) (ListConstant [(ListConstant [(TupleConstant [(IntegerConstant 1 (Integer 4 [])) (StringConstant "a" (Character 1 1 () []))] (Tuple [(Integer 4 []) (Character 1 1 () [])])) (TupleConstant [(IntegerConstant 2 (Integer 4 [])) (StringConstant "b" (Character 1 1 () []))] (Tuple [(Integer 4 []) (Character 1 1 () [])]))] (List (Tuple [(Integer 4 []) (Character 1 1 () [])]))) (ListConstant [(TupleConstant [(IntegerConstant 3 (Integer 4 [])) (StringConstant "c" (Character 1 1 () []))] (Tuple [(Integer 4 []) (Character 1 1 () [])])) (TupleConstant [(IntegerConstant 4 (Integer 4 [])) (StringConstant "d" (Character 1 1 () []))] (Tuple [(Integer 4 []) (Character 1 1 () [])]))] (List (Tuple [(Integer 4 []) (Character 1 1 () [])])))] (List (List (Tuple [(Integer 4 []) (Character 1 1 () [])])))) ()) (= (Var 4 b1) (ListConstant [(StringConstant "a" (Character 1 1 () [])) (StringConstant "bb" (Character 1 2 () [])) (StringConstant "ccc" (Character 1 3 () [])) (StringConstant "dddd" (Character 1 4 () [])) (StringConstant "eeeee" (Character 1 5 () []))] (List (Character 1 1 () []))) ()) (= (Var 4 b2) (ListConstant [(IntegerConstant 10 (Integer 4 [])) (IntegerConstant 20 (Integer 4 [])) (IntegerConstant 30 (Integer 4 [])) (IntegerConstant 40 (Integer 4 []))] (List (Integer 4 []))) ()) (= (Var 4 b) (TupleConstant [(Var 4 b1) (Var 4 b2) (RealConstant 6.030500 (Real 8 []))] (Tuple [(List (Character 1 -2 () [])) (List (Integer 4 [])) (Real 8 [])])) ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 4 __list_iterator) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 4 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "(" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (Print () [(TupleItem (ListItem (Var 4 a) (Var 4 __list_iterator) (Tuple [(Integer 4 []) (Integer 4 [])]) ()) (IntegerConstant 0 (Integer 4 [])) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(TupleItem (ListItem (Var 4 a) (Var 4 __list_iterator) (Tuple [(Integer 4 []) (Integer 4 [])]) ()) (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ")" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator) Lt (IntegerBinOp (ListLen (Var 4 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "(" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 4 __list_iterator1) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (TupleItem (Var 4 b) (IntegerConstant 0 (Integer 4 [])) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (TupleItem (Var 4 b) (IntegerConstant 0 (Integer 4 [])) (List (Character 1 -2 () [])) ()) (Var 4 __list_iterator1) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator1) Lt (IntegerBinOp (ListLen (TupleItem (Var 4 b) (IntegerConstant 0 (Integer 4 [])) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 4 __list_iterator2) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (TupleItem (Var 4 b) (IntegerConstant 1 (Integer 4 [])) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (TupleItem (Var 4 b) (IntegerConstant 1 (Integer 4 [])) (List (Integer 4 [])) ()) (Var 4 __list_iterator2) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator2) Lt (IntegerBinOp (ListLen (TupleItem (Var 4 b) (IntegerConstant 1 (Integer 4 [])) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(TupleItem (Var 4 b) (IntegerConstant 2 (Integer 4 [])) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ")" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 4 __list_iterator3) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 4 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 4 __list_iterator4) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 4 c) (Var 4 __list_iterator3) (List (Tuple [(Integer 4 []) (Character 1 -2 () [])])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "(" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (Print () [(TupleItem (ListItem (ListItem (Var 4 c) (Var 4 __list_iterator3) (List (Tuple [(Integer 4 []) (Character 1 -2 () [])])) ()) (Var 4 __list_iterator4) (Tuple [(Integer 4 []) (Character 1 -2 () [])]) ()) (IntegerConstant 0 (Integer 4 [])) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant "'" (Character 1 1 () [])) (TupleItem (ListItem (ListItem (Var 4 c) (Var 4 __list_iterator3) (List (Tuple [(Integer 4 []) (Character 1 -2 () [])])) ()) (Var 4 __list_iterator4) (Tuple [(Integer 4 []) (Character 1 -2 () [])]) ()) (IntegerConstant 1 (Integer 4 [])) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ")" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator4) Lt (IntegerBinOp (ListLen (ListItem (Var 4 c) (Var 4 __list_iterator3) (List (Tuple [(Integer 4 []) (Character 1 -2 () [])])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator3) Lt (IntegerBinOp (ListLen (Var 4 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 4 __list_iterator5) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 4 b1) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 4 b1) (Var 4 __list_iterator5) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator5) Lt (IntegerBinOp (ListLen (Var 4 b1) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop ((Var 4 __list_iterator6) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 4 b2) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 4 b2) (Var 4 __list_iterator6) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator6) Lt (IntegerBinOp (ListLen (Var 4 b2) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(RealConstant 3.420000 (Real 8 [])) (StringConstant "okay" (Character 1 4 () [])) (LogicalConstant .true. (Logical 4 [])) (IntegerConstant 14483 (Integer 4 []))] () ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 7 {_lpython_main_program: (ExternalSymbol 7 _lpython_main_program 9 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 7 _lpython_main_program () [] ())])}) []) +(TranslationUnit (SymbolTable 1 {_global_symbols: (Module (SymbolTable 9 {_lpython_main_program: (Function (SymbolTable 8 {}) _lpython_main_program (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [check] [] [(SubroutineCall 9 check () [] ())] () Public .false. .false.), check: (Function (SymbolTable 6 {}) check (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [f test_nested_lists test_nested_lists2 test_print_list_tuple] [] [(SubroutineCall 9 f () [] ()) (SubroutineCall 9 test_nested_lists () [] ()) (SubroutineCall 9 test_nested_lists2 () [] ()) (SubroutineCall 9 test_print_list_tuple () [] ())] () Public .false. .false.), f: (Function (SymbolTable 2 {__list_iterator: (Variable 2 __list_iterator [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator1: (Variable 2 __list_iterator1 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator10: (Variable 2 __list_iterator10 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator11: (Variable 2 __list_iterator11 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator12: (Variable 2 __list_iterator12 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator13: (Variable 2 __list_iterator13 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator14: (Variable 2 __list_iterator14 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator15: (Variable 2 __list_iterator15 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator16: (Variable 2 __list_iterator16 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator17: (Variable 2 __list_iterator17 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator18: (Variable 2 __list_iterator18 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator2: (Variable 2 __list_iterator2 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator3: (Variable 2 __list_iterator3 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator4: (Variable 2 __list_iterator4 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator5: (Variable 2 __list_iterator5 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator6: (Variable 2 __list_iterator6 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator7: (Variable 2 __list_iterator7 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator8: (Variable 2 __list_iterator8 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator9: (Variable 2 __list_iterator9 [] Local () () Default (Integer 4 []) Source Public Required .false.), a: (Variable 2 a [] Local () () Default (List (Character 1 -2 () [])) Source Public Required .false.), b: (Variable 2 b [] Local () () Default (List (Integer 4 [])) Source Public Required .false.), c: (Variable 2 c [] Local () () Default (List (Real 8 [])) Source Public Required .false.), d: (Variable 2 d [] Local () () Default (List (Integer 4 [])) Source Public Required .false.)}) f (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 2 a) (ListConstant [(StringConstant "ab" (Character 1 2 () [])) (StringConstant "abc" (Character 1 3 () [])) (StringConstant "abcd" (Character 1 4 () []))] (List (Character 1 2 () []))) ()) (= (Var 2 b) (ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (List (Integer 4 []))) ()) (= (Var 2 c) (ListConstant [(RealConstant 1.230000 (Real 8 [])) (RealConstant 324.300000 (Real 8 [])) (RealConstant 56.431000 (Real 8 [])) (RealConstant 90.500000 (Real 8 [])) (RealConstant 34.100000 (Real 8 []))] (List (Real 8 []))) ()) (= (Var 2 d) (ListConstant [] (List (Integer 4 []))) ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator1) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 b) (Var 2 __list_iterator1) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator1) Lt (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator2) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 c) (Var 2 __list_iterator2) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator2) Lt (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator3) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 d) (Var 2 __list_iterator3) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator3) Lt (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator4) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator4) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator4) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator5) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator5) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator5) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator6) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 b) (Var 2 __list_iterator6) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator6) Lt (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator7) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 c) (Var 2 __list_iterator7) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator7) Lt (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator8) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 d) (Var 2 __list_iterator8) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator8) Lt (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator9) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator9) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator9) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator10) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator10) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator10) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(IntegerConstant 1 (Integer 4 []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator11) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 b) (Var 2 __list_iterator11) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator11) Lt (IntegerBinOp (ListLen (Var 2 b) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator12) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 c) (Var 2 __list_iterator12) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator12) Lt (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(RealConstant 1.100000 (Real 8 []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator13) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 d) (Var 2 __list_iterator13) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator13) Lt (IntegerBinOp (ListLen (Var 2 d) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator14) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListConstant [(IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])) (IntegerConstant 0 (Integer 4 []))] (List (Integer 4 []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListConstant [(IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])) (IntegerConstant 0 (Integer 4 []))] (List (Integer 4 []))) (Var 2 __list_iterator14) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator14) Lt (IntegerBinOp (ListLen (ListConstant [(IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])) (IntegerConstant 0 (Integer 4 []))] (List (Integer 4 []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator15) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListConstant [(StringConstant "a" (Character 1 1 () [])) (StringConstant "b" (Character 1 1 () [])) (StringConstant "c" (Character 1 1 () [])) (StringConstant "d" (Character 1 1 () [])) (StringConstant "e" (Character 1 1 () [])) (StringConstant "f" (Character 1 1 () []))] (List (Character 1 1 () []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (ListConstant [(StringConstant "a" (Character 1 1 () [])) (StringConstant "b" (Character 1 1 () [])) (StringConstant "c" (Character 1 1 () [])) (StringConstant "d" (Character 1 1 () [])) (StringConstant "e" (Character 1 1 () [])) (StringConstant "f" (Character 1 1 () []))] (List (Character 1 1 () []))) (Var 2 __list_iterator15) (Character 1 1 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator15) Lt (IntegerBinOp (ListLen (ListConstant [(StringConstant "a" (Character 1 1 () [])) (StringConstant "b" (Character 1 1 () [])) (StringConstant "c" (Character 1 1 () [])) (StringConstant "d" (Character 1 1 () [])) (StringConstant "e" (Character 1 1 () [])) (StringConstant "f" (Character 1 1 () []))] (List (Character 1 1 () []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator16) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (List (Integer 4 []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (List (Integer 4 []))) (Var 2 __list_iterator16) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator16) Lt (IntegerBinOp (ListLen (ListConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (List (Integer 4 []))) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator17) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 2 a) (Var 2 __list_iterator17) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator17) Lt (IntegerBinOp (ListLen (Var 2 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 2 __list_iterator18) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 2 c) (Var 2 __list_iterator18) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 2 __list_iterator18) Lt (IntegerBinOp (ListLen (Var 2 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ())] () Public .false. .false.), test_nested_lists: (Function (SymbolTable 3 {__list_iterator: (Variable 3 __list_iterator [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator1: (Variable 3 __list_iterator1 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator10: (Variable 3 __list_iterator10 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator11: (Variable 3 __list_iterator11 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator2: (Variable 3 __list_iterator2 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator3: (Variable 3 __list_iterator3 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator4: (Variable 3 __list_iterator4 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator5: (Variable 3 __list_iterator5 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator6: (Variable 3 __list_iterator6 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator7: (Variable 3 __list_iterator7 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator8: (Variable 3 __list_iterator8 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator9: (Variable 3 __list_iterator9 [] Local () () Default (Integer 4 []) Source Public Required .false.), w: (Variable 3 w [] Local () () Default (List (List (List (List (List (Real 8 [])))))) Source Public Required .false.), x: (Variable 3 x [] Local () () Default (List (List (List (Integer 4 [])))) Source Public Required .false.), y: (Variable 3 y [] Local () () Default (List (List (Real 8 []))) Source Public Required .false.), z: (Variable 3 z [] Local () () Default (List (List (Character 1 -2 () []))) Source Public Required .false.)}) test_nested_lists (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 3 w) (ListConstant [(ListConstant [(ListConstant [(ListConstant [(ListConstant [(RealConstant 2.130000 (Real 8 [])) (RealUnaryMinus (RealConstant 98.170000 (Real 8 [])) (Real 8 []) (RealConstant -98.170000 (Real 8 [])))] (List (Real 8 [])))] (List (List (Real 8 []))))] (List (List (List (Real 8 []))))) (ListConstant [(ListConstant [(ListConstant [(RealConstant 1.110000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 []))))] (List (List (List (Real 8 [])))))] (List (List (List (List (Real 8 []))))))] (List (List (List (List (List (Real 8 []))))))) ()) (= (Var 3 x) (ListConstant [(ListConstant [(ListConstant [(IntegerConstant 3 (Integer 4 [])) (IntegerUnaryMinus (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) (IntegerConstant -1 (Integer 4 [])))] (List (Integer 4 []))) (ListConstant [(IntegerUnaryMinus (IntegerConstant 2 (Integer 4 [])) (Integer 4 []) (IntegerConstant -2 (Integer 4 []))) (IntegerConstant 5 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 5 (Integer 4 []))] (List (Integer 4 [])))] (List (List (Integer 4 [])))) (ListConstant [(ListConstant [(IntegerUnaryMinus (IntegerConstant 3 (Integer 4 [])) (Integer 4 []) (IntegerConstant -3 (Integer 4 []))) (IntegerConstant 1 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 2 (Integer 4 [])) (IntegerUnaryMinus (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) (IntegerConstant -5 (Integer 4 [])))] (List (Integer 4 []))) (ListConstant [(IntegerUnaryMinus (IntegerConstant 5 (Integer 4 [])) (Integer 4 []) (IntegerConstant -5 (Integer 4 [])))] (List (Integer 4 [])))] (List (List (Integer 4 []))))] (List (List (List (Integer 4 []))))) ()) (= (Var 3 y) (ListConstant [(ListConstant [(RealConstant 3.140000 (Real 8 [])) (RealUnaryMinus (RealConstant 1.001200 (Real 8 [])) (Real 8 []) (RealConstant -1.001200 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 2.380000 (Real 8 [])) (Real 8 []) (RealConstant -2.380000 (Real 8 []))) (RealConstant 5.510000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 [])))) ()) (= (Var 3 z) (ListConstant [(ListConstant [(StringConstant "bat" (Character 1 3 () [])) (StringConstant "ball" (Character 1 4 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "cat" (Character 1 3 () [])) (StringConstant "dog" (Character 1 3 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "c" (Character 1 1 () [])) (StringConstant "c++" (Character 1 3 () [])) (StringConstant "java" (Character 1 4 () [])) (StringConstant "python" (Character 1 6 () []))] (List (Character 1 1 () [])))] (List (List (Character 1 3 () [])))) ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 3 w) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator1) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator2) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator3) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Var 3 __list_iterator2) (List (List (Real 8 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator4) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Var 3 __list_iterator2) (List (List (Real 8 []))) ()) (Var 3 __list_iterator3) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListItem (ListItem (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Var 3 __list_iterator2) (List (List (Real 8 []))) ()) (Var 3 __list_iterator3) (List (Real 8 [])) ()) (Var 3 __list_iterator4) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator4) Lt (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Var 3 __list_iterator2) (List (List (Real 8 []))) ()) (Var 3 __list_iterator3) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator3) Lt (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Var 3 __list_iterator2) (List (List (Real 8 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator2) Lt (IntegerBinOp (ListLen (ListItem (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Var 3 __list_iterator1) (List (List (List (Real 8 [])))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator1) Lt (IntegerBinOp (ListLen (ListItem (Var 3 w) (Var 3 __list_iterator) (List (List (List (List (Real 8 []))))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator) Lt (IntegerBinOp (ListLen (Var 3 w) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator5) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 3 x) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator6) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 3 x) (Var 3 __list_iterator5) (List (List (Integer 4 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator7) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (Var 3 x) (Var 3 __list_iterator5) (List (List (Integer 4 []))) ()) (Var 3 __list_iterator6) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListItem (ListItem (Var 3 x) (Var 3 __list_iterator5) (List (List (Integer 4 []))) ()) (Var 3 __list_iterator6) (List (Integer 4 [])) ()) (Var 3 __list_iterator7) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator7) Lt (IntegerBinOp (ListLen (ListItem (ListItem (Var 3 x) (Var 3 __list_iterator5) (List (List (Integer 4 []))) ()) (Var 3 __list_iterator6) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator6) Lt (IntegerBinOp (ListLen (ListItem (Var 3 x) (Var 3 __list_iterator5) (List (List (Integer 4 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator5) Lt (IntegerBinOp (ListLen (Var 3 x) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator8) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 3 y) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator9) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 3 y) (Var 3 __list_iterator8) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListItem (Var 3 y) (Var 3 __list_iterator8) (List (Real 8 [])) ()) (Var 3 __list_iterator9) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator9) Lt (IntegerBinOp (ListLen (ListItem (Var 3 y) (Var 3 __list_iterator8) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator8) Lt (IntegerBinOp (ListLen (Var 3 y) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator10) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 3 z) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 3 __list_iterator11) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 3 z) (Var 3 __list_iterator10) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (ListItem (Var 3 z) (Var 3 __list_iterator10) (List (Character 1 -2 () [])) ()) (Var 3 __list_iterator11) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator11) Lt (IntegerBinOp (ListLen (ListItem (Var 3 z) (Var 3 __list_iterator10) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 3 __list_iterator10) Lt (IntegerBinOp (ListLen (Var 3 z) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ())] () Public .false. .false.), test_nested_lists2: (Function (SymbolTable 5 {__list_iterator: (Variable 5 __list_iterator [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator1: (Variable 5 __list_iterator1 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator2: (Variable 5 __list_iterator2 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator3: (Variable 5 __list_iterator3 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator4: (Variable 5 __list_iterator4 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator5: (Variable 5 __list_iterator5 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator6: (Variable 5 __list_iterator6 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator7: (Variable 5 __list_iterator7 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator8: (Variable 5 __list_iterator8 [] Local () () Default (Integer 4 []) Source Public Required .false.), p: (Variable 5 p [] Local () () Default (List (List (Integer 4 []))) Source Public Required .false.), q: (Variable 5 q [] Local () () Default (List (List (List (List (Real 8 []))))) Source Public Required .false.), r: (Variable 5 r [] Local () () Default (List (List (List (Character 1 -2 () [])))) Source Public Required .false.)}) test_nested_lists2 (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 5 p) (ListConstant [(ListConstant [(IntegerConstant 0 (Integer 4 [])) (IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])) (IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 [])) (IntegerConstant 5 (Integer 4 [])) (IntegerConstant 6 (Integer 4 [])) (IntegerConstant 7 (Integer 4 [])) (IntegerConstant 8 (Integer 4 [])) (IntegerConstant 9 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 10 (Integer 4 [])) (IntegerConstant 11 (Integer 4 [])) (IntegerConstant 12 (Integer 4 [])) (IntegerConstant 13 (Integer 4 [])) (IntegerConstant 14 (Integer 4 [])) (IntegerConstant 15 (Integer 4 [])) (IntegerConstant 16 (Integer 4 [])) (IntegerConstant 17 (Integer 4 [])) (IntegerConstant 18 (Integer 4 [])) (IntegerConstant 19 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 20 (Integer 4 [])) (IntegerConstant 21 (Integer 4 [])) (IntegerConstant 22 (Integer 4 [])) (IntegerConstant 23 (Integer 4 [])) (IntegerConstant 24 (Integer 4 [])) (IntegerConstant 25 (Integer 4 [])) (IntegerConstant 26 (Integer 4 [])) (IntegerConstant 27 (Integer 4 [])) (IntegerConstant 28 (Integer 4 [])) (IntegerConstant 29 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 30 (Integer 4 [])) (IntegerConstant 31 (Integer 4 [])) (IntegerConstant 32 (Integer 4 [])) (IntegerConstant 33 (Integer 4 [])) (IntegerConstant 34 (Integer 4 [])) (IntegerConstant 35 (Integer 4 [])) (IntegerConstant 36 (Integer 4 [])) (IntegerConstant 37 (Integer 4 [])) (IntegerConstant 38 (Integer 4 [])) (IntegerConstant 39 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 40 (Integer 4 [])) (IntegerConstant 41 (Integer 4 [])) (IntegerConstant 42 (Integer 4 [])) (IntegerConstant 43 (Integer 4 [])) (IntegerConstant 44 (Integer 4 [])) (IntegerConstant 45 (Integer 4 [])) (IntegerConstant 46 (Integer 4 [])) (IntegerConstant 47 (Integer 4 [])) (IntegerConstant 48 (Integer 4 [])) (IntegerConstant 49 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 50 (Integer 4 [])) (IntegerConstant 51 (Integer 4 [])) (IntegerConstant 52 (Integer 4 [])) (IntegerConstant 53 (Integer 4 [])) (IntegerConstant 54 (Integer 4 [])) (IntegerConstant 55 (Integer 4 [])) (IntegerConstant 56 (Integer 4 [])) (IntegerConstant 57 (Integer 4 [])) (IntegerConstant 58 (Integer 4 [])) (IntegerConstant 59 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 60 (Integer 4 [])) (IntegerConstant 61 (Integer 4 [])) (IntegerConstant 62 (Integer 4 [])) (IntegerConstant 63 (Integer 4 [])) (IntegerConstant 64 (Integer 4 [])) (IntegerConstant 65 (Integer 4 [])) (IntegerConstant 66 (Integer 4 [])) (IntegerConstant 67 (Integer 4 [])) (IntegerConstant 68 (Integer 4 [])) (IntegerConstant 69 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 70 (Integer 4 [])) (IntegerConstant 71 (Integer 4 [])) (IntegerConstant 72 (Integer 4 [])) (IntegerConstant 73 (Integer 4 [])) (IntegerConstant 74 (Integer 4 [])) (IntegerConstant 75 (Integer 4 [])) (IntegerConstant 76 (Integer 4 [])) (IntegerConstant 77 (Integer 4 [])) (IntegerConstant 78 (Integer 4 [])) (IntegerConstant 79 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 80 (Integer 4 [])) (IntegerConstant 81 (Integer 4 [])) (IntegerConstant 82 (Integer 4 [])) (IntegerConstant 83 (Integer 4 [])) (IntegerConstant 84 (Integer 4 [])) (IntegerConstant 85 (Integer 4 [])) (IntegerConstant 86 (Integer 4 [])) (IntegerConstant 87 (Integer 4 [])) (IntegerConstant 88 (Integer 4 [])) (IntegerConstant 89 (Integer 4 []))] (List (Integer 4 []))) (ListConstant [(IntegerConstant 90 (Integer 4 [])) (IntegerConstant 91 (Integer 4 [])) (IntegerConstant 92 (Integer 4 [])) (IntegerConstant 93 (Integer 4 [])) (IntegerConstant 94 (Integer 4 [])) (IntegerConstant 95 (Integer 4 [])) (IntegerConstant 96 (Integer 4 [])) (IntegerConstant 97 (Integer 4 [])) (IntegerConstant 98 (Integer 4 [])) (IntegerConstant 99 (Integer 4 []))] (List (Integer 4 [])))] (List (List (Integer 4 [])))) ()) (= (Var 5 q) (ListConstant [(ListConstant [(ListConstant [(ListConstant [(RealConstant 74.550000 (Real 8 [])) (RealUnaryMinus (RealConstant 77.640000 (Real 8 [])) (Real 8 []) (RealConstant -77.640000 (Real 8 []))) (RealConstant 52.350000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 78.250000 (Real 8 [])) (Real 8 []) (RealConstant -78.250000 (Real 8 []))) (RealUnaryMinus (RealConstant 19.240000 (Real 8 [])) (Real 8 []) (RealConstant -19.240000 (Real 8 []))) (RealConstant 81.380000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 7.860000 (Real 8 [])) (RealConstant 12.110000 (Real 8 [])) (RealConstant 27.500000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealUnaryMinus (RealConstant 98.930000 (Real 8 [])) (Real 8 []) (RealConstant -98.930000 (Real 8 []))) (RealUnaryMinus (RealConstant 79.620000 (Real 8 [])) (Real 8 []) (RealConstant -79.620000 (Real 8 []))) (RealUnaryMinus (RealConstant 73.760000 (Real 8 [])) (Real 8 []) (RealConstant -73.760000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealConstant 42.050000 (Real 8 [])) (RealUnaryMinus (RealConstant 90.290000 (Real 8 [])) (Real 8 []) (RealConstant -90.290000 (Real 8 []))) (RealConstant 69.950000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 59.320000 (Real 8 [])) (RealUnaryMinus (RealConstant 70.780000 (Real 8 [])) (Real 8 []) (RealConstant -70.780000 (Real 8 []))) (RealUnaryMinus (RealConstant 53.220000 (Real 8 [])) (Real 8 []) (RealConstant -53.220000 (Real 8 [])))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealConstant 53.520000 (Real 8 [])) (RealUnaryMinus (RealConstant 93.880000 (Real 8 [])) (Real 8 []) (RealConstant -93.880000 (Real 8 []))) (RealConstant 49.650000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 2.180000 (Real 8 [])) (RealConstant 19.910000 (Real 8 [])) (RealConstant 69.240000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 78.510000 (Real 8 [])) (RealConstant 89.690000 (Real 8 [])) (RealUnaryMinus (RealConstant 86.680000 (Real 8 [])) (Real 8 []) (RealConstant -86.680000 (Real 8 [])))] (List (Real 8 [])))] (List (List (Real 8 []))))] (List (List (List (Real 8 []))))) (ListConstant [(ListConstant [(ListConstant [(RealUnaryMinus (RealConstant 92.480000 (Real 8 [])) (Real 8 []) (RealConstant -92.480000 (Real 8 []))) (RealUnaryMinus (RealConstant 80.750000 (Real 8 [])) (Real 8 []) (RealConstant -80.750000 (Real 8 []))) (RealUnaryMinus (RealConstant 27.760000 (Real 8 [])) (Real 8 []) (RealConstant -27.760000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 13.350000 (Real 8 [])) (Real 8 []) (RealConstant -13.350000 (Real 8 []))) (RealConstant 12.280000 (Real 8 [])) (RealConstant 79.610000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 48.480000 (Real 8 [])) (RealUnaryMinus (RealConstant 10.490000 (Real 8 [])) (Real 8 []) (RealConstant -10.490000 (Real 8 []))) (RealConstant 41.100000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealConstant 20.330000 (Real 8 [])) (RealConstant 14.520000 (Real 8 [])) (RealConstant 82.560000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 57.760000 (Real 8 [])) (Real 8 []) (RealConstant -57.760000 (Real 8 []))) (RealConstant 76.030000 (Real 8 [])) (RealConstant 67.330000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 21.500000 (Real 8 [])) (Real 8 []) (RealConstant -21.500000 (Real 8 []))) (RealUnaryMinus (RealConstant 11.920000 (Real 8 [])) (Real 8 []) (RealConstant -11.920000 (Real 8 []))) (RealUnaryMinus (RealConstant 31.840000 (Real 8 [])) (Real 8 []) (RealConstant -31.840000 (Real 8 [])))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealConstant 9.650000 (Real 8 [])) (RealConstant 11.150000 (Real 8 [])) (RealUnaryMinus (RealConstant 36.580000 (Real 8 [])) (Real 8 []) (RealConstant -36.580000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealConstant 56.550000 (Real 8 [])) (RealUnaryMinus (RealConstant 70.850000 (Real 8 [])) (Real 8 []) (RealConstant -70.850000 (Real 8 []))) (RealUnaryMinus (RealConstant 50.670000 (Real 8 [])) (Real 8 []) (RealConstant -50.670000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealConstant 94.630000 (Real 8 [])) (RealConstant 25.680000 (Real 8 [])) (RealConstant 89.300000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 []))))] (List (List (List (Real 8 []))))) (ListConstant [(ListConstant [(ListConstant [(RealConstant 28.530000 (Real 8 [])) (RealConstant 71.220000 (Real 8 [])) (RealConstant 71.870000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 58.390000 (Real 8 [])) (Real 8 []) (RealConstant -58.390000 (Real 8 []))) (RealUnaryMinus (RealConstant 6.960000 (Real 8 [])) (Real 8 []) (RealConstant -6.960000 (Real 8 []))) (RealConstant 42.980000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 8.950000 (Real 8 [])) (Real 8 []) (RealConstant -8.950000 (Real 8 []))) (RealUnaryMinus (RealConstant 75.090000 (Real 8 [])) (Real 8 []) (RealConstant -75.090000 (Real 8 []))) (RealConstant 37.960000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealUnaryMinus (RealConstant 31.750000 (Real 8 [])) (Real 8 []) (RealConstant -31.750000 (Real 8 []))) (RealConstant 67.330000 (Real 8 [])) (RealConstant 58.170000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 64.010000 (Real 8 [])) (Real 8 []) (RealConstant -64.010000 (Real 8 []))) (RealUnaryMinus (RealConstant 9.220000 (Real 8 [])) (Real 8 []) (RealConstant -9.220000 (Real 8 []))) (RealConstant 9.590000 (Real 8 []))] (List (Real 8 []))) (ListConstant [(RealConstant 15.710000 (Real 8 [])) (RealConstant 82.360000 (Real 8 [])) (RealConstant 51.180000 (Real 8 []))] (List (Real 8 [])))] (List (List (Real 8 [])))) (ListConstant [(ListConstant [(RealUnaryMinus (RealConstant 100.290000 (Real 8 [])) (Real 8 []) (RealConstant -100.290000 (Real 8 []))) (RealUnaryMinus (RealConstant 32.720000 (Real 8 [])) (Real 8 []) (RealConstant -32.720000 (Real 8 []))) (RealUnaryMinus (RealConstant 54.940000 (Real 8 [])) (Real 8 []) (RealConstant -54.940000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealUnaryMinus (RealConstant 0.320000 (Real 8 [])) (Real 8 []) (RealConstant -0.320000 (Real 8 []))) (RealConstant 68.810000 (Real 8 [])) (RealUnaryMinus (RealConstant 55.090000 (Real 8 [])) (Real 8 []) (RealConstant -55.090000 (Real 8 [])))] (List (Real 8 []))) (ListConstant [(RealConstant 97.280000 (Real 8 [])) (RealUnaryMinus (RealConstant 28.200000 (Real 8 [])) (Real 8 []) (RealConstant -28.200000 (Real 8 []))) (RealUnaryMinus (RealConstant 62.610000 (Real 8 [])) (Real 8 []) (RealConstant -62.610000 (Real 8 [])))] (List (Real 8 [])))] (List (List (Real 8 []))))] (List (List (List (Real 8 [])))))] (List (List (List (List (Real 8 [])))))) ()) (= (Var 5 r) (ListConstant [(ListConstant [(ListConstant [(StringConstant "Io" (Character 1 2 () [])) (StringConstant "tl" (Character 1 2 () [])) (StringConstant "bLvjV" (Character 1 5 () [])) (StringConstant "wjFKQ" (Character 1 5 () [])) (StringConstant "lY2" (Character 1 3 () []))] (List (Character 1 2 () []))) (ListConstant [(StringConstant "Be2l6bqE" (Character 1 8 () [])) (StringConstant "pQER3utIXA" (Character 1 10 () [])) (StringConstant "llZBJj5Cdu" (Character 1 10 () [])) (StringConstant "C8" (Character 1 2 () [])) (StringConstant "gwTr77PdYR" (Character 1 10 () []))] (List (Character 1 8 () []))) (ListConstant [(StringConstant "4M6L" (Character 1 4 () [])) (StringConstant "ktPdowqERy" (Character 1 10 () [])) (StringConstant "KSifqTkR" (Character 1 8 () [])) (StringConstant "ZE2p1N78f1" (Character 1 10 () [])) (StringConstant "Mi5e87Xw" (Character 1 8 () []))] (List (Character 1 4 () []))) (ListConstant [(StringConstant "uwfzqDq9g" (Character 1 9 () [])) (StringConstant "QaM1s" (Character 1 5 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "LB" (Character 1 2 () []))] (List (Character 1 9 () []))) (ListConstant [(StringConstant "OJFRY6k" (Character 1 7 () [])) (StringConstant "iz7Oie" (Character 1 6 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "LUYLF" (Character 1 5 () [])) (StringConstant "JBND5FuV7l" (Character 1 10 () []))] (List (Character 1 7 () [])))] (List (List (Character 1 2 () [])))) (ListConstant [(ListConstant [(StringConstant "m" (Character 1 1 () [])) (StringConstant "WIQBQfV" (Character 1 7 () [])) (StringConstant "jxjDrqxu" (Character 1 8 () [])) (StringConstant "kea" (Character 1 3 () [])) (StringConstant "mu" (Character 1 2 () []))] (List (Character 1 1 () []))) (ListConstant [(StringConstant "" (Character 1 0 () [])) (StringConstant "GI8aOwLMe" (Character 1 9 () [])) (StringConstant "Y5m8" (Character 1 4 () [])) (StringConstant "a02Rz" (Character 1 5 () [])) (StringConstant "xNKCJ" (Character 1 5 () []))] (List (Character 1 0 () []))) (ListConstant [(StringConstant "LzkhyiJQHP" (Character 1 10 () [])) (StringConstant "uzc3xyoXL" (Character 1 9 () [])) (StringConstant "sKGnYfpRy" (Character 1 9 () [])) (StringConstant "7x" (Character 1 2 () [])) (StringConstant "WTVKrnPO" (Character 1 8 () []))] (List (Character 1 10 () []))) (ListConstant [(StringConstant "TZa6" (Character 1 4 () [])) (StringConstant "GXRuyRX" (Character 1 7 () [])) (StringConstant "R" (Character 1 1 () [])) (StringConstant "JQxS" (Character 1 4 () [])) (StringConstant "OH" (Character 1 2 () []))] (List (Character 1 4 () []))) (ListConstant [(StringConstant "bSVJZ1OQ" (Character 1 8 () [])) (StringConstant "M" (Character 1 1 () [])) (StringConstant "I9omlF" (Character 1 6 () [])) (StringConstant "x7FR" (Character 1 4 () [])) (StringConstant "XtpL" (Character 1 4 () []))] (List (Character 1 8 () [])))] (List (List (Character 1 1 () [])))) (ListConstant [(ListConstant [(StringConstant "DKOpK" (Character 1 5 () [])) (StringConstant "eg8Nz" (Character 1 5 () [])) (StringConstant "ru" (Character 1 2 () [])) (StringConstant "Sj" (Character 1 2 () [])) (StringConstant "YUDxyI" (Character 1 6 () []))] (List (Character 1 5 () []))) (ListConstant [(StringConstant "Q5uyhvp" (Character 1 7 () [])) (StringConstant "Ydx" (Character 1 3 () [])) (StringConstant "p" (Character 1 1 () [])) (StringConstant "DLM5RX" (Character 1 6 () [])) (StringConstant "pwOujxCO" (Character 1 8 () []))] (List (Character 1 7 () []))) (ListConstant [(StringConstant "s5GOWnNJV" (Character 1 9 () [])) (StringConstant "af" (Character 1 2 () [])) (StringConstant "KAkD" (Character 1 4 () [])) (StringConstant "4IIZK" (Character 1 5 () [])) (StringConstant "JQK040x" (Character 1 7 () []))] (List (Character 1 9 () []))) (ListConstant [(StringConstant "9vF" (Character 1 3 () [])) (StringConstant "9pc7R8v" (Character 1 7 () [])) (StringConstant "nDReIU7" (Character 1 7 () [])) (StringConstant "K" (Character 1 1 () [])) (StringConstant "btn" (Character 1 3 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "" (Character 1 0 () [])) (StringConstant "wVeivkdi" (Character 1 8 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "C" (Character 1 1 () []))] (List (Character 1 0 () [])))] (List (List (Character 1 5 () [])))) (ListConstant [(ListConstant [(StringConstant "vNTtcRXD" (Character 1 8 () [])) (StringConstant "rsi" (Character 1 3 () [])) (StringConstant "YsoF7mZD" (Character 1 8 () [])) (StringConstant "VrPXU50rgA" (Character 1 10 () [])) (StringConstant "mG7zqN0G" (Character 1 8 () []))] (List (Character 1 8 () []))) (ListConstant [(StringConstant "la7cJ" (Character 1 5 () [])) (StringConstant "M5rLJ8Go" (Character 1 8 () [])) (StringConstant "gb" (Character 1 2 () [])) (StringConstant "FjKwYZ7E" (Character 1 8 () [])) (StringConstant "uSPD" (Character 1 4 () []))] (List (Character 1 5 () []))) (ListConstant [(StringConstant "" (Character 1 0 () [])) (StringConstant "oOa79jWcMx" (Character 1 10 () [])) (StringConstant "yyAYZZ" (Character 1 6 () [])) (StringConstant "wbvggXm" (Character 1 7 () [])) (StringConstant "aE3BkCL4" (Character 1 8 () []))] (List (Character 1 0 () []))) (ListConstant [(StringConstant "RdP" (Character 1 3 () [])) (StringConstant "Hwc0x9RZ" (Character 1 8 () [])) (StringConstant "sy" (Character 1 2 () [])) (StringConstant "9" (Character 1 1 () [])) (StringConstant "W1d9xA2BXe" (Character 1 10 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "A" (Character 1 1 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "QnK" (Character 1 3 () [])) (StringConstant "N5tzN" (Character 1 5 () [])) (StringConstant "ou7Lp" (Character 1 5 () []))] (List (Character 1 1 () [])))] (List (List (Character 1 8 () [])))) (ListConstant [(ListConstant [(StringConstant "DL68rDF" (Character 1 7 () [])) (StringConstant "v" (Character 1 1 () [])) (StringConstant "kQ3Mxm" (Character 1 6 () [])) (StringConstant "g" (Character 1 1 () [])) (StringConstant "6KTeF4Eo" (Character 1 8 () []))] (List (Character 1 7 () []))) (ListConstant [(StringConstant "Hx9" (Character 1 3 () [])) (StringConstant "Y1IzQm85Z4" (Character 1 10 () [])) (StringConstant "3D8" (Character 1 3 () [])) (StringConstant "ZLZ5" (Character 1 4 () [])) (StringConstant "rWn" (Character 1 3 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "LtT" (Character 1 3 () [])) (StringConstant "Dh5B" (Character 1 4 () [])) (StringConstant "M" (Character 1 1 () [])) (StringConstant "F" (Character 1 1 () [])) (StringConstant "QTARbY" (Character 1 6 () []))] (List (Character 1 3 () []))) (ListConstant [(StringConstant "Sh" (Character 1 2 () [])) (StringConstant "WL" (Character 1 2 () [])) (StringConstant "yvAfWvZSx1" (Character 1 10 () [])) (StringConstant "90yx" (Character 1 4 () [])) (StringConstant "v" (Character 1 1 () []))] (List (Character 1 2 () []))) (ListConstant [(StringConstant "" (Character 1 0 () [])) (StringConstant "7IBW" (Character 1 4 () [])) (StringConstant "nI" (Character 1 2 () [])) (StringConstant "" (Character 1 0 () [])) (StringConstant "6Cbp5c8RT" (Character 1 9 () []))] (List (Character 1 0 () [])))] (List (List (Character 1 7 () []))))] (List (List (List (Character 1 2 () []))))) ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 5 __list_iterator) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 5 p) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 5 __list_iterator1) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 5 p) (Var 5 __list_iterator) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListItem (Var 5 p) (Var 5 __list_iterator) (List (Integer 4 [])) ()) (Var 5 __list_iterator1) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator1) Lt (IntegerBinOp (ListLen (ListItem (Var 5 p) (Var 5 __list_iterator) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator) Lt (IntegerBinOp (ListLen (Var 5 p) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 5 __list_iterator2) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 5 q) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 5 __list_iterator3) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 5 __list_iterator4) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Var 5 __list_iterator3) (List (List (Real 8 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 5 __list_iterator5) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Var 5 __list_iterator3) (List (List (Real 8 []))) ()) (Var 5 __list_iterator4) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (ListItem (ListItem (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Var 5 __list_iterator3) (List (List (Real 8 []))) ()) (Var 5 __list_iterator4) (List (Real 8 [])) ()) (Var 5 __list_iterator5) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator5) Lt (IntegerBinOp (ListLen (ListItem (ListItem (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Var 5 __list_iterator3) (List (List (Real 8 []))) ()) (Var 5 __list_iterator4) (List (Real 8 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator4) Lt (IntegerBinOp (ListLen (ListItem (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Var 5 __list_iterator3) (List (List (Real 8 []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator3) Lt (IntegerBinOp (ListLen (ListItem (Var 5 q) (Var 5 __list_iterator2) (List (List (List (Real 8 [])))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator2) Lt (IntegerBinOp (ListLen (Var 5 q) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 5 __list_iterator6) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 5 r) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 5 __list_iterator7) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 5 r) (Var 5 __list_iterator6) (List (List (Character 1 -2 () []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 5 __list_iterator8) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (ListItem (Var 5 r) (Var 5 __list_iterator6) (List (List (Character 1 -2 () []))) ()) (Var 5 __list_iterator7) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (ListItem (ListItem (Var 5 r) (Var 5 __list_iterator6) (List (List (Character 1 -2 () []))) ()) (Var 5 __list_iterator7) (List (Character 1 -2 () [])) ()) (Var 5 __list_iterator8) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator8) Lt (IntegerBinOp (ListLen (ListItem (ListItem (Var 5 r) (Var 5 __list_iterator6) (List (List (Character 1 -2 () []))) ()) (Var 5 __list_iterator7) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator7) Lt (IntegerBinOp (ListLen (ListItem (Var 5 r) (Var 5 __list_iterator6) (List (List (Character 1 -2 () []))) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 5 __list_iterator6) Lt (IntegerBinOp (ListLen (Var 5 r) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () ())] () Public .false. .false.), test_print_list_tuple: (Function (SymbolTable 4 {__list_iterator: (Variable 4 __list_iterator [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator1: (Variable 4 __list_iterator1 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator2: (Variable 4 __list_iterator2 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator3: (Variable 4 __list_iterator3 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator4: (Variable 4 __list_iterator4 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator5: (Variable 4 __list_iterator5 [] Local () () Default (Integer 4 []) Source Public Required .false.), __list_iterator6: (Variable 4 __list_iterator6 [] Local () () Default (Integer 4 []) Source Public Required .false.), a: (Variable 4 a [] Local () () Default (List (Tuple [(Integer 4 []) (Integer 4 [])])) Source Public Required .false.), b: (Variable 4 b [] Local () () Default (Tuple [(List (Character 1 -2 () [])) (List (Integer 4 [])) (Real 8 [])]) Source Public Required .false.), b1: (Variable 4 b1 [] Local () () Default (List (Character 1 -2 () [])) Source Public Required .false.), b2: (Variable 4 b2 [] Local () () Default (List (Integer 4 [])) Source Public Required .false.), c: (Variable 4 c [] Local () () Default (List (List (Tuple [(Integer 4 []) (Character 1 -2 () [])]))) Source Public Required .false.)}) test_print_list_tuple (FunctionType [] () Source Implementation () .false. .false. .false. .false. .false. [] [] .false.) [] [] [(= (Var 4 a) (ListConstant [(TupleConstant [(IntegerConstant 1 (Integer 4 [])) (IntegerConstant 2 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 [])])) (TupleConstant [(IntegerConstant 3 (Integer 4 [])) (IntegerConstant 4 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 [])])) (TupleConstant [(IntegerConstant 5 (Integer 4 [])) (IntegerConstant 6 (Integer 4 []))] (Tuple [(Integer 4 []) (Integer 4 [])]))] (List (Tuple [(Integer 4 []) (Integer 4 [])]))) ()) (= (Var 4 c) (ListConstant [(ListConstant [(TupleConstant [(IntegerConstant 1 (Integer 4 [])) (StringConstant "a" (Character 1 1 () []))] (Tuple [(Integer 4 []) (Character 1 1 () [])])) (TupleConstant [(IntegerConstant 2 (Integer 4 [])) (StringConstant "b" (Character 1 1 () []))] (Tuple [(Integer 4 []) (Character 1 1 () [])]))] (List (Tuple [(Integer 4 []) (Character 1 1 () [])]))) (ListConstant [(TupleConstant [(IntegerConstant 3 (Integer 4 [])) (StringConstant "c" (Character 1 1 () []))] (Tuple [(Integer 4 []) (Character 1 1 () [])])) (TupleConstant [(IntegerConstant 4 (Integer 4 [])) (StringConstant "d" (Character 1 1 () []))] (Tuple [(Integer 4 []) (Character 1 1 () [])]))] (List (Tuple [(Integer 4 []) (Character 1 1 () [])])))] (List (List (Tuple [(Integer 4 []) (Character 1 1 () [])])))) ()) (= (Var 4 b1) (ListConstant [(StringConstant "a" (Character 1 1 () [])) (StringConstant "bb" (Character 1 2 () [])) (StringConstant "ccc" (Character 1 3 () [])) (StringConstant "dddd" (Character 1 4 () [])) (StringConstant "eeeee" (Character 1 5 () []))] (List (Character 1 1 () []))) ()) (= (Var 4 b2) (ListConstant [(IntegerConstant 10 (Integer 4 [])) (IntegerConstant 20 (Integer 4 [])) (IntegerConstant 30 (Integer 4 [])) (IntegerConstant 40 (Integer 4 []))] (List (Integer 4 []))) ()) (= (Var 4 b) (TupleConstant [(Var 4 b1) (Var 4 b2) (RealConstant 6.030500 (Real 8 []))] (Tuple [(List (Character 1 -2 () [])) (List (Integer 4 [])) (Real 8 [])])) ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 4 __list_iterator) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 4 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "(" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (Print () [(TupleItem (ListItem (Var 4 a) (Var 4 __list_iterator) (Tuple [(Integer 4 []) (Integer 4 [])]) ()) (IntegerConstant 0 (Integer 4 [])) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(TupleItem (ListItem (Var 4 a) (Var 4 __list_iterator) (Tuple [(Integer 4 []) (Integer 4 [])]) ()) (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ")" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator) Lt (IntegerBinOp (ListLen (Var 4 a) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "(" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 4 __list_iterator1) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (TupleItem (Var 4 b) (IntegerConstant 0 (Integer 4 [])) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (TupleItem (Var 4 b) (IntegerConstant 0 (Integer 4 [])) (List (Character 1 -2 () [])) ()) (Var 4 __list_iterator1) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator1) Lt (IntegerBinOp (ListLen (TupleItem (Var 4 b) (IntegerConstant 0 (Integer 4 [])) (List (Character 1 -2 () [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 4 __list_iterator2) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (TupleItem (Var 4 b) (IntegerConstant 1 (Integer 4 [])) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (TupleItem (Var 4 b) (IntegerConstant 1 (Integer 4 [])) (List (Integer 4 [])) ()) (Var 4 __list_iterator2) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator2) Lt (IntegerBinOp (ListLen (TupleItem (Var 4 b) (IntegerConstant 1 (Integer 4 [])) (List (Integer 4 [])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(TupleItem (Var 4 b) (IntegerConstant 2 (Integer 4 [])) (Real 8 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ")" (Character 1 1 () []))] () ()) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 4 __list_iterator3) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 4 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 4 __list_iterator4) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (ListItem (Var 4 c) (Var 4 __list_iterator3) (List (Tuple [(Integer 4 []) (Character 1 -2 () [])])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "(" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (Print () [(TupleItem (ListItem (ListItem (Var 4 c) (Var 4 __list_iterator3) (List (Tuple [(Integer 4 []) (Character 1 -2 () [])])) ()) (Var 4 __list_iterator4) (Tuple [(Integer 4 []) (Character 1 -2 () [])]) ()) (IntegerConstant 0 (Integer 4 [])) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant "'" (Character 1 1 () [])) (TupleItem (ListItem (ListItem (Var 4 c) (Var 4 __list_iterator3) (List (Tuple [(Integer 4 []) (Character 1 -2 () [])])) ()) (Var 4 __list_iterator4) (Tuple [(Integer 4 []) (Character 1 -2 () [])]) ()) (IntegerConstant 1 (Integer 4 [])) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (Print () [(StringConstant ")" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator4) Lt (IntegerBinOp (ListLen (ListItem (Var 4 c) (Var 4 __list_iterator3) (List (Tuple [(Integer 4 []) (Character 1 -2 () [])])) ()) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator3) Lt (IntegerBinOp (ListLen (Var 4 c) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 4 __list_iterator5) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 4 b1) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(StringConstant "'" (Character 1 1 () [])) (ListItem (Var 4 b1) (Var 4 __list_iterator5) (Character 1 -2 () []) ()) (StringConstant "'" (Character 1 1 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator5) Lt (IntegerBinOp (ListLen (Var 4 b1) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(StringConstant "[" (Character 1 1 () []))] () (StringConstant "" (Character 1 0 () []))) (DoLoop () ((Var 4 __list_iterator6) (IntegerConstant 0 (Integer 4 [])) (IntegerBinOp (ListLen (Var 4 b2) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (IntegerConstant 1 (Integer 4 []))) [(Print () [(ListItem (Var 4 b2) (Var 4 __list_iterator6) (Integer 4 []) ())] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () []))) (If (IntegerCompare (Var 4 __list_iterator6) Lt (IntegerBinOp (ListLen (Var 4 b2) (Integer 4 []) ()) Sub (IntegerConstant 1 (Integer 4 [])) (Integer 4 []) ()) (Logical 4 []) ()) [(Print () [(StringConstant ", " (Character 1 2 () []))] (StringConstant "" (Character 1 0 () [])) (StringConstant "" (Character 1 0 () [])))] [])]) (Print () [(StringConstant "]" (Character 1 1 () []))] () (StringConstant " " (Character 1 1 () []))) (Print () [(RealConstant 3.420000 (Real 8 [])) (StringConstant "okay" (Character 1 4 () [])) (LogicalConstant .true. (Logical 4 [])) (IntegerConstant 14483 (Integer 4 []))] () ())] () Public .false. .false.)}) _global_symbols [] .false. .false.), main_program: (Program (SymbolTable 7 {_lpython_main_program: (ExternalSymbol 7 _lpython_main_program 9 _lpython_main_program _global_symbols [] _lpython_main_program Public)}) main_program [_global_symbols] [(SubroutineCall 7 _lpython_main_program () [] ())])}) [])