Linq equivalent of T-SQL with statement

Question

I have the following data:

I have the following T-SQL statement:

with acc as 
(
    select 
        acc_number,
        acc_parent,
        acc_number as [root],
        balance
    from 
        accounts
    where 
        acc_parent is null

    union all

    select 
        a.acc_number,
        a.acc_parent,
        acc.[root],
        a.balance
    from 
        accounts a
    inner join 
        acc on a.acc_parent = acc.acc_number
    where 
        a.acc_parent is not null
)
select 
    max([root]) as acc_number,
    sum(balance) as balance
from 
    acc
group by 
    [root];

I'd like to translate this into a Linq expression.

My attempt was

using (AccountsContext context = new AccountsContext())
{
    var roots = context.Accounts
        .Where(r => r.acc_parent == null)
        .Select(r => new
        {
            r.acc_number, 
            r.acc_parent, 
            r.balance
        });
    var accounts = context.Accounts
            .Where(a => a.acc_parent != null)
            .Select(a => new
            {
                a.acc_number, 
                a.acc_parent, 
                a.balance
            });
    var union = roots.Union(accounts)
        .Select(u => new
        {
            u.acc_number,
            u.acc_parent,
            u.balance
        });
    var join = union.Join(roots, u => u.acc_parent, r => r.acc_number, (a, r) => new {a, r})
        .Select(t => new
        {
            t.a.acc_number,
            t.a.acc_parent,
            root = t.r.acc_number,
            t.a.balance
        });
    var all = join.GroupBy(g => new { g.root }) // edited
                .Select(g => new
                {
                    acc_number = g.Key.root,
                    balance = g.Sum(x => x.balance ?? 0)
                })
        .ToList();
}

where Account is:

public class Account
{
    public Account()
    {
    }

    [Key]
    public string acc_number { get; set; }
    public decimal? balance { get; set; }

    public string acc_parent { get; set; }
    public virtual Account parent { get; set; }

    public virtual ICollection<Account> accounts { get; set; }
}

And AccountsContext is:

public class AccountsContext : DbContext
{
    public AccountsContext() : base("localhost")
    {
    }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Entity<Account>()
            .HasOptional(e => e.parent)
            .WithMany(e => e.accounts)
            .HasForeignKey(e => e.acc_parent);
    }

    public DbSet<Account> Accounts { get; set; }
}

The expected result should be:

01 > 200
05 > 100
07 > 230

When I use the SQL statement, I get the results correctly but when I use the Linq expression, It misses one account, account 04, because I get:

01 => 100
05 => 100
07 => 230