log of (2592) query executions

Can some who is very familiar with LINQ help answer my questions about the following LINQ query?

The following code performs a faro shuffle.

// Program.cs
public static void Main(string[] args)
{
    var startingDeck = (from s in Suits().LogQuery("Suit Generation")
                        from r in Ranks().LogQuery("Rank Generation")
                        select new { Suit = s, Rank = r }).LogQuery("Starting Deck");

    foreach (var c in startingDeck)
    {
        Console.WriteLine(c);
    }

    Console.WriteLine();
    var times = 0;
    var shuffle = startingDeck;

    do
    {
        // Out shuffle
                shuffle = shuffle.Take(26)
            .LogQuery("Top Half")
            .InterleaveSequenceWith(shuffle.Skip(26)
            .LogQuery("Bottom Half"))
            .LogQuery("Shuffle");


        foreach (var c in shuffle)
        {
            Console.WriteLine(c);
        }

        times++;
        Console.WriteLine(times);
    } while (!startingDeck.SequenceEquals(shuffle));

    Console.WriteLine(times);
}

1. Why is the order of the (first) execution of the StartingDeck query as follows:
Executing Query Suit Generation
Executing Query Starting Deck
Executing Query Rank Generation
Executing Query Rank Generation
Executing Query Rank Generation
Executing Query Rank Generation

I expected the order to be Suit Generation, Rank, StartingDeck because that is the order in the query:
(from s in Suits().LogQuery("Suit Generation")
                        from r in Ranks().LogQuery("Rank Generation")
                        select new { Suit = s, Rank = r }).LogQuery("Starting Deck");

2. I understand that in each iteration of the do-while loop the queries are executed again and again by reconstructing the deck of cards and reshuffling it every time. But what do these executions look like? For example, in the first iteration of the do-while loop because shuffle points to the same object that startingDeck points to I assume the execution of the shuffle query looks like this:
shuffle = startingDeck.Skip(26).LogQuery("Bottom Half")
                .InterleaveSequenceWith(startingDeck.Take(26).LogQuery("Top Half"))
                .LogQuery("Shuffle");

Or in other words:

shuffle = (from s in Suits().LogQuery("Suit Generation")
                        from r in Ranks().LogQuery("Rank Generation")
                        select new { Suit = s, Rank = r }).LogQuery("Starting Deck").Skip(26).LogQuery("Bottom Half")
                .InterleaveSequenceWith((from s in Suits().LogQuery("Suit Generation")
                        from r in Ranks().LogQuery("Rank Generation")
                        select new { Suit = s, Rank = r }).LogQuery("Starting Deck").Take(26).LogQuery("Top Half"))
                .LogQuery("Shuffle");

However, in the 2nd iteration of the do-while loop, the variable shuffle now stores the query from the previous iteration of the do-while loop, so does the execution of the shuffle query in the 2nd iteration of the do-while loop look like this:

shuffle = (from s in Suits().LogQuery("Suit Generation")
                        from r in Ranks().LogQuery("Rank Generation")
                        select new { Suit = s, Rank = r }).LogQuery("Starting Deck").Skip(26).LogQuery("Bottom Half")
                .InterleaveSequenceWith((from s in Suits().LogQuery("Suit Generation")
                        from r in Ranks().LogQuery("Rank Generation")
                        select new { Suit = s, Rank = r }).LogQuery("Starting Deck").Take(26).LogQuery("Top Half"))
                .LogQuery("Shuffle").Skip(26).LogQuery("Bottom Half")
                .InterleaveSequenceWith((from s in Suits().LogQuery("Suit Generation")
                        from r in Ranks().LogQuery("Rank Generation")
                        select new { Suit = s, Rank = r }).LogQuery("Starting Deck").Skip(26).LogQuery("Bottom Half")
                .InterleaveSequenceWith((from s in Suits().LogQuery("Suit Generation")
                        from r in Ranks().LogQuery("Rank Generation")
                        select new { Suit = s, Rank = r }).LogQuery("Starting Deck").Take(26).LogQuery("Top Half"))
                .LogQuery("Shuffle").Take(26).LogQuery("Top Half"))
                .LogQuery("Shuffle");


/*Bonus questions:

* In the following query, are the iterator methods executed when the query startingDeck is used in the foreach statement, or are they executed when the query is defined (i.e. when program execution reaches the query expression)?

    var startingDeck = (from s in Suits().LogQuery("Suit Generation")
                        from r in Ranks().LogQuery("Rank Generation")
                        select new { Suit = s, Rank = r }).LogQuery("Starting Deck");
* In the following query expression I believe that the query named shuffle is executed when Skip and Take are called. However I want to confirm whether the query named shuffle is executed when Take and Skip are called, or is the query named shuffle executed only when shuffle is used in the foreach statement that follows?
    shuffle = shuffle.Take(26)
            .LogQuery("Top Half")
            .InterleaveSequenceWith(shuffle.Skip(26)
            .LogQuery("Bottom Half"))
            .LogQuery("Shuffle");

If the query named shuffle is executed when Take and Skip are called, then does that mean that Take and Skip are executed twice, first when program execution reaches the query expression named shuffle in the do-while loop, and again in the foreach statement?*/