anchor.diff:  
           // Computes real value, price, and price date for commodities
           // TODO: Propogate real value to parent accounts
  -        // TODO: See FIXMEs
  -        let computeCommodityValues (accountBalances : list<AccountBalance>) (priceDB : SymbolPriceDB) (periodEnd : option<DateTime>) =
  +        // TODO: get rid of yucky side-effects re:
  +        let computeCommodityValues (accountBalances : list<AccountBalance>) (priceDB : SymbolPriceDB) (periodEnd : option<DateTime>) (mainAccounts : Set<string>) =
  +            let accountRealValues = new System.Collections.Generic.Dictionary<string, Amount>()
  +            // TODO: getAccountLineage copied from Parser.toEntryList -- remove duplication if this works
  +            let getAccountLineage (account: string) =
  +                /// Use with fold to get all combinations.
  +                /// ex: if we have a:b:c, returns a list of a:b:c; a:b; a
  +                let combinator (s: string list) (t: string) =
  +                    if not s.IsEmpty then (s.Head + ":" + t) :: s else t :: s
  +                account.Split ':'
  +                |> Array.fold combinator []
  +                |> List.rev
  +            let updateAccountRealValues lineage (amount : Amount) =
  +                lineage
  +                |> List.iter (fun account -> match accountRealValues.ContainsKey(account) with
  +                                             | true -> 
  +                                                    let currentAmount = accountRealValues.[account]
  +                                                    accountRealValues.[account] <- { currentAmount with Amount = currentAmount.Amount + amount.Amount }
  +                                             | false ->
  +                                                    accountRealValues.[account] <- amount)
  +            // for each account balance, if it has some commodity, look up price and calculate real value
               let computeValue (accountBalance : AccountBalance) =
  +                let accountLineage = getAccountLineage accountBalance.Account
                   match accountBalance.Commodity with
                   | Some commodity ->
                       match Map.tryFind commodity.Symbol.Value priceDB with
  
positive.code:                             symbolData.Prices
                              |> List.filter (fun symbolPrice -> symbolPrice.Date <= if periodEnd.IsSome then periodEnd.Value else symbolPrice.Date)
                              |> List.maxBy (fun symbolPrice -> symbolPrice.Date)
                          { accountBalance with RealBalance = Some { Amount = symbolPrice.Price * commodity.Amount; Symbol = Some "$" }; // FIXME hard-coded symbol
                                                Price = Some { Amount = symbolPrice.Price; Symbol = Some "$" } // FIXME hard-coded symbol
                                                PriceDate = Some symbolPrice.Date;}
                      | None -> accountBalance
                  | None -> 
                      accountBalance
              accountBalances
              |> List.map computeValue
              // for each item in list, if has commodity, look up price and calculate real value
  
  
  
  
negative.code:             |> List.filter (existsChildAccountWithSameAmount accountBalances)
  
          /// Calculate real value, price, and price date for commodities
          let accountBalances = computeCommodityValues accountBalances priceDB filters.PeriodEnd journal.MainAccounts
  
          // calculate total balance
          let totalBalance = 
  