You have been tasked with writing a program for a popular bank that will automate all its incoming transactions (transfer, deposit, and withdraw). The bank has n accounts numbered from 1 to n. The initial balance of each account is stored in a 0-indexed integer array balance, with the (i + 1)th account having an initial balance of balance[i].

Execute all the valid transactions. A transaction is valid if:


	The given account number(s) are between 1 and n, and
	The amount of money withdrawn or transferred from is less than or equal to the balance of the account.


Implement the Bank class:


	Bank(long[] balance) Initializes the object with the 0-indexed integer array balance.
	boolean transfer(int account1, int account2, long money) Transfers money dollars from the account numbered account1 to the account numbered account2. Return true if the transaction was successful, false otherwise.
	boolean deposit(int account, long money) Deposit money dollars into the account numbered account. Return true if the transaction was successful, false otherwise.
	boolean withdraw(int account, long money) Withdraw money dollars from the account numbered account. Return true if the transaction was successful, false otherwise.


&nbsp;
Example 1:

Input
["Bank", "withdraw", "transfer", "deposit", "transfer", "withdraw"]
[[[10, 100, 20, 50, 30]], [3, 10], [5, 1, 20], [5, 20], [3, 4, 15], [10, 50]]
Output
[null, true, true, true, false, false]

Explanation
Bank bank = new Bank([10, 100, 20, 50, 30]);
bank.withdraw(3, 10);    // return true, account 3 has a balance of $20, so it is valid to withdraw $10.
                         // Account 3 has $20 - $10 = $10.
bank.transfer(5, 1, 20); // return true, account 5 has a balance of $30, so it is valid to transfer $20.
                         // Account 5 has $30 - $20 = $10, and account 1 has $10 + $20 = $30.
bank.deposit(5, 20);     // return true, it is valid to deposit $20 to account 5.
                         // Account 5 has $10 + $20 = $30.
bank.transfer(3, 4, 15); // return false, the current balance of account 3 is $10,
                         // so it is invalid to transfer $15 from it.
bank.withdraw(10, 50);   // return false, it is invalid because account 10 does not exist.


&nbsp;
Constraints:


	n == balance.length
	1 &lt;= n, account, account1, account2 &lt;= 105
	0 &lt;= balance[i], money &lt;= 1012
	At most 104 calls will be made to each function transfer, deposit, withdraw.


class Bank:

    def __init__(self, bal: List[int]):
        self.store = bal # storage list

    def transfer(self, a1: int, a2: int, money: int) -> bool:
        try:
            # checking if both accounts exist. and if the transaction would be valid
            if self.store[a1 - 1] >= money and self.store[a2 - 1] >= 0:
                # performing the transaction
                self.store[a1 - 1] -= money
                self.store[a2 - 1] += money
                return True
            else:
                # retrning false on invalid transaction
                return False
        except:
            # returning false when accounts don't exist
            return False

    def deposit(self, ac: int, mn: int) -> bool:
        try:
            # if account exists performing transaction
            self.store[ac - 1] += mn
            return True
        except:
            # returning false when account doesn't exist
            return False

    def withdraw(self, ac: int, mn: int) -> bool:
        try:
            # checking if transaction is valid
            if self.store[ac - 1] >= mn:
                # performing the transaction
                self.store[ac - 1] -= mn
                return True
            else:
                # returning false in case on invalid transaction
                return False
        except:
            # returning false when account doesn't exist
            return False
class Bank {

    int N;
    long[] balance;
    public Bank(long[] balance) {
        this.N = balance.length;
        this.balance = balance;
    }

    public boolean transfer(int account1, int account2, long money) {
        if(account1 < 1 || account1 > N || account2 < 1 || account2 > N || balance[account1 - 1] < money)
            return false;
        balance[account1 - 1] -= money;
        balance[account2 - 1] += money;
        return true;
    }

    public boolean deposit(int account, long money) {
        if(account < 1 || account > N)
            return false;
        balance[account - 1] += money;
        return true;
    }

    public boolean withdraw(int account, long money) {
        if(account < 1 || account > N || balance[account - 1] < money)
            return false;
        balance[account - 1] -= money;
        return true;
    }
}
class Bank {
public:
	vector<long long> temp;
	int n;
	Bank(vector<long long>& balance) {
		temp=balance;
		n=balance.size();
	}

	bool transfer(int account1, int account2, long long money) {
		if(account1<=n && account2<=n && account1>0 && account2>0 && temp[account1-1]>=money){
			temp[account1-1]-=money;
			temp[account2-1]+=money;
			return true;
		}
		return false;
	}

	bool deposit(int account, long long money) {
		if(account>n || account<0)return false;
		temp[account-1]+=money;
		return true;
	}

	bool withdraw(int account, long long money) {
		if(account<=n && account>0 && temp[account-1]>=money){
			temp[account-1]-=money;
			return true;
		}
		return false;
	}
};
/**
 * @param {number[]} balance
 */
var Bank = function(balance) {
   this.arr = balance; 
};

/** 
 * @param {number} account1 
 * @param {number} account2 
 * @param {number} money
 * @return {boolean}
 */
Bank.prototype.transfer = function(account1, account2, money) {
    if (this.arr[account1-1] >= money && this.arr.length >= account1 && this.arr.length >= account2) {
        this.arr[account1-1] -= money;
        this.arr[account2-1] += money;
        return true;
    }
    return false;
};

/** 
 * @param {number} account 
 * @param {number} money
 * @return {boolean}
 */
Bank.prototype.deposit = function(account, money) {
    if (this.arr.length >= account) {
        this.arr[account-1] += money;
        return true;
    }
    return false;
};

/** 
 * @param {number} account 
 * @param {number} money
 * @return {boolean}
 */
Bank.prototype.withdraw = function(account, money) {
    if (this.arr.length >= account && this.arr[account-1] >= money) {
        this.arr[account-1] -= money
        return true;
    }
    return false;
};

/** 
 * Your Bank object will be instantiated and called as such:
 * var obj = new Bank(balance)
 * var param_1 = obj.transfer(account1,account2,money)
 * var param_2 = obj.deposit(account,money)
 * var param_3 = obj.withdraw(account,money)
 */
Simple Bank System