context: using System;
  using System.Collections.Generic;
  using System.Linq;
  using Server.ContextMenus;
  using Server.Items;
  using Server.Network;
  using Server.Accounting;
  using Acc = Server.Accounting.Account;
  using Server.AccountConfiguration;
  
  namespace Server.Mobiles
  {
      public class Banker : BaseVendor
      {
          private readonly List<SBInfo> m_SBInfos = new List<SBInfo>();
          [Constructable]
          public Banker()
              : base("the banker")
          {
          }
  
          public Banker(Serial serial)
              : base(serial)
          {
          }
  
          public override NpcGuild NpcGuild
          {
              get
              {
                  return NpcGuild.MerchantsGuild;
              }
          }
          protected override List<SBInfo> SBInfos
          {
              get
              {
                  return this.m_SBInfos;
              }
          }
          public static int GetBalance(Mobile m)
          {
              double balance = 0;
  
              if (AccountGold.Enabled && m.Account != null)
              {
                  int goldStub;
                  m.Account.GetGoldBalance(out goldStub, out balance);
  
                  if (balance > Int32.MaxValue)
                  {
                      return Int32.MaxValue;
                  }
              }
  
              Container bank = m.FindBankNoCreate();
  
              if (bank != null)
              {
                  var gold = bank.FindItemsByType<Gold>();
                  var checks = bank.FindItemsByType<BankCheck>();
  
                  balance += gold.Aggregate(0.0, (c, t) => c + t.Amount);
                  balance += checks.Aggregate(0.0, (c, t) => c + t.Worth);
              }
  
              return (int)Math.Max(0, Math.Min(Int32.MaxValue, balance));
          }
  
          public static int GetBalance(Mobile m, out Item[] gold, out Item[] checks)
          {
              double balance = 0;
  
              if (AccountGold.Enabled && m.Account != null)
              {
                  int goldStub;
                  m.Account.GetGoldBalance(out goldStub, out balance);
  
                  if (balance > Int32.MaxValue)
                  {
                      gold = checks = new Item[0];
                      return Int32.MaxValue;
                  }
              }
  
              Container bank = m.FindBankNoCreate();
  
              if (bank != null)
              {
                  gold = bank.FindItemsByType(typeof(Gold));
                  checks = bank.FindItemsByType(typeof(BankCheck));
  
                  balance += gold.OfType<Gold>().Aggregate(0.0, (c, t) => c + t.Amount);
                  balance += checks.OfType<BankCheck>().Aggregate(0.0, (c, t) => c + t.Worth);
              }
              else
              {
                  gold = checks = new Item[0];
              }
  
              return (int)Math.Max(0, Math.Min(Int32.MaxValue, balance));
          }
  
          public static bool Withdraw(Mobile from, int amount)
          {
              // If for whatever reason the TOL checks fail, we should still try old methods for withdrawing currency.
              if (AccountGold.Enabled && from.Account != null && from.Account.WithdrawGold(amount))
              {
                  return true;
              }
  
              Item[] gold, checks;
              var balance = GetBalance(from, out gold, out checks);
  
              if (balance < amount)
              {
                  return false;
              }
  
              for (var i = 0; amount > 0 && i < gold.Length; ++i)
              {
                  if (gold[i].Amount <= amount)
                  {
                      amount -= gold[i].Amount;
                      gold[i].Delete();
                  }
                  else
                  {
                      gold[i].Amount -= amount;
                      amount = 0;
                  }
              }
  
              for (var i = 0; amount > 0 && i < checks.Length; ++i)
              {
                  var check = (BankCheck)checks[i];
  
                  if (check.Worth <= amount)
                  {
                      amount -= check.Worth;
                      check.Delete();
                  }
                  else
                  {
                      check.Worth -= amount;
                      amount = 0;
                  }
              }
  
              return true;
          }
  
          public static bool Deposit(Mobile from, int amount)
          {
              // If for whatever reason the TOL checks fail, we should still try old methods for depositing currency.
              if (AccountGold.Enabled && from.Account != null && from.Account.DepositGold(amount))
              {
                  return true;
              }
  
              var box = from.FindBankNoCreate();
  
              if (box == null)
              {
                  return false;
              }
  
              var items = new List<Item>();
  
              while (amount > 0)
              {
                  Item item;
                  if (amount < 5000)
                  {
                      item = new Gold(amount);
                      amount = 0;
                  }
                  else if (amount <= 1000000)
                  {
                      item = new BankCheck(amount);
                      amount = 0;
                  }
                  else
                  {
                      item = new BankCheck(1000000);
                      amount -= 1000000;
                  }
  
                  if (box.TryDropItem(from, item, false))
                  {
                      items.Add(item);
                  }
                  else
                  {
                      item.Delete();
                      foreach (var curItem in items)
                      {
                          curItem.Delete();
                      }
  
                      return false;
                  }
              }
  
              return true;
          }
  
          public static int DepositUpTo(Mobile from, int amount)
          {
              // If for whatever reason the TOL checks fail, we should still try old methods for depositing currency.
              if (AccountGold.Enabled && from.Account != null && from.Account.DepositGold(amount))
              {
                  return amount;
              }
  
              var box = from.FindBankNoCreate();
  
              if (box == null)
              {
                  return 0;
              }
  
              var amountLeft = amount;
              while (amountLeft > 0)
              {
                  Item item;
                  int amountGiven;
  
                  if (amountLeft < 5000)
                  {
                      item = new Gold(amountLeft);
                      amountGiven = amountLeft;
                  }
                  else if (amountLeft <= 1000000)
                  {
                      item = new BankCheck(amountLeft);
                      amountGiven = amountLeft;
                  }
                  else
                  {
                      item = new BankCheck(1000000);
                      amountGiven = 1000000;
                  }
  
                  if (box.TryDropItem(from, item, false))
                  {
                      amountLeft -= amountGiven;
                  }
                  else
                  {
                      item.Delete();
                      break;
                  }
              }
  
              return amount - amountLeft;
          }
  
          public static void Deposit(Container cont, int amount)
          {
  
gt:             while (amount > 0)