class ATM:
    def __init__(self, initial_balance=0, available_denominations=[20, 50, 100]):
        self.account_balance = initial_balance
        self.cash_available = {
            20: 100, 
            50: 50,  
            100: 20   
        }
        self.available_denominations = available_denominations
        self.pin = "1234"

    def check_balance(self, entered_pin):
        if entered_pin == self.pin:
            return self.account_balance
        else:
            return "Incorrect PIN"

    def withdraw(self, amount, entered_pin):
        if entered_pin != self.pin:
            return "Incorrect PIN"

        if amount <= 0:
            return "Invalid amount"

        if amount > self.account_balance:
            return "Insufficient funds in account"

        if amount > self.calculate_total_cash_available():
            return "Insufficient funds in ATM"

        if amount % min(self.available_denominations) != 0:
            return "Amount must be a multiple of available denominations"

        dispensed_cash = self.dispense_cash(amount)

        if dispensed_cash is None:
            return "Cannot dispense exact amount with available denominations"

        self.account_balance -= amount
        return dispensed_cash

    def deposit(self, amount, entered_pin):
        if entered_pin != self.pin:
            return "Incorrect PIN"

        if amount <= 0:
            return "Invalid deposit amount"

        self.account_balance += amount
        return "Deposit successful"

    def change_pin(self, old_pin, new_pin):
        if old_pin != self.pin:
            return "Incorrect PIN"
        if len(new_pin) != 4 or not new_pin.isdigit():
            return "Invalid new PIN. Must be 4 digits."

        self.pin = new_pin
        return "PIN changed successfully"

    def dispense_cash(self, amount):
        cash_to_dispense = {}
        remaining_amount = amount

        # Iterate through denominations from largest to smallest
        for denomination in sorted(self.available_denominations, reverse=True):
            while remaining_amount >= denomination and self.cash_available[denomination] > 0:
                if denomination not in cash_to_dispense:
                    cash_to_dispense[denomination] = 0
                cash_to_dispense[denomination] += 1
                remaining_amount -= denomination
                self.cash_available[denomination] -= 1

        if remaining_amount == 0:
            return cash_to_dispense
        else:
            self.replenish_cash(cash_to_dispense)
            return None

    def calculate_total_cash_available(self):
        total = 0
        for denomination, count in self.cash_available.items():
            total += denomination * count
        return total

    def replenish_cash(self, dispensed_cash):
        # If dispensing fails, restore the cash
        for denomination, count in dispensed_cash.items():
            self.cash_available[denomination] += count

def brute_force_atm_testing():
    atm = ATM(initial_balance=500)

    # Test valid balance check
    print(f"Initial balance: {atm.check_balance('1234')}
")

    # Test invalid PIN during balance check
    print(f"Balance check with wrong pin: {atm.check_balance('0000')}
")

    # Test valid withdrawal
    withdrawal_amount = 100
    withdrawal_result = atm.withdraw(withdrawal_amount, "1234")
    print(f"Withdrawal of ${withdrawal_amount}: {withdrawal_result}
")

    # Test insufficient funds withdrawal
    withdrawal_amount = 1000
    withdrawal_result = atm.withdraw(withdrawal_amount, "1234")
    print(f"Withdrawal of ${withdrawal_amount} (insufficient funds): {withdrawal_result}
")

    # Test changing the pin successfully
    print(f"Changing pin: {atm.change_pin('1234', '5678')}
")

    # Test deposit
    deposit_amount = 200
    deposit_result = atm.deposit(deposit_amount, "5678")
    print(f"Deposit of ${deposit_amount}: {deposit_result}
")

    # Test invalid pin for deposit
    deposit_amount = 200
    deposit_result = atm.deposit(deposit_amount, "1234")
    print(f"Deposit of ${deposit_amount} with invalid pin: {deposit_result}
")

brute_force_atm_testing()

class ATMMachine:
    def __init__(self, initial_balance=0):
        self.account_balance = initial_balance
        self.transaction_log = []

    def check_balance(self, pin_number):
        if self._verify_pin(pin_number):
            return self.account_balance
        else:
            return "Incorrect PIN."

    def deposit(self, amount, pin_number):
        if self._verify_pin(pin_number):
            if amount > 0:
                self.account_balance += amount
                self.transaction_log.append(f"Deposit: +${amount}")
                return f"Deposited ${amount}. New balance: ${self.account_balance}"
            else:
                return "Invalid deposit amount."
        else:
            return "Incorrect PIN."

    def withdraw(self, amount, pin_number):
        if self._verify_pin(pin_number):
            if amount > 0 and amount <= self.account_balance:
                self.account_balance -= amount
                self.transaction_log.append(f"Withdrawal: -${amount}")

                # Must update transaction log before returning new balance
                return f"Withdrew ${amount}. New balance: ${self.account_balance}"

            elif amount <= 0:
                return "Invalid withdrawal amount."
            else:

                # Insufficient Funds
                return "Insufficient funds."
        else:
            return "Incorrect PIN."

    def _verify_pin(self, entered_pin):
        correct_pin = "1234"
        return entered_pin == correct_pin

    def get_transaction_log(self):
        return self.transaction_log

# Example Usage
atm = ATMMachine(100)
print(atm.check_balance("1234"))
print(atm.deposit(50, "1234"))

# Must implement pin verification
print(atm.withdraw(20, "1234"))

print(atm.check_balance("1234"))
print(atm.get_transaction_log())