Семантика перемещения C++ и вызов функции

Я обновляю свои навыки C++ и заново изучаю семантику движений. Вот пример программы и вывод, который я не могу понять.

#include <iostream>
#include <iomanip>

int sepI = 0;
void printSep(const char* msg) {
    std::cout
        << std::setw(40) << std::setfill('>') << "" << std::setfill(' ')
        << std::setw(2) << std::setiosflags(std::ios::right) << sepI++ << ": " << std::resetiosflags(std::ios::right)
        << std::setiosflags(std::ios::left) << msg << std::resetiosflags(std::ios::left)
        << std::endl;
}

void printHook(const char* msg, void* p) {
    std::cout
        << std::setw(25) << std::setiosflags(std::ios::left) << msg << std::resetiosflags(std::ios::left)
        << std::setw(15) << std::setiosflags(std::ios::right) << p << std::resetiosflags(std::ios::right)
        << std::endl;
}

class MyT {
public:
    MyT() { printHook("constructor call", this); }
    MyT(MyT& t) { printHook("copy constructor call", this); }
    MyT(MyT&& t) { printHook("move constructor call", this); }

    ~MyT() { printHook("destructor call", this); v = 0; }

    MyT& operator=(MyT& t) { printHook("copy assigment call", this); return *this; }
    MyT& operator=(MyT&& t) { printHook("move assigment call", this); return *this; }

    int v = 1;
};

MyT fn() { return MyT(); }

int main() {
    printSep("a");
    MyT a;

    printSep("MyT&& v1 = std::move(a)");

    MyT&& v1 = std::move(a);
    std::cout << v1.v << " " << &v1 << std::endl;

    printSep("MyT&& v2 = MyT()");

    MyT&& v2 = MyT();
    std::cout << v2.v << " " << &v2 << std::endl;

    printSep("MyT&& v3 = std::move(MyT())");

    MyT&& v3 = std::move(MyT());
    std::cout << v3.v << " " << &v3 << std::endl;

    printSep("MyT&& v4 = fn()");

    MyT&& v4 = fn();
    std::cout << v4.v << " " << &v4 << std::endl;

    printSep("MyT&& v5 = std::move(fn())");

    MyT&& v5 = std::move(fn());
    std::cout << v5.v << " " << &v5 << std::endl;

    printSep("end");

    return 0;
}

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0: a                            OK.
constructor call          0x7ffe656eeae0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 1: MyT&& v1 = std::move(a)      OK. Makes sense.
1 0x7ffe656eeae0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2: MyT&& v2 = MyT()             OK. Makes sense.
constructor call          0x7ffe656eeae8
1 0x7ffe656eeae8
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3: MyT&& v3 = std::move(MyT())  NOT OK.
constructor call          0x7ffe656eeaec
destructor call           0x7ffe656eeaec
1 0x7ffe656eeaec
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 4: MyT&& v4 = fn()              NOT OK.
constructor call          0x7ffe656eeaf0
1 0x7ffe656eeaf0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 5: MyT&& v5 = std::move(fn())   NOT OK.
constructor call          0x7ffe656eeaf4
destructor call           0x7ffe656eeaf4
1 0x7ffe656eeaf4
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6: end
destructor call           0x7ffe656eeaf4
destructor call           0x7ffe656eeaf0
destructor call           0x7ffe656eeae8
destructor call           0x7ffe656eeae0

Вопросы к шагам 3, 4, 5.

3
Что здесь происходит?
Почему это не то же самое, что и в шаге 2?
Как так получилось, что по одному и тому же адресу 0x7ffe656eeaec мы звонили в constructor - destructor - print цепочку и не получили segfault?\

4 и 5
Откуда была выделена память?
Как мы получили 2 разных адреса экземпляра MyT из нединамических распределений в fn() вызовах?
Это зарезервированная память для статических вызовов? Или они тогда размещаются в стеке? Например, компилятор видит, что это локальные переменные, и резервирует области памяти программы для таких вещей. Но я изучил дизассемблирование, и это был обычный вызов функции. Я не мог проверить это на динамических данных, так как я не могу создать массив rvalues.\

Неважно, какие флаги оптимизации я устанавливаю, результат один и тот же. Но вот команда сборки:

g++ -std=c++17 -g -Wall -O3 -pedantic

Обновление 1: уменьшен пример кода.