Golang defers in a for loop behaves differently for the same struct

I wrote the following golang code and ran it.

type Test struct {
	Name string
}

func (t Test) hello() {
	fmt.Printf("Hello, %s\n", t.Name)
}

func (t *Test) hello2() {
	fmt.Printf("pointer: %s\n", t.Name)
}

func runT(t Test) {
	t.hello()
}

func main() {
	mapt := []Test{
		{Name: "A"},
		{Name: "B"},
		{Name: "C"},
	}

	for _, t := range mapt {
		defer t.hello()
		defer t.hello2()
	}
}

The output:

pointer: C
Hello, C
pointer: C
Hello, B
pointer: C
Hello, A

What I understood is that the pointer t will be pointed to "C" after 3 loops thus three 3 "C"s for "hello2" output. However, the behavior of deferred "hello" function call is very curious. It looked like it was preserving where it was pointing to. How does (t Test) affect this?

I'm very curious about what Golang compiles this into. Thank you so much!

Inside the for-loop, the argument to the defer statement is a closure. The closure captures the loop variable t.

For the call that uses the value receiver, the closure includes a copy of t. For the call that uses the pointer receiver, the closure includes a pointer to t.

Loop variables are rewritten at every iteration (this behavior will be changed in a later version of the language). Because of this, the value receiver closures capture every value, wheres the pointer receiver closures only capture the pointer, thus, when run, they work with the latest value of that pointer.