i++
	}
}

func TestExtending() {
	l1 := _New[int]()
	l2 := _New[int]()

	l1.PushBack(1)
	l1.PushBack(2)
	l1.PushBack(3)

	l2.PushBack(4)
	l2.PushBack(5)

	l3 := _New[int]()
	l3.PushBackList(l1)
	checkList(l3, []interface{}{1, 2, 3})
	l3.PushBackList(l2)
	checkList(l3, []interface{}{1, 2, 3, 4, 5})

	l3 = _New[int]()
	l3.PushFrontList(l2)

	} else if len(langs3) != 3 {
		t.Errorf("should only find only 3 languages, but got %+v", langs3)
	}

	for idx, lang := range langs {
		lang.Name = lang.Name + "_new"
		langs[idx] = lang
	}

	if err := DB.Clauses(clause.OnConflict{
		Columns:   []clause.Column{{Name: "code"}},
		DoUpdates: clause.AssignmentColumns([]string{"name"}),
	}).Create(&langs).Error; err != nil {

	var args []*operand // not valid for _Make, _New, _Offsetof, _Trace
	var nargs int
	switch id {
	default:
		// check all arguments
		args = check.exprList(argList)
		nargs = len(args)
		for _, a := range args {
			if a.mode == invalid {
				return
			}
		}
		// first argument is always in x
		if nargs > 0 {
			*x = *args[0]
		}
	case _Make, _New, _Offsetof, _Trace:
		// arguments require special handling

            //
            publicMethod("load", RETURN_OBJECT_FROM_STRING, methodVisitor -> new MethodVisitorScope(methodVisitor) {{
                // Call return new <implClass>(param1)
                _NEW(implementationType);
                _DUP();
                _ALOAD(1);
                _INVOKESPECIAL(implementationType, CONSTRUCTOR_NAME, RETURN_VOID_FROM_STRING);
                _ARETURN();
            }});

	var args []*operand // not valid for _Make, _New, _Offsetof, _Trace
	var nargs int
	switch id {
	default:
		// check all arguments
		args = check.exprList(argList)
		nargs = len(args)
		for _, a := range args {
			if a.mode == invalid {
				return
			}
		}
		// first argument is always in x
		if nargs > 0 {
			*x = *args[0]
		}
	case _Make, _New, _Offsetof, _Trace:
		// arguments require special handling

    }

    public void _ACONST_NULL() {
        super.visitInsn(ACONST_NULL);
    }

    public void _LDC(Object value) {
        super.visitLdcInsn(value);
    }

    public void _NEW(Type type) {
        super.visitTypeInsn(NEW, type.getInternalName());
    }

    public void _CHECKCAST(Type type) {
        _CHECKCAST(type.getInternalName());
    }

====

[NOTE]
====
Choosing the right attributes to set is the hardest thing in this process, because they carry the semantics of the variant.
Therefore, before adding _new attributes_, you should always ask yourself if there isn't an attribute which carries the semantics you need.
If there isn't, then you may add a new attribute.