draw a umf diagram for this set of ide code
"import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedWriter;
import java.io.IOException;

public class AdminFile {
    
    private String hashedAdminPassword;

    public AdminFile() {
        try {
            // Read the hashed admin password from the admin.txt file
            BufferedReader reader = new BufferedReader(new FileReader("admin.txt"));
            hashedAdminPassword = reader.readLine();
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void login() {
        System.out.println("Welcome Admin");
        String password = Keyboard.readString("Enter password: ");
        while (true) {
            if (Utility.checkPassword(password, hashedAdminPassword)) { // Use Utility.checkPassword() with the hashedAdminPassword
                return;
            } else {
                System.out.println("Incorrect password!");
                password = Keyboard.readString("Enter password: ");
            }
        }
    }

    public static void main(String[] args) {
        try {
            File file = new File("admin.txt");
            if (!file.exists()) {
                FileWriter writer = new FileWriter("admin.txt");
                BufferedWriter bufferedWriter = new BufferedWriter(writer);

                bufferedWriter.write("Username: admin");
                bufferedWriter.newLine();
                bufferedWriter.write("Password: admin");
                bufferedWriter.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

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

public class AdminModule {

  private ArrayList<Player> players;
  private final String PLAYERS_FILENAME = "players.bin";
  
  public AdminModule() {
    players = new ArrayList<Player>();
    loadPlayers();
  }
  
  public void login() {
    System.out.println("Welcome Admin");
    try {
      File file = new File("admin.txt");
      Scanner reader = new Scanner(file);
      while(reader.hasNextLine()) {
        String line = reader.nextLine();
        System.out.println("Password: "+line);
      }
      reader.close();
      
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    }
    System.out.println("Players information loaded");
  }

  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(EOFException ex) {
          endOfFile = true;
        }
      }
    }catch(ClassNotFoundException ex) {
      System.out.println("ClassNotFoundException");
    }catch(FileNotFoundException ex) {
      System.out.println("FileNotFoundException");
    }catch(IOException ex) {
      System.out.println("IOException");
    }
  }
  
  private void displayPlayers() {
    for(Player player: players) {
      player.display();
    }
  }
  
  private void updatePlayersChip() {
      String playerName = Keyboard.readString("Issuing chips, please enter the player name to issue chips to: ");
      Player player = getPlayerName(playerName);
      if (player == null) {
          System.out.println("Error: no player with that name exists");
          return;
      }
      int chips = Keyboard.readInt("Enter the number of chips to issue: ");
      player.addChips(chips);
      System.out.println("Chips issued");
  }
  
  private void createNewPlayer() {
    String playerName = Keyboard.readString("Creating a new player, please enter new player name: ");
    if (getPlayerName(playerName) != null) {
            System.out.println("Error: a player with that name already exists");
            return;
        }
    String password = Keyboard.readString("Enter new password: ");
    String passwordHashed = Utility.getHash(password);
    Player player = new Player(playerName,passwordHashed, 100);
    players.add(player);
    System.out.println("Player created");
  }
  
  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) {
      System.out.println("Failed to save players");
    }
  }
  
  private void deletePlayer() {
    String playerName = Keyboard.readString("Deleting a player, please enter player name to delete: ");
    Player player = getPlayerName(playerName);
     if (player == null) {
              System.out.println("Error: no player with that name exists");
              return;
          }
    players.remove(player);
    System.out.println("Player deleted");
  }
  
  private Player getPlayerName(String playerName) {
    for (Player player: players) {
      if (player.getLoginName().equals(playerName)) {
        return player;
      }
    }
    return null;
  }
  
  private void resetPlayerPassword() {
      String playerName = Keyboard.readString("Resetting player password, please enter player name to reset the password for: ");
      Player player = getPlayerName(playerName);
      if (player == null) {
          System.out.println("Error: no player with that name exists");
          return;
      }
      String newPassword = Keyboard.readString("Enter the new password: ");
      String passwordHashed = Utility.getHash(newPassword);
      player.setHashPassword(passwordHashed);
      System.out.println("Password reset");
  }

private void changeAdminPassword() {
      String currentPassword = Keyboard.readString("Resetting admin password, please enter current admin password: ");
      if (!"password1".equals(currentPassword)) {
          System.out.println("Error: incorrect password");
          return;
      }
      String newPassword = Keyboard.readString("Enter new admin password: ");
      String passwordHashed = Utility.getHash(newPassword);
      try {
      FileOutputStream file = new FileOutputStream("admin.txt");
      PrintWriter pw = new PrintWriter(file);
      pw.write(passwordHashed);
      pw.close();
    }catch(IOException ex) {
      System.out.println("Failed to save password");
    }
      System.out.println("Admin password changed");
  }
  
  public void logout() {
    System.out.println("Logging out...Goodbye");
  }
  
  public void run() {
    login();
    displayPlayers();
    createNewPlayer();
    displayPlayers();
    deletePlayer();
    displayPlayers();
    updatePlayersChip();
    displayPlayers();
    resetPlayerPassword();
    displayPlayers();
    changeAdminPassword();
    savePlayersToBin();
    logout();
  }
  
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    new AdminModule().run();
  }
}

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("BlackRanger", "password2", 1000);
    Player player2 = new Player("BlueKnight", "password3", 1500);
    Player player3 = new Player("IcePeak", "password4", 100);
    Player player4 = new Player("GoldDigger", "password5", 2200);
    
    try {
      FileOutputStream file = new FileOutputStream("players.bin");
      ObjectOutputStream opStream = new ObjectOutputStream(file);
      
      opStream.writeObject(player1);
      opStream.writeObject(player2);
      opStream.writeObject(player3);
      opStream.writeObject(player4);
      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.io.EOFException;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

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("================================================================================");

        // Load players from the players.bin file
        ArrayList<Player> players = new ArrayList<Player>();
        try {
            FileInputStream file = new FileInputStream("players.bin");
            ObjectInputStream input = new ObjectInputStream(file);
            Player player;
            while ((player = (Player) input.readObject()) != null) {
                players.add(player);
            }
            input.close();
        } catch (EOFException ex) {
            // End of file
        } catch (IOException | ClassNotFoundException ex) {
        	System.out.println("Exception: " + ex.getMessage());
        }

        String playerLoginName = "";
        String playerPassword = "";
        boolean loggedIn = false;
        Player player = null;

        // Add user authentication
        while (!loggedIn) {
            playerName = Keyboard.readString("Enter Login name > ");
            playerPassword = Keyboard.readString("Enter Password > ");

            for (Player p : players) {
            	if (p.getLoginName().equals(playerLoginName) && p.checkPassword(playerPassword)) {
                    loggedIn = true;
                    player = p;
                    break;
                }
            }

            if (!loggedIn) {
                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.*;

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 showCardsOnHand() {
    System.out.println(getLoginName());
    for(Card card:this.cardsOnHand) {
      System.out.print(card+" ");
    }
    System.out.println();
  }
  
  public ArrayList<Card> getCardsOnHand() {
    return cardsOnHand;
  }

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

  public void addChips(int amount) {
    this.chips+=amount; //no error check
  }
  
  public void deductChips(int amount) {
    this.chips-=amount; //no error check
  }
  
  public void showTotalCardsValue() {
    System.out.println("Value:"+getTotalCardsValue());
  }
  
  public int getTotalCardsValue() {
    int total = 0;
    for(Card card:cardsOnHand) {
      total+=card.getValue();
    }
    return total;
  }
  
  public void display() {
    super.display();
    System.out.println(this.chips);
  }

  public static void main(String[] args) {
    // TODO Auto-generated method stub
    Player player = new Player("IcePeak","password",100);
    Deck deck = new Deck();
    deck.shuffle();
    Card card1 = deck.dealCard();
    Card card2 = deck.dealCard();
    player.addCard(card1);
    player.addCard(card2);
    player.showCardsOnHand();
    player.showTotalCardsValue();
    player.deductChips(10);
    System.out.println(player.getChips());
    player.addChips(20);
    System.out.println(player.getChips());
  }
}

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);
	}
}

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("");
        
    }
    
}"