diff --git a/src/Evalvisitor.cpp b/src/Evalvisitor.cpp
index 8bd0f20..568bd0e 100644
--- a/src/Evalvisitor.cpp
+++ b/src/Evalvisitor.cpp
@@ -12,14 +12,14 @@ VariableContainer Variables;
 FucntionContainer Functions;
 
 std::any EvalVisitor::visitFile_input(Python3Parser::File_inputContext *ctx) {
-  return std::move(visitChildren(ctx));
+  return 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 = std::move(ctx->NAME()->getText());
+  std::string name = 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 std::move(visitTypedargslist(ctx->typedargslist()));
+    return visitTypedargslist(ctx->typedargslist());
 }
 
 std::any EvalVisitor::visitTypedargslist(
     Python3Parser::TypedargslistContext *ctx) {
-  const auto &tfpdef_list = ctx->tfpdef();
-  const auto &default_value_list = ctx->test();
+  auto tfpdef_list = ctx->tfpdef();
+  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,37 +44,36 @@ std::any EvalVisitor::visitTypedargslist(
     res.emplace_back(tfpdef_list[i]->NAME()->getText(),
                      DeQuate(visitTest(default_value_list[i - lenght_delta]),
                              Variables));
-  return std::move(res);
+  return res;
 }
 
 std::any EvalVisitor::visitTfpdef(Python3Parser::TfpdefContext *ctx) {
-  return std::move(ctx->NAME()->getText());
+  return ctx->NAME()->getText();
 }
 
 std::any EvalVisitor::visitStmt(Python3Parser::StmtContext *ctx) {
-  if (ctx->compound_stmt())
-    return std::move(visitCompound_stmt(ctx->compound_stmt()));
-  return std::move(visitSimple_stmt(ctx->simple_stmt()));
+  if (ctx->compound_stmt()) return visitCompound_stmt(ctx->compound_stmt());
+  return visitSimple_stmt(ctx->simple_stmt());
 }
 
 std::any EvalVisitor::visitSimple_stmt(Python3Parser::Simple_stmtContext *ctx) {
-  return std::move(visitSmall_stmt(ctx->small_stmt()));
+  return visitSmall_stmt(ctx->small_stmt());
 }
 
 std::any EvalVisitor::visitSmall_stmt(Python3Parser::Small_stmtContext *ctx) {
   if (ctx->expr_stmt())
-    return std::move(visitExpr_stmt(ctx->expr_stmt()));
+    return visitExpr_stmt(ctx->expr_stmt());
   else
-    return std::move(visitFlow_stmt(ctx->flow_stmt()));
+    return visitFlow_stmt(ctx->flow_stmt());
 }
 
 std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
   if (!ctx->augassign() && !ctx->ASSIGN(0))
-    return std::move(visitTestlist(ctx->testlist(0)));
+    return visitTestlist(ctx->testlist(0));
   if (ctx->augassign()) {
-    auto left_value = std::move(visitTestlist(ctx->testlist(0)));
-    auto right_value = std::move(visitTestlist(ctx->testlist(1)));
-    right_value = std::move(DeQuate(right_value, Variables));
+    auto left_value = visitTestlist(ctx->testlist(0));
+    auto right_value = visitTestlist(ctx->testlist(1));
+    right_value = 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);
@@ -84,7 +83,7 @@ std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
           "augassign",
           1);
     if (ptr_var) {
-      std::any old_val = std::move(DeQuate(*ptr_var, Variables));
+      std::any old_val = DeQuate(*ptr_var, Variables);
       if (ctx->augassign()->ADD_ASSIGN())
         SelfAdd(old_val, right_value);
       else if (ctx->augassign()->SUB_ASSIGN())
@@ -109,7 +108,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 = std::move(DeQuate(*ptr_var, Variables));
+        std::any old_val = DeQuate(*ptr_var, Variables);
         if (ctx->augassign()->ADD_ASSIGN())
           SelfAdd(old_val,
                   std::any_cast<std::vector<std::any>>(right_value)[i]);
@@ -135,11 +134,11 @@ std::any EvalVisitor::visitExpr_stmt(Python3Parser::Expr_stmtContext *ctx) {
     }
     return NoneType();
   }
-  const auto &testlist_list = ctx->testlist();
-  auto val = std::move(visitTestlist(testlist_list[testlist_list.size() - 1]));
-  val = std::move(DeQuate(val, Variables));
+  auto testlist_list = ctx->testlist();
+  auto val = visitTestlist(testlist_list[testlist_list.size() - 1]);
+  val = DeQuate(val, Variables);
   for (int i = testlist_list.size() - 2; i >= 0; i--) {
-    auto dest = std::move(visitTestlist(testlist_list[i]));
+    auto dest = 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);
@@ -170,11 +169,9 @@ std::any EvalVisitor::visitAugassign(Python3Parser::AugassignContext *ctx) {
 }
 
 std::any EvalVisitor::visitFlow_stmt(Python3Parser::Flow_stmtContext *ctx) {
-  if (ctx->break_stmt()) return std::move(visitBreak_stmt(ctx->break_stmt()));
-  if (ctx->continue_stmt())
-    return std::move(visitContinue_stmt(ctx->continue_stmt()));
-  if (ctx->return_stmt())
-    return std::move(visitReturn_stmt(ctx->return_stmt()));
+  if (ctx->break_stmt()) return visitBreak_stmt(ctx->break_stmt());
+  if (ctx->continue_stmt()) return visitContinue_stmt(ctx->continue_stmt());
+  if (ctx->return_stmt()) return visitReturn_stmt(ctx->return_stmt());
   throw FatalError("Unknown flow statement", 10);
   return NoneType();
 }
@@ -190,49 +187,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 = std::move(visitTestlist(ctx->testlist()));
-  val = std::move(DeQuate(val, Variables));
+  std::any val = visitTestlist(ctx->testlist());
+  val = 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 std::move(FlowType(RETURN, tmp));
+  return FlowType(RETURN, tmp);
 }
 
 std::any EvalVisitor::visitCompound_stmt(
     Python3Parser::Compound_stmtContext *ctx) {
-  if (ctx->if_stmt()) return std::move(visitIf_stmt(ctx->if_stmt()));
-  if (ctx->while_stmt()) return std::move(visitWhile_stmt(ctx->while_stmt()));
-  if (ctx->funcdef()) return std::move(visitFuncdef(ctx->funcdef()));
+  if (ctx->if_stmt()) return visitIf_stmt(ctx->if_stmt());
+  if (ctx->while_stmt()) return visitWhile_stmt(ctx->while_stmt());
+  if (ctx->funcdef()) return visitFuncdef(ctx->funcdef());
   throw FatalError("Unknown compound statement", 11);
   return NoneType();
 }
 
 std::any EvalVisitor::visitIf_stmt(Python3Parser::If_stmtContext *ctx) {
-  const auto &test_list = ctx->test();
-  const auto &suite_list = ctx->suite();
+  auto test_list = ctx->test();
+  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 std::move(visitSuite(suite_list[i]));
+      return visitSuite(suite_list[i]);
   if (test_list.size() - suite_list.size() == -1)
-    return std::move(visitSuite(suite_list[suite_list.size() - 1]));
+    return visitSuite(suite_list[suite_list.size() - 1]);
   return NoneType();
 }
 
 std::any EvalVisitor::visitWhile_stmt(Python3Parser::While_stmtContext *ctx) {
-  const auto &test = ctx->test();
-  const auto &suite = ctx->suite();
+  auto test = ctx->test();
+  auto suite = ctx->suite();
   while (Any2Bool(DeQuate(visitTest(test), Variables))) {
-    auto res = std::move(visitSuite(suite));
+    auto res = 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 std::move(*res_ptr);
+      if (res_ptr->Status == RETURN) return *res_ptr;
     }
   }
   return NoneType();
@@ -240,31 +237,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());
-  const auto &stmt_list = ctx->stmt();
+  auto stmt_list = ctx->stmt();
   std::any res;
   for (int i = 0; i < stmt_list.size(); i++) {
-    res = std::move(visitStmt(stmt_list[i]));
+    res = visitStmt(stmt_list[i]);
     FlowType *res_ptr = std::any_cast<FlowType>(&res);
-    if (res_ptr) return std::move(res);
+    if (res_ptr) return res;
   }
-  return std::move(res);
+  return res;
 }
 std::any EvalVisitor::visitTestlist(Python3Parser::TestlistContext *ctx) {
-  const auto &test_list = ctx->test();
-  if (test_list.size() == 1) return std::move(visitTest(test_list[0]));
+  auto test_list = ctx->test();
+  if (test_list.size() == 1) return visitTest(test_list[0]);
   std::vector<std::any> res;
   for (auto item : test_list) {
     res.push_back(visitTest(item));
   }
-  return std::move(res);
+  return res;
 }
 std::any EvalVisitor::visitTest(Python3Parser::TestContext *ctx) {
-  return std::move(visitOr_test(ctx->or_test()));
+  return visitOr_test(ctx->or_test());
 }
 
 std::any EvalVisitor::visitOr_test(Python3Parser::Or_testContext *ctx) {
-  const auto &or_list = ctx->and_test();
-  if (or_list.size() == 1) return std::move(visitAnd_test(or_list[0]));
+  auto or_list = ctx->and_test();
+  if (or_list.size() == 1) return visitAnd_test(or_list[0]);
   for (auto or_item : or_list) {
     if (Any2Bool(DeQuate(visitAnd_test(or_item), Variables))) return true;
   }
@@ -272,8 +269,8 @@ std::any EvalVisitor::visitOr_test(Python3Parser::Or_testContext *ctx) {
 }
 
 std::any EvalVisitor::visitAnd_test(Python3Parser::And_testContext *ctx) {
-  const auto &not_list = ctx->not_test();
-  if (not_list.size() == 1) return std::move(visitNot_test(not_list[0]));
+  auto not_list = ctx->not_test();
+  if (not_list.size() == 1) return visitNot_test(not_list[0]);
   for (auto not_item : not_list) {
     if (!Any2Bool(DeQuate(visitNot_test(not_item), Variables))) return false;
   }
@@ -281,19 +278,19 @@ std::any EvalVisitor::visitAnd_test(Python3Parser::And_testContext *ctx) {
 }
 
 std::any EvalVisitor::visitNot_test(Python3Parser::Not_testContext *ctx) {
-  if (!ctx->NOT()) return std::move(visitComparison(ctx->comparison()));
+  if (!ctx->NOT()) return visitComparison(ctx->comparison());
   return !Any2Bool(DeQuate(visitNot_test(ctx->not_test()), Variables));
 }
 
 std::any EvalVisitor::visitComparison(Python3Parser::ComparisonContext *ctx) {
-  const auto &arith_expr_list = ctx->arith_expr();
-  auto last_val = std::move(visitArith_expr(arith_expr_list[0]));
-  if (arith_expr_list.size() == 1) return std::move(last_val);
-  last_val = std::move(DeQuate(last_val, Variables));
+  auto arith_expr_list = ctx->arith_expr();
+  auto last_val = visitArith_expr(arith_expr_list[0]);
+  if (arith_expr_list.size() == 1) return last_val;
+  last_val = DeQuate(last_val, Variables);
   auto op_list = ctx->comp_op();
   for (int i = 0; i < op_list.size(); i++) {
-    auto cur = std::move(visitArith_expr(arith_expr_list[i + 1]));
-    cur = std::move(DeQuate(cur, Variables));
+    auto cur = visitArith_expr(arith_expr_list[i + 1]);
+    cur = DeQuate(cur, Variables);
     bool ok = false;
     if (op_list[i]->GREATER_THAN())
       ok = Greater(last_val, cur);
@@ -310,7 +307,7 @@ std::any EvalVisitor::visitComparison(Python3Parser::ComparisonContext *ctx) {
     else
       throw InterpretException("visitComparison: Unknown operator", 13);
     if (!ok) return false;
-    last_val = std::move(cur);
+    last_val = cur;
   }
   return true;
 }
@@ -320,14 +317,14 @@ std::any EvalVisitor::visitComp_op(Python3Parser::Comp_opContext *ctx) {
 }
 
 std::any EvalVisitor::visitArith_expr(Python3Parser::Arith_exprContext *ctx) {
-  const auto &term_list = ctx->term();
-  auto ans = std::move(visitTerm(term_list[0]));
-  if (term_list.size() == 1) return std::move(ans);
-  const auto &op_list = ctx->addorsub_op();
-  ans = std::move(DeQuate(ans, Variables));
+  auto term_list = ctx->term();
+  auto ans = visitTerm(term_list[0]);
+  if (term_list.size() == 1) return ans;
+  auto op_list = ctx->addorsub_op();
+  ans = DeQuate(ans, Variables);
   for (int i = 0; i < op_list.size(); i++) {
     auto cur = visitTerm(term_list[i + 1]);
-    cur = std::move(DeQuate(cur, Variables));
+    cur = DeQuate(cur, Variables);
     if (op_list[i]->ADD())
       SelfAdd(ans, cur);
     else if (op_list[i]->MINUS())
@@ -335,7 +332,7 @@ std::any EvalVisitor::visitArith_expr(Python3Parser::Arith_exprContext *ctx) {
     else
       throw FatalError("visitArith_expr: Unknown operator", 15);
   }
-  return std::move(ans);
+  return ans;
 }
 
 std::any EvalVisitor::visitAddorsub_op(Python3Parser::Addorsub_opContext *ctx) {
@@ -343,14 +340,14 @@ std::any EvalVisitor::visitAddorsub_op(Python3Parser::Addorsub_opContext *ctx) {
 }
 
 std::any EvalVisitor::visitTerm(Python3Parser::TermContext *ctx) {
-  const auto &factor_list = ctx->factor();
-  auto ans = std::move(visitFactor(factor_list[0]));
-  if (factor_list.size() == 1) return std::move(ans);
+  auto factor_list = ctx->factor();
+  auto ans = visitFactor(factor_list[0]);
+  if (factor_list.size() == 1) return ans;
   auto op_list = ctx->muldivmod_op();
-  ans = std::move(DeQuate(ans, Variables));
+  ans = DeQuate(ans, Variables);
   for (int i = 0; i < op_list.size(); i++) {
-    auto cur = std::move(visitFactor(factor_list[i + 1]));
-    cur = std::move(DeQuate(cur, Variables));
+    auto cur = visitFactor(factor_list[i + 1]);
+    cur = DeQuate(cur, Variables);
     if (op_list[i]->STAR())
       SelfMul(ans, cur);
     else if (op_list[i]->DIV())
@@ -362,7 +359,7 @@ std::any EvalVisitor::visitTerm(Python3Parser::TermContext *ctx) {
     else
       throw FatalError("visitTerm: Unknown operator", 17);
   }
-  return std::move(ans);
+  return ans;
 }
 
 std::any EvalVisitor::visitMuldivmod_op(
@@ -371,47 +368,45 @@ std::any EvalVisitor::visitMuldivmod_op(
 }
 
 std::any EvalVisitor::visitFactor(Python3Parser::FactorContext *ctx) {
-  if (ctx->atom_expr()) return std::move(visitAtom_expr(ctx->atom_expr()));
-  std::any res = std::move(visitFactor(ctx->factor()));
-  res = std::move(DeQuate(res, Variables));
-  if (ctx->MINUS()) res = std::move(Neg(res));
-  return std::move(res);
+  if (ctx->atom_expr()) return visitAtom_expr(ctx->atom_expr());
+  std::any res = visitFactor(ctx->factor());
+  res = DeQuate(res, Variables);
+  if (ctx->MINUS()) res = Neg(res);
+  return res;
 }
 
 std::any EvalVisitor::visitAtom_expr(Python3Parser::Atom_exprContext *ctx) {
-  if (!ctx->trailer()) return std::move(visitAtom(ctx->atom()));
-  std::string func_name = std::move(ctx->atom()->NAME()->getText());
+  if (!ctx->trailer()) return visitAtom(ctx->atom());
+  std::string func_name = ctx->atom()->NAME()->getText();
   std::vector<ParaArguItemType> args =
-      std::move(std::any_cast<std::vector<ParaArguItemType>>(
-          std::move(visitTrailer(ctx->trailer()))));
-  return std::move(Functions.CallFunction(func_name, args, Variables));
+      std::any_cast<std::vector<ParaArguItemType>>(
+          visitTrailer(ctx->trailer()));
+  return Functions.CallFunction(func_name, args, Variables);
 }
 
 std::any EvalVisitor::visitTrailer(Python3Parser::TrailerContext *ctx) {
   if (!ctx->arglist()) return std::vector<ParaArguItemType>();
-  return std::move(visitArglist(ctx->arglist()));
+  return visitArglist(ctx->arglist());
 }
 std::any EvalVisitor::visitArglist(Python3Parser::ArglistContext *ctx) {
-  const auto &argument_list = ctx->argument();
+  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 std::move(resolved_args);
+  return resolved_args;
 }
 
 std::any EvalVisitor::visitArgument(Python3Parser::ArgumentContext *ctx) {
-  const auto & arg_list = ctx->test();
+  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 std::move(
-        ParaArguItemType("", DeQuate(visitTest(arg_list[0]), Variables)));
+    return ParaArguItemType("", DeQuate(visitTest(arg_list[0]), Variables));
   else
-    return std::move(
-        ParaArguItemType(arg_list[0]->getText(),
-                         DeQuate(visitTest(arg_list[1]), Variables)));
+    return ParaArguItemType(arg_list[0]->getText(),
+                            DeQuate(visitTest(arg_list[1]), Variables));
 }
 std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
   if (ctx->NONE())
@@ -427,9 +422,9 @@ std::any EvalVisitor::visitAtom(Python3Parser::AtomContext *ctx) {
     else
       return std::stod(num);
   } else if (ctx->test())
-    return std::move(visitTest(ctx->test()));
+    return visitTest(ctx->test());
   else if (ctx->NAME()) {
-    return std::move(RawVarible(ctx->getText()));
+    return RawVarible(ctx->getText());
   } else {
     auto string_lists = ctx->STRING();
     std::string res;
@@ -438,6 +433,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 std::move(res);
+    return res;
   }
 }
\ No newline at end of file
diff --git a/src/names.cpp b/src/names.cpp
index c5a0621..1ca32da 100644
--- a/src/names.cpp
+++ b/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 = std::move(Any2String(args[i].value));
+        std::string buf = 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 std::move(Any2String(args[0].value));
+    return Any2String(args[0].value);
   } else if (name == "int") {
     if (args.size() == 1) {
-      return std::move(Any2Int(args[0].value));
+      return 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 = std::move(vis.visit(func.code_address));
+  std::any res = 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 std::move(flow->ReturnValueLists[0]);
+      return flow->ReturnValueLists[0];
     else
-      return std::move(flow->ReturnValueLists);
+      return flow->ReturnValueLists;
   }
   // std::cerr<<"Return value isn't FlowType"<<std::endl;
   return NoneType();
diff --git a/src/utils.cpp b/src/utils.cpp
index e544851..d538db1 100644
--- a/src/utils.cpp
+++ b/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 = std::move(*ptr);
+    std::string str = *ptr;
     size_t dot_position = str.find('.');
     if (dot_position != std::string::npos) {
-      std::string integer_part = std::move(str.substr(0, dot_position));
-      str = std::move(integer_part);
+      std::string integer_part = str.substr(0, dot_position);
+      str = 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 std::move(res);
+  return 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] = std::move(DeQuate((*ptr)[i], Variables));
-    return std::move(*ptr);
+      (*ptr)[i] = DeQuate((*ptr)[i], Variables);
+    return *ptr;
   } else if (auto ptr = std::any_cast<RawVarible>(&val)) {
-    return std::move(Variables.ReadVariable(ptr->name));
+    return 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 std::move(val);
+    return 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 = std::move(Any2Int(a));
-      b = std::move(Any2Int(b));
+      a = Any2Int(a);
+      b = 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 std::move((*ptr_a_string) + (*ptr_b_string));
+    return (*ptr_a_string) + (*ptr_b_string);
   if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr))
-    return std::move(ZYM::int2048(int(*ptr_a_bool) + int(*ptr_b_bool)));
+    return ZYM::int2048(int(*ptr_a_bool) + int(*ptr_b_bool));
   else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr))
-    return std::move((*ptr_a_int2048) + (*ptr_b_int2048));
+    return (*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 std::move(Any2String(a) + Any2String(b));
+    return 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 std::move(ZYM::int2048(int(*ptr_a_bool) - int(*ptr_b_bool)));
+    return ZYM::int2048(int(*ptr_a_bool) - int(*ptr_b_bool));
   else if ((ptr_a_int2048 != nullptr) && (ptr_b_int2048 != nullptr))
-    return std::move((*ptr_a_int2048) - (*ptr_b_int2048));
+    return (*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 = std::move(Neg(b));
+      b = 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 = std::move(Any2Int(*ptr_b_float));
+      b = 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 std::move(*ptr_a_string);
+        return *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 std::move(res);
+      return 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 std::move((*ptr_a_int2048) / (*ptr_b_int2048));
+      return (*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 std::move((*ptr_a_int2048) % (*ptr_b_int2048));
+    return (*ptr_a_int2048) % (*ptr_b_int2048);
   else if ((ptr_a_bool != nullptr) && (ptr_b_bool != nullptr))
-    return std::move(ZYM::int2048(int(*ptr_a_bool) % int(*ptr_b_bool)));
+    return 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 = std::move(Add(a, b));
+  a = Add(a, b);
   return a;
 }
 
 std::any &SelfSub(std::any &a, std::any b) {
-  a = std::move(Sub(a, b));
+  a = Sub(a, b);
   return a;
 }
 
 std::any &SelfMul(std::any &a, std::any b) {
-  a = std::move(Mul(a, b));
+  a = Mul(a, b);
   return a;
 }
 
 std::any &SelfDiv(std::any &a, std::any b) {
-  a = std::move(Div(a, b));
+  a = Div(a, b);
   return a;
 }
 
 std::any &SelfDivv(std::any &a, std::any b) {
-  a = std::move(Divv(a, b));
+  a = Divv(a, b);
   return a;
 }
 
 std::any &SelfMod(std::any &a, std::any b) {
-  a = std::move(Mod(a, b));
+  a = 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 std::move(-(*ptr_a_int2048));
+    return -(*ptr_a_int2048);
   else if (ptr_a_float != nullptr)
     return -(*ptr_a_float);
   else