class AdditionExpression extends AdditionSubtractionExpression {
    
    private static final long serialVersionUID = -971366486450425605L;


    private static final Logger logger = LoggerFactory.getLogger(AdditionExpression.class);


    
    public AdditionExpression(final IStandardExpression left, final IStandardExpression right) {
        super(left, right);
    }
    

    
    @Override
    public String getStringRepresentation() {
        return getStringRepresentation(ADDITION_OPERATOR);
    }
    
    
    
    
    
    static Object executeAddition(
            final IExpressionContext context,
            final AdditionExpression expression, final StandardExpressionExecutionContext expContext) {<FILL_FUNCTION_BODY>}

    
}


        if (logger.isTraceEnabled()) {
            logger.trace("[THYMELEAF][{}] Evaluating addition expression: \"{}\"", TemplateEngine.threadIndex(), expression.getStringRepresentation());
        }

        final IStandardVariableExpressionEvaluator expressionEvaluator =
                StandardExpressions.getVariableExpressionEvaluator(context.getConfiguration());

        final IStandardExpression leftExpr = expression.getLeft();
        final IStandardExpression rightExpr = expression.getRight();

        // We try use the Expression.execute methods directly if possible, because we cannot allow the results
        // to be literal-unwrapped (if literal unwrap takes place, '.' + 3 + 2 = 2.3 instead of '.32' as it should be).
        // Note this is only needed in AdditionExpression, because '+' is the only overloaded operator
        Object leftValue;
        if (leftExpr instanceof Expression) {
            // This avoids literal-unwrap
            leftValue = Expression.execute(context, (Expression)leftExpr, expressionEvaluator, expContext);
        } else{
            leftValue = leftExpr.execute(context, expContext);
        }
        Object rightValue;
        if (rightExpr instanceof Expression) {
            // This avoids literal-unwrap
            rightValue = Expression.execute(context, (Expression)rightExpr, expressionEvaluator, expContext);
        } else{
            rightValue = rightExpr.execute(context, expContext);
        }

        if (leftValue == null) {
            leftValue = "null";
        }
        if (rightValue == null) {
            rightValue = "null";
        }

        final BigDecimal leftNumberValue = EvaluationUtils.evaluateAsNumber(leftValue);
        if (leftNumberValue != null) {
            final BigDecimal rightNumberValue = EvaluationUtils.evaluateAsNumber(rightValue);
            if (rightNumberValue != null) {
                // Addition will act as a mathematical 'plus'
                return leftNumberValue.add(rightNumberValue);
            }
        }

        return new LiteralValue(LiteralValue.unwrap(leftValue).toString() + (LiteralValue.unwrap(rightValue).toString()));

    
<methods><variables>protected static final java.lang.String ADDITION_OPERATOR,private static final non-sealed java.lang.reflect.Method LEFT_ALLOWED_METHOD,private static final boolean[] LENIENCIES,static final java.lang.String[] OPERATORS,private static final Class<? extends org.thymeleaf.standard.expression.BinaryOperationExpression>[] OPERATOR_CLASSES,private static final non-sealed java.lang.reflect.Method RIGHT_ALLOWED_METHOD,protected static final java.lang.String SUBTRACTION_OPERATOR,private static final long serialVersionUID