this is my current ide program for high sum card game: "import java.security.MessageDigest;

public class Utility {
    
    public static String getHash(String base)
    {
        String message=""; 
         
        try{
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hash = digest.digest(base.getBytes("UTF-8"));
        StringBuffer hexString = new StringBuffer();

        for (int i = 0; i < hash.length; i++) {
            String hex = Integer.toHexString(0xff & hash[i]);
            if(hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }

        message = hexString.toString();
    
        } catch(Exception ex){
             throw new RuntimeException(ex);
        }
        
        return message;
    }
     
    public static void printLine(int num)
    {
      printLine(num,'-');
    }
     
    public static void printDoubleLine(int num)
    {
        printLine(num,'=');
    }
    
    
    public static void printLine(int num,char pattern)
    {
      for(int i =0;i<num;i++)
      {
          System.out.print(pattern);
      }
      System.out.println("");
        
    }
    
}

import java.util.*;
import java.io.*;

public class Admin {

	private ArrayList<Player> players;
	
	public Admin() {
		players = new ArrayList<Player>();
		loadPlayers();
	}

	private void loadPlayers() {
		try {
			FileInputStream file = new FileInputStream(PLAYERS_FILENAME);
			ObjectInputStream output = new ObjectInputStream(file);
			
			boolean endOfFile = false;
			while(endOfFile) {
				try {
					Player player = (Player)output.readObject();
					players.add(player);
				}catch(EOException ex) {
					endOfFile = true;
				}
			}
		}catch(ClassNotFoundException ex) {
			System.out.println("ClassNotFoundException");
		}catch(FileNotFoundException ex) {
			System.out.println("FileNotFoundException");
		}catch(IOException ex) {
			System.out.println("IOException");
		}
		System.out.println("Players information loaded");
	}
	
	private void displayPlayers() {
		for(Player player: players) {
			player.display();
		}
	}
	
	private void updatePlayersChip() {
		for(Player player: players) {
			player.addChips(100);
		}
	}
	
	private void createNewPlayer() {
		int playerNum = players.size()+1;
		Player player = new Player("Player"+playerNum,"Password"+playerNum,100);
		players.add(player);
	}
	
	private void savePlayersToBin() {
		try {
			FileOutputStream file = new FileOutputStream(PLAYERS_FILENAME);
			ObjectOutputStream opStream = new ObjectOutputStream(file);
			
			for(Player player: players) {
				opStream.writeObject(player);
			}
			opStream.close();
		}catch(IOException ex) {
			
		}
	}

	public void run() {
		displayPlayers();
		updatePlayersChip();
		displayPlayers();
		createNewPlayer();
		displayPlayers();
		savePlayersToBin();
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}
}

public class Card {
    private String suit;
    private String name;
    private int value;
    private boolean hidden;

    public Card(String suit, String name, int value) {
        this.suit = suit;
        this.name = name;
        this.value = value;
        this.hidden = false; // Change this line to make cards revealed by default
    }

    public int getValue() {
        return value;
    }

    public void reveal() {
        this.hidden = false;
    }

    public boolean isHidden() {
        return hidden;
    }

    @Override
    public String toString() {
        return this.hidden ? "<HIDDEN CARD>" : "<" + this.suit + " " + this.name + ">";
    }

    public static void main(String[] args) {
        Card card = new Card("Heart", "Ace", 1);
        System.out.println(card);
    }
    
    public void hide() {
        this.hidden = true;
    }
}

import java.io.*;

public class CreatePlayersBin {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Player player1 = new Player("Player1", "Password1", 100);
		Player player2 = new Player("Player2", "Password2", 200);
		Player player3 = new Player("Player3", "Password3", 300);
		
		try {
			FileOutputStream file = new FileOutputStream("players.bin");
			ObjectOutputStream opStream = new ObjectOutputStream(file);
			
			opStream.writeObject(player1);
			opStream.writeObject(player2);
			opStream.writeObject(player3);
			opStream.close();
		}catch(IOException ex) {
			
		}
	}
}

public class Dealer extends Player {
    public Dealer() {
        super("Dealer", "", 0);
    }

    @Override
    public void addCard(Card card) {
        super.addCard(card);
        
        // Hide only the first card for the dealer
        if (cardsOnHand.size() == 1) {
            cardsOnHand.get(0).hide();
        }
    }

    @Override
    public void showCardsOnHand() {
        System.out.println(getLoginName());
        int numCards = cardsOnHand.size();
        for (int i = 0; i < numCards; i++) {
            System.out.print(cardsOnHand.get(i));
            if (i < numCards - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("\n");
    }
    
    public void revealHiddenCard() {
        if (!cardsOnHand.isEmpty()) {
            cardsOnHand.get(0).reveal();
        }
    }
}

import java.util.ArrayList;
import java.util.Random;

public class Deck {
    private ArrayList<Card> cards;

    public Deck() {
        cards = new ArrayList<Card>();
        String[] suits = {"Heart", "Diamond", "Spade", "Club"};
        for (int i = 0; i < suits.length; i++) {
            String suit = suits[i];
            Card card = new Card(suit, "Ace", 1);
            cards.add(card);
            for (int n = 2; n <= 10; n++) {
                Card aCard = new Card(suit, n + "", n);
                cards.add(aCard);
            }
            Card jackCard = new Card(suit, "Jack", 10);
            cards.add(jackCard);
            Card queenCard = new Card(suit, "Queen", 10);
            cards.add(queenCard);
            Card kingCard = new Card(suit, "King", 10);
            cards.add(kingCard);
        }
    }

    public void shuffle() {
        Random random = new Random();
        for (int i = 0; i < 1000; i++) {
            int indexA = random.nextInt(cards.size());
            int indexB = random.nextInt(cards.size());
            Card cardA = cards.get(indexA);
            Card cardB = cards.get(indexB);
            cards.set(indexA, cardB);
            cards.set(indexB, cardA);
        }
    }

    public Card dealCard() {
        return cards.remove(0);
    }
}

import java.util.Scanner;
import java.util.Random;

public class GameModule {
    private static final int NUM_ROUNDS = 4;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("HighSum GAME");
        System.out.println("================================================================================");

        String playerName = "";
        String playerPassword = "";
        boolean loggedIn = false;

        // Add user authentication
        while (!loggedIn) {
            playerName = Keyboard.readString("Enter Login name > ");
            playerPassword = Keyboard.readString("Enter Password > ");
            if (playerName.equals("IcePeak") && playerPassword.equals("password")) {
                loggedIn = true;
            } else {
                System.out.println("Username or Password is incorrect. Please try again.");
            }
        }

        Player player = new Player(playerName, playerPassword, 100);
        Dealer dealer = new Dealer();
        Deck deck = new Deck();

        boolean nextGame = true;
        int betOnTable;
        boolean playerQuit = false; // Add this line

        // Add "HighSum GAME" text after logging in
        System.out.println("================================================================================");
        System.out.println("HighSum GAME");

        while (nextGame) {

            System.out.println("================================================================================");
            System.out.println(playerName + ", You have " + player.getChips() + " chips");
            System.out.println("--------------------------------------------------------------------------------");
            System.out.println("Game starts - Dealer shuffles deck.");

            deck.shuffle();
            dealer.clearCardsOnHand();
            player.clearCardsOnHand();

            // Switch the order of dealer and player to deal cards to the dealer first
            for (int i = 0; i < 2; i++) {
                dealer.addCard(deck.dealCard());
                player.addCard(deck.dealCard());
            }

            betOnTable = 0;

            int round = 1;
            int dealerBet;
            while (round <= NUM_ROUNDS) {
                System.out.println("--------------------------------------------------------------------------------");
                System.out.println("Dealer dealing cards - ROUND " + round);
                System.out.println("--------------------------------------------------------------------------------");

                // Show dealer’s cards first, then player’s cards
                if (round == 2) {
                    dealer.addCard(deck.dealCard());
                    player.addCard(deck.dealCard());
                }

                dealer.showCardsOnHand();
                player.showCardsOnHand();
                System.out.println("Value: " + player.getTotalCardsValue());

                if (round > 1) {
                    dealer.addCard(deck.dealCard());
                    player.addCard(deck.dealCard());
                }

                if (round == 4) {
                    dealer.revealHiddenCard();
                }

                if (round >= 2) {
                    if (player.getTotalCardsValue() > dealer.getTotalCardsValue()) {
                        boolean validChoice = false;
                        while (!validChoice) {
                            String prompt = (round == 2) ? "Do you want to follow? [Y/N]: " : "Player call, do you want to [C]all or [Q]uit?: ";
                            String choice = Keyboard.readString(prompt).toLowerCase();
                            if (choice.equals("c") || choice.equals("y")) {
                                validChoice = true;
                                int playerBet = Keyboard.readInt("Player, state your bet > ");

                                // Check for invalid bet conditions
                                if (playerBet > 100) {
                                    System.out.println("Insufficient chips");
                                    validChoice = false;
                                } else if (playerBet <= 0) {
                                    System.out.println("Invalid bet");
                                    validChoice = false;
                                } else {
                                    betOnTable += playerBet;
                                    player.deductChips(playerBet);
                                    System.out.println("Player call, state bet: " + playerBet);
                                    System.out.println(playerName + ", You are left with " + player.getChips() + " chips");
                                    System.out.println("Bet on table: " + betOnTable);
                                    round++;
                                }
                            } else if (choice.equals("q") || choice.equals("n")) {
                                validChoice = true;
                                nextGame = false;
                                round = NUM_ROUNDS + 1;
                                playerQuit = true; // Add this line

                                // Give all the current chips bet to the dealer and the dealer wins
                                System.out.println("Since the player has quit, all the current chips bet goes to the dealer.");
                                System.out.println("Dealer Wins");
                                break;
                            }
                        }
                    } else {
                        dealerBet = Math.min(new Random().nextInt(11), 10);
                        betOnTable += dealerBet;
                        System.out.println("Dealer call, state bet: " + dealerBet);
                        System.out.println(playerName + ", You are left with " + player.getChips() + " chips");
                        System.out.println("Bet on table: " + betOnTable);
                        round++;
                    }
                } else {
                    dealerBet = 10;
                    betOnTable += dealerBet;
                    player.deductChips(dealerBet);
                    System.out.println("Dealer call, state bet: " + dealerBet);
                    System.out.println(playerName + ", You are left with " + player.getChips() + " chips");
                    System.out.println("Bet on table: " + betOnTable);
                    round++;
                }
            }

            // Determine the winner after the game ends
            if (!playerQuit) { // Add this line
                System.out.println("--------------------------------------------------------------------------------");
                System.out.println("Game End - Dealer reveal hidden cards");
                System.out.println("--------------------------------------------------------------------------------");
                dealer.showCardsOnHand();
                System.out.println("Value: " + dealer.getTotalCardsValue());
                player.showCardsOnHand();
                System.out.println("Value: " + player.getTotalCardsValue());
                if (player.getTotalCardsValue() > dealer.getTotalCardsValue()) {
                    System.out.println(playerName + " Wins");
                    player.addChips(betOnTable);
                } else {
                    System.out.println("Dealer Wins");
                }
                System.out.println(playerName + ", You have " + player.getChips() + " chips");
                System.out.println("Dealer shuffles used cards and place behind the deck.");
                System.out.println("--------------------------------------------------------------------------------");
            } // Add this line

            boolean valid = false;
            while (!valid) {
                String input = Keyboard.readString("Next Game? (Y/N) > ").toLowerCase();
                if (input.equals("y")) {
                    playerQuit = false; // Add this line
                    nextGame = true;
                    valid = true;
                } else if (input.equals("n")) {
                    nextGame = false;
                    valid = true;
                } else {
                    System.out.println("*** Please enter Y or N ");
                }
            }
        }
    }
}

public class Keyboard {

	public static String readString(String prompt) {
		System.out.print(prompt);
		return new java.util.Scanner(System.in).nextLine();
	}

	public static int readInt(String prompt) {
		int input = 0;
		boolean valid = false;
		while (!valid) {
			try {
				input = Integer.parseInt(readString(prompt));
				valid = true;
			} catch (NumberFormatException e) {
				System.out.println("*** Please enter an integer ***");
			}
		}
		return input;
	}

	public static double readDouble(String prompt) {
		double input = 0;
		boolean valid = false;
		while (!valid) {
			try {
				input = Double.parseDouble(readString(prompt));
				valid = true;
			} catch (NumberFormatException e) {
				System.out.println("*** Please enter a double ***");
			}
		}
		return input;
	}

	public static float readFloat(String prompt) {
		float input = 0;
		boolean valid = false;
		while (!valid) {
			try {
				input = Float.parseFloat(readString(prompt));
				valid = true;
			} catch (NumberFormatException e) {
				System.out.println("*** Please enter a float ***");
			}
		}
		return input;
	}

	public static long readLong(String prompt) {
		long input = 0;
		boolean valid = false;
		while (!valid) {
			try {
				input = Long.parseLong(readString(prompt));
				valid = true;
			} catch (NumberFormatException e) {
				e.printStackTrace();
				System.out.println("*** Please enter a long ***");
			}
		}
		return input;
	}

	public static char readChar(String prompt) {
		char input = 0;
		boolean valid = false;
		while (!valid) {
			String temp = readString(prompt);
			if (temp.length() != 1) {
				System.out.println("*** Please enter a character ***");
			} else {
				input = temp.charAt(0);
				valid = true;
			}
		}
		return input;
	}

	public static boolean readBoolean(String prompt) {
		boolean valid = false;
		while (!valid) {
			String input = readString(prompt);
			if (input.equalsIgnoreCase("yes") || input.equalsIgnoreCase("y") || input.equalsIgnoreCase("true")
					|| input.equalsIgnoreCase("t")) {
				return true;
			} else if (input.equalsIgnoreCase("no") || input.equalsIgnoreCase("n") || input.equalsIgnoreCase("false")
					|| input.equalsIgnoreCase("f")) {
				return false;
			} else {
				System.out.println("*** Please enter Yes/No or True/False ***");
			}
		}
		return false;
	}

	public static java.util.Date readDate(String prompt) {
		java.util.Date date = null;
		boolean valid = false;
		while (!valid) {
			try {
				String input = readString(prompt).trim();
				if (input.matches("\\d\\d/\\d\\d/\\d\\d\\d\\d")) {
					int day = Integer.parseInt(input.substring(0, 2));
					int month = Integer.parseInt(input.substring(3, 5));
					int year = Integer.parseInt(input.substring(6, 10));
					java.util.Calendar cal = java.util.Calendar.getInstance();
					cal.setLenient(false);
					cal.set(year, month - 1, day, 0, 0, 0);
					date = cal.getTime();
					valid = true;
				} else {
					System.out.println("*** Please enter a date (DD/MM/YYYY) ***");
				}
			} catch (IllegalArgumentException e) {
				System.out.println("*** Please enter a date (DD/MM/YYYY) ***");
			}
		}
		return date;
	}

	private static String quit = "0";

	public static int getUserOption(String title, String[] menu) {
		displayMenu(title, menu);
		int choice = Keyboard.readInt("Enter Choice --> ");
		while (choice > menu.length || choice < 0) {
			choice = Keyboard.readInt("Invalid Choice, Re-enter --> ");
		}
		return choice;
	}

	private static void displayMenu(String title, String[] menu) {
		line(80, "=");
		System.out.println(title.toUpperCase());
		line(80, "-");
		for (int i = 0; i < menu.length; i++) {
			System.out.println("[" + (i + 1) + "] " + menu[i]);
		}
		System.out.println("[" + quit + "] Quit");
		line(80, "-");
	}

	public static void line(int len, String c) {
		System.out.println(String.format("%" + len + "s", " ").replaceAll(" ", c));
	}
}

import java.util.ArrayList;

public class Player extends User {
    private int chips;
    protected ArrayList<Card> cardsOnHand;

    public Player(String loginName, String password, int chips) {
        super(loginName, password);
        this.chips = chips;
        this.cardsOnHand = new ArrayList<Card>();
    }

    public void addCard(Card card) {
        this.cardsOnHand.add(card);
    }
    
    public void display() {
        super.display();
        System.out.println(this.chips);
      }

    public void showCardsOnHand() {
        System.out.println(getLoginName());
        int numCards = cardsOnHand.size();
        for (int i = 0; i < numCards; i++) {
            if (i < numCards - 1) {
                System.out.print(cardsOnHand.get(i) + ", ");
            } else {
                System.out.print(cardsOnHand.get(i));
            }
        }
        System.out.println("\n");
    }

    public int getChips() {
        return this.chips;
    }

    public void addChips(int amount) {
        this.chips += amount;
    }

    public void deductChips(int amount) {
        if (amount < chips)
            this.chips -= amount;
    }

    public int getTotalCardsValue() {
        int totalValue = 0;
        for (Card card : cardsOnHand) {
            totalValue += card.getValue();
        }
        return totalValue;
    }

    public int getNumberOfCards() {
        return cardsOnHand.size();
    }

    public void clearCardsOnHand() {
        cardsOnHand.clear();
    }
}

import java.io.Serializable;

abstract public class User implements Serializable {

	private static final long serialVersionUID = 1L;
	private String loginName;
	private String hashPassword; //plain password
	
	public User(String loginName, String password) {
		this.loginName = loginName;
		this.hashPassword = Utility.getHash(password);
	}

	public String getLoginName() {
		return loginName;
	}

	public boolean checkPassword(String password) {
		return this.hashPassword.equals(Utility.getHash(password));
	}
	
	public void display() {
		System.out.println(this.loginName+","+this.hashPassword);
	}
}"

edit it so that it folllows the follwing requirements: "Develop a Java program for the HighSum game Administration module.
Administration Module
This module allows the administor to
1. Create a player
2. Delete a player
3. View all players
4. Issue more chips to a player
5. Reset player’s password
6. Change administrator’s password
7. Logout
This module will have access to two files (admin.txt and players.bin)
The first text file (admin.txt) contains the administrator hashed password (SHA-256).
For example
0b14d501a594442a01c6859541bcb3e8164d183d32937b851835442f69d5c94e
Note: Refer Reference and Utility.java function getHash() function
Page 2
Copyright SCIT, University of Wollongong, 2023
The second text file (players.bin) contains the following players object information in a binary
serialized file.
• Login Name
• Password in SHA-256
• Chips
Login Name Password in SHA-256 Chips
BlackRanger 6cf615d5bcaac778352a8f1f3360d23f02f34ec182e259897fd6ce485d7870d4 1000
BlueKnight 5906ac361a137e2d286465cd6588ebb5ac3f5ae955001100bc41577c3d751764 1500
IcePeak b97873a40f73abedd8d685a7cd5e5f85e4a9cfb83eac26886640a0813850122b 100
GoldDigger 8b2c86ea9cf2ea4eb517fd1e06b74f399e7fec0fef92e3b482a6cf2e2b092023 2200
Game play module
Modify Assignment 1 HighSum Game module such that the Player data is read from the binary file
players.bin. And different players are able to login to the GameModule.
"