Appending to two slice with same underlying array, why the result?

Here is a code snippet from some Go book.

func incr(s []int) {
	s = append(s, 0)
	for i := range s {
		s[i]++
	}
}

func main() {
	s1 := []int{1, 2}
	s2 := s1
	s2 = append(s2, 3)

	incr(s1)
	incr(s2)

	fmt.Print(s1, s2) // "[1, 2][2, 3, 4]"
}

I don't understand why the result is "[1, 2][2, 3, 4]".

Based on two points from <https://golang.org/doc/effective_go#slices>:
> Slices hold references to an underlying array, and if you assign one slice to another, both refer to the same array

> If a function takes a slice argument, changes it makes to the elements of the slice will be visible to the caller, analogous to passing a pointer to the underlying array

Here is what I imagined should happen:

1. At first, both s1 and s2's have the same underlying array [1, 2]
2. After appending 3 to s2, the underlying array changed to [1, 2, 3]. But s1 still only see [1, 2]
3. After incr(s1), s1 is appended 0 and all item incremented, resulting s1 into [2, 3, 1]. The appending also changed the underlying array, so s2 now see [2, 3, 1]
4. After incr(s2), s2 is appended 0 and all item incremented, resulting s2 into [3, 4, 2, 1]. The increment also affected underlying array, so now s1 see [3, 4, 2]
5. So the result printed should be [3, 4, 2][3, 4, 2, 1]

I obviously have huge mistake understanding slice in Go. Please tell me where I am wrong. It seems my reasoning is in accord with slice's behavior. (I know appending to an insufficient capacity slice will also reallocate an underlying array, but don't know how to fit it into this).

Let's analyze this program step by step:

s1 := []int{1, 2}  // s1 -> [1,2]
s2 := s1           // s1, s2 -> [1,2]

The next operation is:

s2 = append(s2, 3)

This may allocate a new backing array if the capacity of the underlying array is not sufficient. In this case, it will do that to give:

s1 -> [1,2]
s2 -> [1,2,3]

Then incr(s1) will append a new element to s1, increment values, but the resulting slice will not be assigned to s1 in main, so still:

s1 -> [1,2]
s2 -> [1,2,3]

incr(s2) will do the same, but this time, the backing array has the capacity to hold the appended zero, so the increment operation increments the values, but the new slice is never assigned to s2 in main. So, s2 still has 3 elements:

s1 -> [1,2]
s2 -> [2,3,4]

The backing array of s2 has one more element in it, but s2 does not include that element.