diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..a496751
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,4 @@
+github.com/yqylovy/goimportdot v0.0.0-20170519021755-eb181a7eeabe h1:bWYrKmmfv37uNgXTdwkLSKYiYPJ1yfWmjBnvtMyAYzk=
+github.com/yqylovy/goimportdot v0.0.0-20170519021755-eb181a7eeabe/go.mod h1:alTKUpAJ/zbp17qvZwcFNwzufrb5DljMDY4mgJlIHao=
+golang.org/x/exp v0.0.0-20241204233417-43b7b7cde48d h1:0olWaB5pg3+oychR51GUVCEsGkeCU/2JxjBgIo4f3M0=
+golang.org/x/exp v0.0.0-20241204233417-43b7b7cde48d/go.mod h1:qj5a5QZpwLU2NLQudwIN5koi3beDhSAlJwa67PuM98c=
diff --git a/operator-assign.go b/operator-assign.go
index e730855..1a2bf18 100644
--- a/operator-assign.go
+++ b/operator-assign.go
@@ -181,6 +181,8 @@ func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
 				v, err = mulValues(opTerm, leftValue, rightValue)
 			case SymSlashEqual:
 				v, err = divValues(opTerm, leftValue, rightValue)
+			case SymPercEqual:
+				v, err = remainderValues(opTerm, leftValue, rightValue)
 			default:
 				err = opTerm.Errorf("unsupported assign operator %q", opTerm.source())
 			}
diff --git a/operator-prod.go b/operator-prod.go
index 63e497c..6adeadf 100644
--- a/operator-prod.go
+++ b/operator-prod.go
@@ -50,24 +50,6 @@ func evalMultiply(ctx ExprContext, prodTerm *term) (v any, err error) {
 	}
 
 	return mulValues(prodTerm, leftValue, rightValue)
-	// if IsString(leftValue) && IsInteger(rightValue) {
-	// 	s, _ := leftValue.(string)
-	// 	n, _ := rightValue.(int64)
-	// 	v = strings.Repeat(s, int(n))
-	// } else if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
-	// 	if IsFloat(leftValue) || IsFloat(rightValue) {
-	// 		v = numAsFloat(leftValue) * numAsFloat(rightValue)
-	// 	} else if isFraction(leftValue) || isFraction(rightValue) {
-	// 		v, err = mulAnyFract(leftValue, rightValue)
-	// 	} else {
-	// 		leftInt, _ := leftValue.(int64)
-	// 		rightInt, _ := rightValue.(int64)
-	// 		v = leftInt * rightInt
-	// 	}
-	// } else {
-	// 	err = prodTerm.errIncompatibleTypes(leftValue, rightValue)
-	// }
-	// return
 }
 
 //-------- divide term
@@ -115,28 +97,6 @@ func evalDivide(ctx ExprContext, opTerm *term) (v any, err error) {
 	}
 
 	return divValues(opTerm, leftValue, rightValue)
-	// if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
-	// 	if IsFloat(leftValue) || IsFloat(rightValue) {
-	// 		d := numAsFloat(rightValue)
-	// 		if d == 0.0 {
-	// 			err = errors.New("division by zero")
-	// 		} else {
-	// 			v = numAsFloat(leftValue) / d
-	// 		}
-	// 	} else if isFraction(leftValue) || isFraction(rightValue) {
-	// 		v, err = divAnyFract(leftValue, rightValue)
-	// 	} else {
-	// 		leftInt, _ := leftValue.(int64)
-	// 		if rightInt, _ := rightValue.(int64); rightInt == 0 {
-	// 			err = errors.New("division by zero")
-	// 		} else {
-	// 			v = leftInt / rightInt
-	// 		}
-	// 	}
-	// } else {
-	// 	err = opTerm.errIncompatibleTypes(leftValue, rightValue)
-	// }
-	// return
 }
 
 //-------- divide as float term
@@ -179,17 +139,10 @@ func newRemainderTerm(tk *Token) (inst *term) {
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priProduct,
-		evalFunc: evalReminder,
+		evalFunc: evalRemainder,
 	}
 }
-
-func evalReminder(ctx ExprContext, ramainderTerm *term) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = ramainderTerm.evalInfix(ctx); err != nil {
-		return
-	}
-
+func remainderValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
 	if IsInteger(leftValue) && IsInteger(rightValue) {
 		rightInt, _ := rightValue.(int64)
 		if rightInt == 0 {
@@ -199,11 +152,21 @@ func evalReminder(ctx ExprContext, ramainderTerm *term) (v any, err error) {
 			v = leftInt % rightInt
 		}
 	} else {
-		err = ramainderTerm.errIncompatibleTypes(leftValue, rightValue)
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
 
+func evalRemainder(ctx ExprContext, remainderTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = remainderTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	return remainderValues(remainderTerm, leftValue, rightValue)
+}
+
 // init
 func init() {
 	registerTermConstructor(SymStar, newMultiplyTerm)
diff --git a/operator-sum.go b/operator-sum.go
index 249cfca..1a4cc6d 100644
--- a/operator-sum.go
+++ b/operator-sum.go
@@ -67,41 +67,6 @@ func evalPlus(ctx ExprContext, plusTerm *term) (v any, err error) {
 	}
 
 	return sumValues(plusTerm, leftValue, rightValue)
-	// if (IsString(leftValue) && isNumberString(rightValue)) || (IsString(rightValue) && isNumberString(leftValue)) {
-	// 	v = fmt.Sprintf("%v%v", leftValue, rightValue)
-	// } else if IsNumber(leftValue) && IsNumber(rightValue) {
-	// 	if IsFloat(leftValue) || IsFloat(rightValue) {
-	// 		v = numAsFloat(leftValue) + numAsFloat(rightValue)
-	// 	} else {
-	// 		leftInt, _ := leftValue.(int64)
-	// 		rightInt, _ := rightValue.(int64)
-	// 		v = leftInt + rightInt
-	// 	}
-	// } else if IsList(leftValue) && IsList(rightValue) {
-	// 	var leftList, rightList *ListType
-	// 	leftList, _ = leftValue.(*ListType)
-	// 	rightList, _ = rightValue.(*ListType)
-
-	// 	sumList := make(ListType, 0, len(*leftList)+len(*rightList))
-	// 	sumList = append(sumList, *leftList...)
-	// 	sumList = append(sumList, *rightList...)
-	// 	v = &sumList
-	// } else if (isFraction(leftValue) && IsNumber(rightValue)) || (isFraction(rightValue) && IsNumber(leftValue)) {
-	// 	if IsFloat(leftValue) || IsFloat(rightValue) {
-	// 		v = numAsFloat(leftValue) + numAsFloat(rightValue)
-	// 	} else {
-	// 		v, err = sumAnyFract(leftValue, rightValue)
-	// 	}
-	// } else if IsDict(leftValue) && IsDict(rightValue) {
-	// 	leftDict, _ := leftValue.(*DictType)
-	// 	rightDict, _ := rightValue.(*DictType)
-	// 	c := leftDict.clone()
-	// 	c.merge(rightDict)
-	// 	v = c
-	// } else {
-	// 	err = plusTerm.errIncompatibleTypes(leftValue, rightValue)
-	// }
-	// return
 }
 
 //-------- minus term
@@ -151,30 +116,6 @@ func evalMinus(ctx ExprContext, minusTerm *term) (v any, err error) {
 	}
 
 	return diffValues(minusTerm, leftValue, rightValue)
-	// if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
-	// 	if IsFloat(leftValue) || IsFloat(rightValue) {
-	// 		v = numAsFloat(leftValue) - numAsFloat(rightValue)
-	// 	} else if isFraction(leftValue) || isFraction(rightValue) {
-	// 		v, err = subAnyFract(leftValue, rightValue)
-	// 	} else {
-	// 		leftInt, _ := leftValue.(int64)
-	// 		rightInt, _ := rightValue.(int64)
-	// 		v = leftInt - rightInt
-	// 	}
-	// } else if IsList(leftValue) && IsList(rightValue) {
-	// 	leftList, _ := leftValue.(*ListType)
-	// 	rightList, _ := rightValue.(*ListType)
-	// 	diffList := make(ListType, 0, len(*leftList)-len(*rightList))
-	// 	for _, item := range *leftList {
-	// 		if slices.Index(*rightList, item) < 0 {
-	// 			diffList = append(diffList, item)
-	// 		}
-	// 	}
-	// 	v = &diffList
-	// } else {
-	// 	err = minusTerm.errIncompatibleTypes(leftValue, rightValue)
-	// }
-	// return
 }
 
 // init
diff --git a/parser.go b/parser.go
index 5fbd964..8e9b34f 100644
--- a/parser.go
+++ b/parser.go
@@ -513,16 +513,6 @@ func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymb
 				// Colon outside a selector term acts like a separator
 				firstToken = true
 			}
-		// case SymPlusEqual:
-		// 	opTk := NewToken(tk.row, tk.col, SymEqual, "=")
-		// 	if _, err = tree.addToken(opTk); err == nil {
-		// 		if err = tree.addTerm(tree.root.Clone()); err == nil {
-		// 			opTk = NewToken(tk.row, tk.col, SymPlus, "+")
-		// 			currentTerm, err = tree.addToken(opTk)
-		// 		}
-		// 	}
-		// case SymStarEqual:
-		// 	currentTerm, err = parser.expandOpAssign(scanner, tree, tk, ctx, termSymbols)
 		default:
 			currentTerm, err = tree.addToken(tk)
 		}
@@ -560,50 +550,3 @@ func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymb
 // 	}
 // 	return
 // }
-
-// func (parser *parser) expandOpAssign(scanner *scanner, tree *ast, tk *Token, ctx parserContext, termSymbols []Symbol) (t *term, err error) {
-// 	var opSym Symbol
-// 	var opString string
-
-// 	if tree.root != nil {
-// 		switch tk.Sym {
-// 		case SymPlusEqual:
-// 			opString = "+"
-// 			opSym = SymPlus
-// 		case SymMinusEqual:
-// 			opString = "-"
-// 			opSym = SymMinus
-// 		case SymStarEqual:
-// 			opString = "*"
-// 			opSym = SymStar
-// 		default:
-// 			err = tk.Errorf("unsopported operator %q", tk.source)
-// 			return
-// 		}
-// 		leftExpr := tree.root.Clone()
-// 		leftExpr.setParent(nil)
-// 		if t, err = tree.addToken(NewToken(tk.row, tk.col, SymEqual, "=")); err == nil {
-// 			t = leftExpr
-// 			if err = tree.addTerm(leftExpr); err == nil {
-// 				if t, err = tree.addToken(NewToken(tk.row, tk.col, opSym, opString)); err == nil {
-
-// 					var subTree *ast
-// 					// if subTree, err = parser.parseGeneral(scanner, ctx, SymEos, SymSemiColon, SymClosedRound, SymClosedBrace, SymClosedSquare); err == nil {
-// 					if subTree, err = parser.parseGeneral(scanner, ctx, termSymbols...); err == nil {
-// 						if scanner.Previous().IsOneOfA(SymSemiColon, SymClosedRound, SymClosedBrace, SymClosedSquare) {
-// 							if err = scanner.UnreadToken(); err != nil {
-// 								return
-// 							}
-// 						}
-// 						subTree.root.priority = priValue
-// 						err = tree.addTerm(newExprTerm(subTree.root))
-// 						t = subTree.root
-// 					}
-// 				}
-// 			}
-// 		}
-// 	} else {
-// 		err = tk.Errorf("left operand of %q must be a variable or a variable expression", tk)
-// 	}
-// 	return
-// }
diff --git a/symbol-map.go b/symbol-map.go
index 6329bd3..f6048c9 100644
--- a/symbol-map.go
+++ b/symbol-map.go
@@ -92,6 +92,7 @@ func init() {
 		SymTripleDot:       {"...", symClassOperator},    //  59: '...'
 		SymStarEqual:       {"*=", symClassOperator},     //  60: '*='
 		SymSlashEqual:      {"/=", symClassOperator},     //  61: '/='
+		SymPercEqual:       {"%=", symClassOperator},     //  62: '%='
 		// SymChangeSign
 		// SymUnchangeSign
 		// SymIdentifier
diff --git a/symbol.go b/symbol.go
index f7c844f..d42fa59 100644
--- a/symbol.go
+++ b/symbol.go
@@ -70,6 +70,7 @@ const (
 	SymTripleDot                         //  59: '...'
 	SymStarEqual                         //  60: '*='
 	SymSlashEqual                        //  61: '/='
+	SymPercEqual                         //  62: '%='
 	SymChangeSign
 	SymUnchangeSign
 	SymIdentifier