Dart event loop: understanding why such order print (Case 4) - flutter

Question

There is the following code:
Case 1. Basic Example
Future<void> main() async {
print('A');
await Future(
() {
print('C');
Future(() => print('D'));
Future(() => print('E')).then((value) => print('F'));
Future.microtask(() => print('W'));
Future.microtask(() => print('Z'));
print('G');
},
);
print('B');
}
Output: A C G B W Z D E F
"A" will appear on the screen first, since this is a synchronous operation that is performed sequentially.
Next, Future with the await keyword (line 4), which means that we transfer control to the scope of the function inside the Future (lines 5 - 12). The code below a function marked with await will not execute until the function returns some result.
Inside the Future (line 4) we see the output "C", then four Futures with the output of other letters and the output "G".
"C" will be output first, since this is a synchronous operation.
Futures (lines 7 - 10) are scheduled for the next iteration of the event loop because we didn't mark them with the await keyword.
Next, "G" will be displayed.
The function inside the Future on line 4 returned a result, so control returns to the main function, where the output "B" is left, which is successfully executed.
After the end of the main function, the next iteration of the event loop begins and first the microtask queue is checked, and then the event queue.
In the previous iteration of the event loop, microtasks were scheduled (lines 9, 10), which are successfully executed in the order in which they were scheduled and will display "W" and "Z".
Next, the event queue begins to clear, in which there are functions from Future (lines 7, 8). The Future (line 8) also has a "then" callback that will be executed when the Future succeeds. Accordingly, the letters D E F will be displayed.
Case 2
Future<void> main() async {
print('A');
await Future(
() async {
print('C');
Future(() => print('D'));
await Future(() => print('E')).then((value) => print('F'));
Future.microtask(() => print('W'));
Future.microtask(() => print('Z'));
print('G');
},
);
print('B');
}
Output: A C D E F G B W Z
The letters "DEF" have moved from the end to the middle. This happens because the await keyword automatically redirects us to a new iteration of the event loop where the Future is already scheduled (line 7), and we also transfer control to the scope of the function in the Future (line 8), so the code below will not be executed until the function will return the result.
After its execution, the code will continue to run as in the base example.
Case 3
Future<void> main() async {
print('A');
await Future(
() async {
print('C');
Future(() => print('D'));
Future(() => print('E')).then((value) => print('F'));
Future.microtask(() => print('W'));
await Future.microtask(() => print('Z'));
print('G');
},
);
print('B');
}
Output:A C W Z G B D E F
Await automatically jumps us to the next iteration of the event loop and passes control to the scope of the function we want to wait until it returns a result.
The event loop sees "await" on line 10 and starts executing the queue of microtasks in the order in which they are scheduled and, executing the "Z" microtask, returns control to the scope above, since the function returned the result.
The event loop does not have time to reach the event queue at the iteration with clearing the microtask queue, so the events will remain for the next iteration of the event loop (which will start after the main method is executed).
Case 4
Future<void> main() async {
print('A');
await Future(
() async {
print('C');
Future(() => print('D'));
Future(() => print('E')).then((value) => print('F'));
Future.microtask(() => print('W'));
Future.microtask(() => print('Z'));
print('G');
},
);
print('B');
}
Output: A C G W Z B D E F
Microtasks are displayed before the output "B".
This case was not understood.