feat: us const & and std::move

libs/int2048/CMakeLists.txt

@@ -1,4 +1,4 @@
 set(PROJECT_NAME ${CMAKE_PROJECT_NAME})
 set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_FLAGS "-O2")
+set(CMAKE_CXX_FLAGS "-Ofast")
 add_library(int2048 STATIC int2048.cpp)

src/Evalvisitor.cpp

@@ -12,14 +12,14 @@ VariableContainer Variables;
 FucntionContainer Functions;
 
 std::any EvalVisitor::visitFile_input(Python3Parser::File_inputContext *ctx) {
-  return visitChildren(ctx);
+  return std::move(visitChildren(ctx));
 }
 
 std::any EvalVisitor::visitFuncdef(Python3Parser::FuncdefContext *ctx) {
   std::vector<ParaArguItemType> paraVec =
       std::any_cast<std::vector<ParaArguItemType>>(
           visitParameters(ctx->parameters()));
-  std::string name = ctx->NAME()->getText();
+  std::string name = std::move(ctx->NAME()->getText());
   Functions.AddFunction(name, FunctionItem(ctx->suite(), paraVec));
   return NoneType();
 }
@@ -28,13 +28,13 @@ std::any EvalVisitor::visitParameters(Python3Parser::ParametersContext *ctx) {
   if (!ctx->typedargslist())
     return std::vector<ParaArguItemType>();
   else
-    return visitTypedargslist(ctx->typedargslist());
+    return std::move(visitTypedargslist(ctx->typedargslist()));
 }
 
 std::any EvalVisitor::visitTypedargslist(
     Python3Parser::TypedargslistContext *ctx) {
-  auto tfpdef_list = ctx->tfpdef();
+  const auto &tfpdef_list = ctx->tfpdef();
-  auto default_value_list = ctx->test();
+  const auto &default_value_list = ctx->test();
   const int lenght_delta = tfpdef_list.size() - default_value_list.size();
   std::vector<ParaArguItemType> res;
   res.reserve(tfpdef_list.size());
@@ -44,36 +44,37 @@ std::any EvalVisitor::visitTypedargslist(
     res.emplace_back(tfpdef_list[i]->NAME()->getText(),
                      DeQuate(visitTest(default_value_list[i - lenght_delta]),
                              Variables));
-  return res;
+  return std::move(res);
 }
 
 std::any EvalVisitor::visitTfpdef(Python3Parser::TfpdefContext *ctx) {
-  return ctx->NAME()->getText();
+  return std::move(ctx->NAME()->getText());
 }
 
 std::any EvalVisitor::visitStmt(Python3Parser::StmtContext *ctx) {
-  if (ctx->compound_stmt()) return visitCompound_stmt(ctx->compound_stmt());
+  if (ctx->compound_stmt())
-  return visitSimple_stmt(ctx->simple_stmt());
+    return std::move(visitCompound_stmt(ctx->compound_stmt()));
+  return std::move(visitSimple_stmt(ctx->simple_stmt()));
 }
 
 std::any EvalVisitor::visitSimple_stmt(Python3Parser::Simple_stmtContext *ctx) {
-  return visitSmall_stmt(ctx->small_stmt());
+  return std::move(visitSmall_stmt(ctx->small_stmt()));
 }
 
 std::any EvalVisitor::visitSmall_stmt(Python3Parser::Small_stmtContext *ctx) {
   if (ctx->expr_stmt())
-    return visitExpr_stmt(ctx->expr_stmt());
+    return std::move(visitExpr_stmt(ctx->expr_stmt()));
   else
-    return visitFlow_stmt(ctx->flow_stmt());
+    return std::move(visitFlow_stmt(ctx->flow_stmt()));
 }
 
 std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
   if (!ctx->augassign() && !ctx->ASSIGN(0))
-    return visitTestlist(ctx->testlist(0));
+    return std::move(visitTestlist(ctx->testlist(0)));
   if (ctx->augassign()) {
-    auto left_value = visitTestlist(ctx->testlist(0));
+    auto left_value = std::move(visitTestlist(ctx->testlist(0)));
-    auto right_value = visitTestlist(ctx->testlist(1));
+    auto right_value = std::move(visitTestlist(ctx->testlist(1)));
-    right_value = DeQuate(right_value, Variables);
+    right_value = std::move(DeQuate(right_value, Variables));
     RawVarible *ptr_var = std::any_cast<RawVarible>(&left_value);
     std::vector<std::any> *ptr_vec =
         std::any_cast<std::vector<std::any>>(&left_value);
@@ -83,7 +84,7 @@ std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
           "augassign",
           1);
     if (ptr_var) {
-      std::any old_val = DeQuate(*ptr_var, Variables);
+      std::any old_val = std::move(DeQuate(*ptr_var, Variables));
       if (ctx->augassign()->ADD_ASSIGN())
         SelfAdd(old_val, right_value);
       else if (ctx->augassign()->SUB_ASSIGN())
@@ -108,7 +109,7 @@ std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
         if (!ptr_var)
           throw InterpretException(
               "visitExpr_stmt: Expect left value at the left of augassign", 4);
-        std::any old_val = DeQuate(*ptr_var, Variables);
+        std::any old_val = std::move(DeQuate(*ptr_var, Variables));
         if (ctx->augassign()->ADD_ASSIGN())
           SelfAdd(old_val,
                   std::any_cast<std::vector<std::any>>(right_value)[i]);
@@ -134,11 +135,11 @@ std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
     }
     return NoneType();
   }
-  auto testlist_list = ctx->testlist();
+  const auto &testlist_list = ctx->testlist();
-  auto val = visitTestlist(testlist_list[testlist_list.size() - 1]);
+  auto val = std::move(visitTestlist(testlist_list[testlist_list.size() - 1]));
-  val = DeQuate(val, Variables);
+  val = std::move(DeQuate(val, Variables));
   for (int i = testlist_list.size() - 2; i >= 0; i--) {
-    auto dest = visitTestlist(testlist_list[i]);
+    auto dest = std::move(visitTestlist(testlist_list[i]));
     RawVarible *ptr_dest_single = std::any_cast<RawVarible>(&dest);
     std::vector<std::any> *ptr_dest_tuple =
         std::any_cast<std::vector<std::any>>(&dest);
@@ -169,9 +170,11 @@ std::any EvalVisitor::visitAugassign(Python3Parser::AugassignContext *ctx) {
 }
 
 std::any EvalVisitor::visitFlow_stmt(Python3Parser::Flow_stmtContext *ctx) {
-  if (ctx->break_stmt()) return visitBreak_stmt(ctx->break_stmt());
+  if (ctx->break_stmt()) return std::move(visitBreak_stmt(ctx->break_stmt()));
-  if (ctx->continue_stmt()) return visitContinue_stmt(ctx->continue_stmt());
+  if (ctx->continue_stmt())
-  if (ctx->return_stmt()) return visitReturn_stmt(ctx->return_stmt());
+    return std::move(visitContinue_stmt(ctx->continue_stmt()));
+  if (ctx->return_stmt())
+    return std::move(visitReturn_stmt(ctx->return_stmt()));
   throw FatalError("Unknown flow statement", 10);
   return NoneType();
 }
@@ -187,49 +190,49 @@ std::any EvalVisitor::visitContinue_stmt(
 
 std::any EvalVisitor::visitReturn_stmt(Python3Parser::Return_stmtContext *ctx) {
   if (!ctx->testlist()) return FlowType(RETURN, std::vector<std::any>());
-  std::any val = visitTestlist(ctx->testlist());
+  std::any val = std::move(visitTestlist(ctx->testlist()));
-  val = DeQuate(val, Variables);
+  val = std::move(DeQuate(val, Variables));
   std::vector<std::any> *val_ptr = std::any_cast<std::vector<std::any>>(&val);
   if (val_ptr) return FlowType(RETURN, *val_ptr);
   std::vector<std::any> tmp;
   tmp.push_back(val);
   // std::cerr << "ready to send return value" << Any2String(val) << std::endl;
-  return FlowType(RETURN, tmp);
+  return std::move(FlowType(RETURN, tmp));
 }
 
 std::any EvalVisitor::visitCompound_stmt(
     Python3Parser::Compound_stmtContext *ctx) {
-  if (ctx->if_stmt()) return visitIf_stmt(ctx->if_stmt());
+  if (ctx->if_stmt()) return std::move(visitIf_stmt(ctx->if_stmt()));
-  if (ctx->while_stmt()) return visitWhile_stmt(ctx->while_stmt());
+  if (ctx->while_stmt()) return std::move(visitWhile_stmt(ctx->while_stmt()));
-  if (ctx->funcdef()) return visitFuncdef(ctx->funcdef());
+  if (ctx->funcdef()) return std::move(visitFuncdef(ctx->funcdef()));
   throw FatalError("Unknown compound statement", 11);
   return NoneType();
 }
 
 std::any EvalVisitor::visitIf_stmt(Python3Parser::If_stmtContext *ctx) {
-  auto test_list = ctx->test();
+  const auto &test_list = ctx->test();
-  auto suite_list = ctx->suite();
+  const auto &suite_list = ctx->suite();
   if (test_list.size() - suite_list.size() != -1 &&
       test_list.size() - suite_list.size() != 0)
     throw InterpretException("test and suite doesn't match in If_stmt", 12);
   for (int i = 0; i < test_list.size(); i++)
     if (Any2Bool(DeQuate(visitTest(test_list[i]), Variables)))
-      return visitSuite(suite_list[i]);
+      return std::move(visitSuite(suite_list[i]));
   if (test_list.size() - suite_list.size() == -1)
-    return visitSuite(suite_list[suite_list.size() - 1]);
+    return std::move(visitSuite(suite_list[suite_list.size() - 1]));
   return NoneType();
 }
 
 std::any EvalVisitor::visitWhile_stmt(Python3Parser::While_stmtContext *ctx) {
-  auto test = ctx->test();
+  const auto &test = ctx->test();
-  auto suite = ctx->suite();
+  const auto &suite = ctx->suite();
   while (Any2Bool(DeQuate(visitTest(test), Variables))) {
-    auto res = visitSuite(suite);
+    auto res = std::move(visitSuite(suite));
     FlowType *res_ptr = std::any_cast<FlowType>(&res);
     if (res_ptr) {
       if (res_ptr->Status == BREAK) break;
       if (res_ptr->Status == CONTINUE) continue;
-      if (res_ptr->Status == RETURN) return *res_ptr;
+      if (res_ptr->Status == RETURN) return std::move(*res_ptr);
     }
   }
   return NoneType();
@@ -237,31 +240,31 @@ std::any EvalVisitor::visitWhile_stmt(Python3Parser::While_stmtContext *ctx) {
 
 std::any EvalVisitor::visitSuite(Python3Parser::SuiteContext *ctx) {
   if (ctx->simple_stmt()) return visitSimple_stmt(ctx->simple_stmt());
-  auto stmt_list = ctx->stmt();
+  const auto &stmt_list = ctx->stmt();
   std::any res;
   for (int i = 0; i < stmt_list.size(); i++) {
-    res = visitStmt(stmt_list[i]);
+    res = std::move(visitStmt(stmt_list[i]));
     FlowType *res_ptr = std::any_cast<FlowType>(&res);
-    if (res_ptr) return res;
+    if (res_ptr) return std::move(res);
   }
-  return res;
+  return std::move(res);
 }
 std::any EvalVisitor::visitTestlist(Python3Parser::TestlistContext *ctx) {
-  auto test_list = ctx->test();
+  const auto &test_list = ctx->test();
-  if (test_list.size() == 1) return visitTest(test_list[0]);
+  if (test_list.size() == 1) return std::move(visitTest(test_list[0]));
   std::vector<std::any> res;
   for (auto item : test_list) {
     res.push_back(visitTest(item));
   }
-  return res;
+  return std::move(res);
 }
 std::any EvalVisitor::visitTest(Python3Parser::TestContext *ctx) {
-  return visitOr_test(ctx->or_test());
+  return std::move(visitOr_test(ctx->or_test()));
 }
 
 std::any EvalVisitor::visitOr_test(Python3Parser::Or_testContext *ctx) {
-  auto or_list = ctx->and_test();
+  const auto &or_list = ctx->and_test();
-  if (or_list.size() == 1) return visitAnd_test(or_list[0]);
+  if (or_list.size() == 1) return std::move(visitAnd_test(or_list[0]));
   for (auto or_item : or_list) {
     if (Any2Bool(DeQuate(visitAnd_test(or_item), Variables))) return true;
   }
@@ -269,8 +272,8 @@ std::any EvalVisitor::visitOr_test(Python3Parser::Or_testContext *ctx) {
 }
 
 std::any EvalVisitor::visitAnd_test(Python3Parser::And_testContext *ctx) {
-  auto not_list = ctx->not_test();
+  const auto &not_list = ctx->not_test();
-  if (not_list.size() == 1) return visitNot_test(not_list[0]);
+  if (not_list.size() == 1) return std::move(visitNot_test(not_list[0]));
   for (auto not_item : not_list) {
     if (!Any2Bool(DeQuate(visitNot_test(not_item), Variables))) return false;
   }
@@ -278,19 +281,19 @@ std::any EvalVisitor::visitAnd_test(Python3Parser::And_testContext *ctx) {
 }
 
 std::any EvalVisitor::visitNot_test(Python3Parser::Not_testContext *ctx) {
-  if (!ctx->NOT()) return visitComparison(ctx->comparison());
+  if (!ctx->NOT()) return std::move(visitComparison(ctx->comparison()));
   return !Any2Bool(DeQuate(visitNot_test(ctx->not_test()), Variables));
 }
 
 std::any EvalVisitor::visitComparison(Python3Parser::ComparisonContext *ctx) {
-  auto arith_expr_list = ctx->arith_expr();
+  const auto &arith_expr_list = ctx->arith_expr();
-  auto last_val = visitArith_expr(arith_expr_list[0]);
+  auto last_val = std::move(visitArith_expr(arith_expr_list[0]));
-  if (arith_expr_list.size() == 1) return last_val;
+  if (arith_expr_list.size() == 1) return std::move(last_val);
-  last_val = DeQuate(last_val, Variables);
+  last_val = std::move(DeQuate(last_val, Variables));
   auto op_list = ctx->comp_op();
   for (int i = 0; i < op_list.size(); i++) {
-    auto cur = visitArith_expr(arith_expr_list[i + 1]);
+    auto cur = std::move(visitArith_expr(arith_expr_list[i + 1]));
-    cur = DeQuate(cur, Variables);
+    cur = std::move(DeQuate(cur, Variables));
     bool ok = false;
     if (op_list[i]->GREATER_THAN())
       ok = Greater(last_val, cur);
@@ -307,7 +310,7 @@ std::any EvalVisitor::visitComparison(Python3Parser::ComparisonContext *ctx) {
     else
       throw InterpretException("visitComparison: Unknown operator", 13);
     if (!ok) return false;
-    last_val = cur;
+    last_val = std::move(cur);
   }
   return true;
 }
@@ -317,14 +320,14 @@ std::any EvalVisitor::visitComp_op(Python3Parser::Comp_opContext *ctx) {
 }
 
 std::any EvalVisitor::visitArith_expr(Python3Parser::Arith_exprContext *ctx) {
-  auto term_list = ctx->term();
+  const auto &term_list = ctx->term();
-  auto ans = visitTerm(term_list[0]);
+  auto ans = std::move(visitTerm(term_list[0]));
-  if (term_list.size() == 1) return ans;
+  if (term_list.size() == 1) return std::move(ans);
-  auto op_list = ctx->addorsub_op();
+  const auto &op_list = ctx->addorsub_op();
-  ans = DeQuate(ans, Variables);
+  ans = std::move(DeQuate(ans, Variables));
   for (int i = 0; i < op_list.size(); i++) {
     auto cur = visitTerm(term_list[i + 1]);
-    cur = DeQuate(cur, Variables);
+    cur = std::move(DeQuate(cur, Variables));
     if (op_list[i]->ADD())
       SelfAdd(ans, cur);
     else if (op_list[i]->MINUS())
@@ -332,7 +335,7 @@ std::any EvalVisitor::visitArith_expr(Python3Parser::Arith_exprContext *ctx) {
     else
       throw FatalError("visitArith_expr: Unknown operator", 15);
   }
-  return ans;
+  return std::move(ans);
 }
 
 std::any EvalVisitor::visitAddorsub_op(Python3Parser::Addorsub_opContext *ctx) {
@@ -340,14 +343,14 @@ std::any EvalVisitor::visitAddorsub_op(Python3Parser::Addorsub_opContext *ctx) {
 }
 
 std::any EvalVisitor::visitTerm(Python3Parser::TermContext *ctx) {
-  auto factor_list = ctx->factor();
+  const auto &factor_list = ctx->factor();
-  auto ans = visitFactor(factor_list[0]);
+  auto ans = std::move(visitFactor(factor_list[0]));
-  if (factor_list.size() == 1) return ans;
+  if (factor_list.size() == 1) return std::move(ans);
   auto op_list = ctx->muldivmod_op();
-  ans = DeQuate(ans, Variables);
+  ans = std::move(DeQuate(ans, Variables));
   for (int i = 0; i < op_list.size(); i++) {
-    auto cur = visitFactor(factor_list[i + 1]);
+    auto cur = std::move(visitFactor(factor_list[i + 1]));
-    cur = DeQuate(cur, Variables);
+    cur = std::move(DeQuate(cur, Variables));
     if (op_list[i]->STAR())
       SelfMul(ans, cur);
     else if (op_list[i]->DIV())
@@ -359,7 +362,7 @@ std::any EvalVisitor::visitTerm(Python3Parser::TermContext *ctx) {
     else
       throw FatalError("visitTerm: Unknown operator", 17);
   }
-  return ans;
+  return std::move(ans);
 }
 
 std::any EvalVisitor::visitMuldivmod_op(
@@ -368,45 +371,47 @@ std::any EvalVisitor::visitMuldivmod_op(
 }
 
 std::any EvalVisitor::visitFactor(Python3Parser::FactorContext *ctx) {
-  if (ctx->atom_expr()) return visitAtom_expr(ctx->atom_expr());
+  if (ctx->atom_expr()) return std::move(visitAtom_expr(ctx->atom_expr()));
-  std::any res = visitFactor(ctx->factor());
+  std::any res = std::move(visitFactor(ctx->factor()));
-  res = DeQuate(res, Variables);
+  res = std::move(DeQuate(res, Variables));
-  if (ctx->MINUS()) res = Neg(res);
+  if (ctx->MINUS()) res = std::move(Neg(res));
-  return res;
+  return std::move(res);
 }
 
 std::any EvalVisitor::visitAtom_expr(Python3Parser::Atom_exprContext *ctx) {
-  if (!ctx->trailer()) return visitAtom(ctx->atom());
+  if (!ctx->trailer()) return std::move(visitAtom(ctx->atom()));
-  std::string func_name = ctx->atom()->NAME()->getText();
+  std::string func_name = std::move(ctx->atom()->NAME()->getText());
   std::vector<ParaArguItemType> args =
-      std::any_cast<std::vector<ParaArguItemType>>(
+      std::move(std::any_cast<std::vector<ParaArguItemType>>(
-          visitTrailer(ctx->trailer()));
+          std::move(visitTrailer(ctx->trailer()))));
-  return Functions.CallFunction(func_name, args, Variables);
+  return std::move(Functions.CallFunction(func_name, args, Variables));
 }
 
 std::any EvalVisitor::visitTrailer(Python3Parser::TrailerContext *ctx) {
   if (!ctx->arglist()) return std::vector<ParaArguItemType>();
-  return visitArglist(ctx->arglist());
+  return std::move(visitArglist(ctx->arglist()));
 }
 std::any EvalVisitor::visitArglist(Python3Parser::ArglistContext *ctx) {
-  auto argument_list = ctx->argument();
+  const auto &argument_list = ctx->argument();
   std::vector<ParaArguItemType> resolved_args;
   for (auto item : argument_list) {
     resolved_args.push_back(
         std::any_cast<ParaArguItemType>(visitArgument(item)));
   }
-  return resolved_args;
+  return std::move(resolved_args);
 }
 
 std::any EvalVisitor::visitArgument(Python3Parser::ArgumentContext *ctx) {
-  auto arg_list = ctx->test();
+  const auto & arg_list = ctx->test();
   if (arg_list.size() != 1 && arg_list.size() != 2)
     throw FatalError("visitArgument: arg_list.size()!=1&&arg_list!=2", 19);
   if (arg_list.size() == 1)
-    return ParaArguItemType("", DeQuate(visitTest(arg_list[0]), Variables));
+    return std::move(
+        ParaArguItemType("", DeQuate(visitTest(arg_list[0]), Variables)));
   else
-    return ParaArguItemType(arg_list[0]->getText(),
+    return std::move(
-                            DeQuate(visitTest(arg_list[1]), Variables));
+        ParaArguItemType(arg_list[0]->getText(),
+                         DeQuate(visitTest(arg_list[1]), Variables)));
 }
 std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
   if (ctx->NONE())
@@ -422,9 +427,9 @@ std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
     else
       return std::stod(num);
   } else if (ctx->test())
-    return visitTest(ctx->test());
+    return std::move(visitTest(ctx->test()));
   else if (ctx->NAME()) {
-    return RawVarible(ctx->getText());
+    return std::move(RawVarible(ctx->getText()));
   } else {
     auto string_lists = ctx->STRING();
     std::string res;
@@ -433,6 +438,6 @@ std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
       res.append(tmp, 1, tmp.size() - 2);
     }
     // std::cerr<<"[Log] The string is : "<<res<<std::endl;
-    return res;
+    return std::move(res);
   }
 }

src/names.cpp

@@ -56,7 +56,7 @@ std::any FucntionContainer::CallFunction(const std::string &name,
       is_first = false;
       double *value_ptr = std::any_cast<double>(&args[i].value);
       if (!value_ptr) {
-        std::string buf = Any2String(args[i].value);
+        std::string buf = std::move(Any2String(args[i].value));
         std::cout << buf;
       } else
         std::cout << std::fixed << std::setprecision(6) << *value_ptr;
@@ -67,10 +67,10 @@ std::any FucntionContainer::CallFunction(const std::string &name,
     if (args.size() != 1)
       throw InterpretException(
           "CallFunction: str() should take exactly one argument", 23);
-    return Any2String(args[0].value);
+    return std::move(Any2String(args[0].value));
   } else if (name == "int") {
     if (args.size() == 1) {
-      return Any2Int(args[0].value);
+      return std::move(Any2Int(args[0].value));
     } else {
       throw InterpretException(
           "CallFunction: int() should take exactly one argument", 24);
@@ -128,7 +128,7 @@ std::any FucntionContainer::CallFunction(const std::string &name,
     args_with_data.insert(func.para_list[i].name);
   }
   EvalVisitor vis;
-  std::any res = vis.visit(func.code_address);
+  std::any res = std::move(vis.visit(func.code_address));
   Variables.DestroyFrame();
   // std::cerr << "function called " << std::endl;
   FlowType *flow = std::any_cast<FlowType>(&res);
@@ -136,9 +136,9 @@ std::any FucntionContainer::CallFunction(const std::string &name,
     if (flow->ReturnValueLists.size() == 0)
       return NoneType();
     else if (flow->ReturnValueLists.size() == 1)
-      return flow->ReturnValueLists[0];
+      return std::move(flow->ReturnValueLists[0]);
     else
-      return flow->ReturnValueLists;
+      return std::move(flow->ReturnValueLists);
   }
   // std::cerr<<"Return value isn't FlowType"<<std::endl;
   return NoneType();

src/utils.cpp

@@ -23,11 +23,11 @@ inline ZYM::int2048 Any2Int(const std::any &value) {
   } else if (auto ptr = std::any_cast<bool>(&value))
     return std::move(ZYM::int2048((long long)(*ptr)));
   else if (auto ptr = std::any_cast<std::string>(&value)) {
-    std::string str = *ptr;
+    std::string str = std::move(*ptr);
     size_t dot_position = str.find('.');
     if (dot_position != std::string::npos) {
-      std::string integer_part = str.substr(0, dot_position);
+      std::string integer_part = std::move(str.substr(0, dot_position));
-      str = integer_part;
+      str = std::move(integer_part);
     }
     return std::move(ZYM::int2048(str));
   } else if (auto ptr = std::any_cast<NoneType>(&value))
@@ -103,7 +103,7 @@ std::string Any2String(const std::any &value) {
   else
     throw FatalError("Any2String: unknown type", 31);
   std::getline(buf, res);
-  return res;
+  return std::move(res);
 }
 
 /**
@@ -148,14 +148,14 @@ bool Any2Bool(const std::any &value) {
 std::any DeQuate(std::any val, VariableContainer &Variables) {
   if (auto ptr = std::any_cast<std::vector<std::any>>(&val)) {
     for (int i = 0; i < ptr->size(); i++)
-      (*ptr)[i] = DeQuate((*ptr)[i], Variables);
+      (*ptr)[i] = std::move(DeQuate((*ptr)[i], Variables));
-    return *ptr;
+    return std::move(*ptr);
   } else if (auto ptr = std::any_cast<RawVarible>(&val)) {
-    return Variables.ReadVariable(ptr->name);
+    return std::move(Variables.ReadVariable(ptr->name));
   } else if (std::any_cast<double>(&val) || std::any_cast<ZYM::int2048>(&val) ||
              std::any_cast<bool>(&val) || std::any_cast<std::string>(&val) ||
              std::any_cast<NoneType>(&val))
-    return val;
+    return std::move(val);
   else
     return NoneType();
   // throw FatalError("DeQuate: unknown type");
@@ -211,8 +211,8 @@ int ConverToSameArithType(std::any &a, std::any &b,
     case 1:
       break;
     case 2:
-      a = Any2Int(a);
+      a = std::move(Any2Int(a));
-      b = Any2Int(b);
+      b = std::move(Any2Int(b));
       break;
     case 3:
       a = Any2Float(a);
@@ -249,17 +249,17 @@ std::any Add(std::any a, std::any b) {
   std::string *ptr_b_string = std::any_cast<std::string>(&b);
   if ((ptr_a_string != nullptr ? 1 : 0) + (ptr_b_string != nullptr ? 1 : 0) ==
       2)
-    return (*ptr_a_string) + (*ptr_b_string);
+    return std::move((*ptr_a_string) + (*ptr_b_string));
   if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr))
-    return ZYM::int2048(int(*ptr_a_bool) + int(*ptr_b_bool));
+    return std::move(ZYM::int2048(int(*ptr_a_bool) + int(*ptr_b_bool)));
   else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr))
-    return (*ptr_a_int2048) + (*ptr_b_int2048);
+    return std::move((*ptr_a_int2048) + (*ptr_b_int2048));
   else if ((ptr_a_float != nullptr) && (ptr_b_float != nullptr)) {
     double tmp = (*ptr_a_float) + (*ptr_b_float);
     if (tmp > -1e-8 && tmp < 0) tmp = 0;
     return tmp;
   } else if ((ptr_a_string != nullptr) || (ptr_b_string != nullptr))
-    return Any2String(a) + Any2String(b);
+    return std::move(Any2String(a) + Any2String(b));
   else
     throw FatalError("Add: Type Error", 38);
 }
@@ -290,9 +290,9 @@ std::any Sub(std::any a, std::any b) {
   double *ptr_a_float = std::any_cast<double>(&a);
   double *ptr_b_float = std::any_cast<double>(&b);
   if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr))
-    return ZYM::int2048(int(*ptr_a_bool) - int(*ptr_b_bool));
+    return std::move(ZYM::int2048(int(*ptr_a_bool) - int(*ptr_b_bool)));
   else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr))
-    return (*ptr_a_int2048) - (*ptr_b_int2048);
+    return std::move((*ptr_a_int2048) - (*ptr_b_int2048));
   else if ((ptr_a_float != nullptr) && (ptr_b_float != nullptr)) {
     double tmp = (*ptr_a_float) - (*ptr_b_float);
     if (tmp > -1e-8 && tmp < 0) tmp = 0;
@@ -345,20 +345,20 @@ std::any Mul(std::any a, std::any b) {
       ptr_b_string = std::any_cast<std::string>(&b);
     }
     if (Less(b, ZYM::int2048(0))) {
-      b = Neg(b);
+      b = std::move(Neg(b));
       ptr_b_bool = std::any_cast<bool>(&b);
       ptr_b_int2048 = std::any_cast<ZYM::int2048>(&b);
       ptr_b_float = std::any_cast<double>(&b);
       ptr_b_string = std::any_cast<std::string>(&b);
     }
     if (ptr_b_float != nullptr) {
-      b = Any2Int(*ptr_b_float);
+      b = std::move(Any2Int(*ptr_b_float));
       ptr_b_int2048 = std::any_cast<ZYM::int2048>(&b);
       goto st;
     }
     if (ptr_b_bool != nullptr) {
       if (*ptr_b_bool) {
-        return *ptr_a_string;
+        return std::move(*ptr_a_string);
       } else {
         return std::string("");
       }
@@ -370,7 +370,7 @@ std::any Mul(std::any a, std::any b) {
     st:;
       std::string res;
       for (int i = 0; i < (*ptr_b_int2048); i++) res += *ptr_a_string;
-      return res;
+      return std::move(res);
     }
   }
   if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr))
@@ -449,9 +449,9 @@ std::any Divv(std::any a, std::any b) {
     if (tmp > -1e-8 && tmp < 0) tmp = 0;
     return tmp;
   } else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr)) {
-      return (*ptr_a_int2048) / (*ptr_b_int2048);
+    return std::move((*ptr_a_int2048) / (*ptr_b_int2048));
   } else if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr)) {
-      return ZYM::int2048(int(*ptr_a_bool) / int(*ptr_b_bool));
+    return ZYM::int2048(int(*ptr_a_bool) / int(*ptr_b_bool));
   } else
     throw FatalError("Divv: Type Error", 48);
 }
@@ -486,40 +486,40 @@ std::any Mod(std::any a, std::any b) {
     if (tmp > -1e-8 && tmp < 0) tmp = 0;
     return tmp;
   } else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr))
-    return (*ptr_a_int2048) % (*ptr_b_int2048);
+    return std::move((*ptr_a_int2048) % (*ptr_b_int2048));
   else if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr))
-    return ZYM::int2048(int(*ptr_a_bool) % int(*ptr_b_bool));
+    return std::move(ZYM::int2048(int(*ptr_a_bool) % int(*ptr_b_bool)));
   else
     throw FatalError("Mod: Type Error", 52);
 }
 
 std::any &SelfAdd(std::any &a, std::any b) {
-  a = Add(a, b);
+  a = std::move(Add(a, b));
   return a;
 }
 
 std::any &SelfSub(std::any &a, std::any b) {
-  a = Sub(a, b);
+  a = std::move(Sub(a, b));
   return a;
 }
 
 std::any &SelfMul(std::any &a, std::any b) {
-  a = Mul(a, b);
+  a = std::move(Mul(a, b));
   return a;
 }
 
 std::any &SelfDiv(std::any &a, std::any b) {
-  a = Div(a, b);
+  a = std::move(Div(a, b));
   return a;
 }
 
 std::any &SelfDivv(std::any &a, std::any b) {
-  a = Divv(a, b);
+  a = std::move(Divv(a, b));
   return a;
 }
 
 std::any &SelfMod(std::any &a, std::any b) {
-  a = Mod(a, b);
+  a = std::move(Mod(a, b));
   return a;
 }
 
@@ -542,7 +542,7 @@ std::any Neg(std::any a) {
   if (ptr_a_bool != nullptr)
     return ZYM::int2048(-(*ptr_a_bool));
   else if (ptr_a_int2048 != nullptr)
-    return -(*ptr_a_int2048);
+    return std::move(-(*ptr_a_int2048));
   else if (ptr_a_float != nullptr)
     return -(*ptr_a_float);
   else